platform/include/pion/platform/Event.hpp

// ------------------------------------------------------------------------
// Pion is a development platform for building Reactors that process Events
// ------------------------------------------------------------------------
// Copyright (C) 2007-2008 Atomic Labs, Inc.  (http://www.atomiclabs.com)
//
// Pion is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// Pion is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for
// more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with Pion.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef __PION_EVENT_HEADER__
#define __PION_EVENT_HEADER__

#include <list>
#include <vector>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#ifdef _MSC_VER
    #pragma warning(push)
    #pragma warning(disable: 4181) // qualifier applied to reference type
#endif
#include <boost/variant.hpp>
#ifdef _MSC_VER
    #pragma warning(pop)
#endif
#include <boost/thread/once.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/detail/atomic_count.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/intrusive/rbtree_algorithms.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionBlob.hpp>
#include <pion/PionDateTime.hpp>
#include <pion/platform/Vocabulary.hpp>


#ifndef _WIN64
#define PION_EVENT_USE_POOL_ALLOCATORS
#endif

#ifdef PION_EVENT_USE_POOL_ALLOCATORS
    #include <boost/thread/tss.hpp>
    #include <pion/PionPoolAllocator.hpp>
#else
    #include <cstdlib>
#endif


namespace pion {        // begin namespace pion
namespace platform {    // begin namespace platform (Pion Platform Library)

    
template <typename CharType, typename AllocType>
class BasicEvent
    : private boost::noncopyable
{
public:

    struct ParameterNode;
    
    class TermTypeNotSerializableException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "Term type is not serializable";
        }
    };
    

protected:

    template <typename NodeType>
    class IteratorBase :
        public boost::iterator_facade<IteratorBase<NodeType>, NodeType,
            boost::bidirectional_traversal_tag>
    {
    private:
        
        struct enabler {};
        
    public:
        
        IteratorBase(void) { tree_algo::init(&m_param_ptr); }
        
        explicit IteratorBase(NodeType *p) : m_param_ptr(p) {}
        
        template <class OtherNodeType>
        IteratorBase(IteratorBase<OtherNodeType> const& other,
                     typename boost::enable_if<
                        boost::is_convertible<OtherNodeType*,NodeType*>,
                     enabler>::type = enabler()
                     )
            : m_param_ptr(other.m_param_ptr)
        {}
        
    private:
        
        inline void increment(void) {
            m_param_ptr = tree_algo::next_node(const_cast<ParameterNode*>(m_param_ptr));
        }
        
        inline void decrement(void) {
            m_param_ptr = tree_algo::prev_node(const_cast<ParameterNode*>(m_param_ptr));
        }
        
        template <class OtherValue>
        inline bool equal(IteratorBase<OtherValue> const& other) const {
            return this->m_param_ptr == other.m_param_ptr;
        }
        
        NodeType& dereference(void) const {
            return *m_param_ptr;
        }
        
        friend class boost::iterator_core_access;
        
        friend class IteratorBase<const ParameterNode>;
        friend class IteratorBase<ParameterNode>;

        NodeType *      m_param_ptr;
    };


public:

    typedef Vocabulary::TermRef             EventType;
    
    typedef PionBlob<CharType,AllocType>    BlobType;

    typedef typename BlobType::BlobParams   BlobParams;
    
    typedef boost::variant<boost::int32_t, boost::uint32_t,
        boost::int64_t, boost::uint64_t, float, double, long double,
        PionDateTime, BlobType>             ParameterValue;
    
    struct ParameterNode {
        ParameterNode(void) {}
        
        template <typename T>
        ParameterNode(const Vocabulary::TermRef& tr, const T& v) :
            term_ref(tr), value(v)
        {}

        ParameterNode *         m_parent_ptr;
        ParameterNode *         m_left_ptr;
        ParameterNode *         m_right_ptr;
        boost::uint8_t          m_tree_color;

        Vocabulary::TermRef     term_ref;

        ParameterValue          value;
    };
    
    typedef IteratorBase<ParameterNode>         Iterator;

    typedef IteratorBase<ParameterNode const>   ConstIterator;
    
    typedef std::pair<ConstIterator, ConstIterator>
                                                ValuesRange;
    
    BasicEvent(const EventType t, AllocType *alloc_ptr)
        : m_event_type(t), m_alloc_ptr(alloc_ptr), m_references(0)
    {
        // create an empty parameter tree
        tree_algo::init_header(&m_param_tree);
    }
    
    ~BasicEvent() { clear(); }
    
    inline EventType getType(void) const { return m_event_type; }

    inline bool empty(void) const {
        return (tree_algo::begin_node(&m_param_tree) == &m_param_tree);
    }
    
    inline ConstIterator begin(void) const {
        return ConstIterator(tree_algo::begin_node(&m_param_tree));
    }
    
    inline ConstIterator end(void) const {
        return ConstIterator(tree_algo::end_node(&m_param_tree));
    }

    inline void clear(void) {
        tree_algo::clear_and_dispose(&m_param_tree,
            boost::bind(&BasicEvent<CharType,AllocType>::destroyParameter, this, _1));
    }

    inline void clear(const Vocabulary::TermRef& term_ref) {
        ParameterNode *node_ptr;
        std::pair<ParameterNode*, ParameterNode*> range =
            tree_algo::equal_range(&m_param_tree, term_ref, m_key_compare);
        while (range.first != range.second) {
            node_ptr = range.first;
            range.first = tree_algo::next_node(range.first);
            tree_algo::erase(&m_param_tree, node_ptr);
            destroyParameter(node_ptr);
        }
    }

    inline ConstIterator find(const Vocabulary::TermRef& term_ref) const {
        return ConstIterator(tree_algo::find(&m_param_tree, term_ref, m_key_compare));
    }
    
    inline ValuesRange equal_range(const Vocabulary::TermRef& term_ref) const
    {
        std::pair<ParameterNode*, ParameterNode*> range =
            tree_algo::equal_range(&m_param_tree, term_ref, m_key_compare);
        return std::make_pair(Iterator(range.first), Iterator(range.second));
    }

    inline void for_each(boost::function2<void, Vocabulary::TermRef, const ParameterValue&> f) const {
        for (ParameterNode *node_ptr = tree_algo::begin_node(&m_param_tree);
            node_ptr != tree_algo::end_node(&m_param_tree);
            node_ptr = tree_algo::next_node(node_ptr))
        {
            f(node_ptr->term_ref, node_ptr->value);
        }
    }

    inline BasicEvent& operator+=(const BasicEvent& e) {
        ParameterNode *new_param_ptr;
        for (ParameterNode *node_ptr = tree_algo::begin_node(&e.m_param_tree);
            node_ptr != tree_algo::end_node(&e.m_param_tree);
            node_ptr = tree_algo::next_node(node_ptr))
        {
            new_param_ptr = createParameter(node_ptr->term_ref, node_ptr->value);
            tree_algo::insert_equal_upper_bound(&m_param_tree,
                new_param_ptr, m_item_compare);
        }
        return *this;
    }

    inline void copyValues(const BasicEvent& e, const Vocabulary::TermRef& term_ref)
    {
        std::pair<ParameterNode*, ParameterNode*> range =
            tree_algo::equal_range(&e.m_param_tree, term_ref, e.m_key_compare);
        ParameterNode *new_param_ptr;
        while (range.first != range.second) {
            new_param_ptr = createParameter(range.first->term_ref, range.first->value);
            tree_algo::insert_equal_upper_bound(&m_param_tree,
                new_param_ptr, m_item_compare);
            range.first = tree_algo::next_node(range.first);
        }
    }
    
    inline const ParameterValue *getPointer(const Vocabulary::TermRef& term_ref) const {
        const ParameterNode *node_ptr = tree_algo::find(&m_param_tree, term_ref, m_key_compare);
        return (node_ptr==&m_param_tree ? NULL : &(node_ptr->value));
    }
    
    inline bool isDefined(const Vocabulary::TermRef& term_ref) const {
        return (tree_algo::find(&m_param_tree, term_ref, m_key_compare) != &m_param_tree);
    }
        
    inline const boost::int32_t& getInt(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<boost::int32_t>(getPointer(term_ref)));
        return boost::get<const boost::int32_t&>(*getPointer(term_ref));
    }
    
    inline const boost::uint32_t& getUInt(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<boost::uint32_t>(getPointer(term_ref)));
        return boost::get<const boost::uint32_t&>(*getPointer(term_ref));
    }
    
    inline const boost::int64_t& getBigInt(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<boost::int64_t>(getPointer(term_ref)));
        return boost::get<const boost::int64_t&>(*getPointer(term_ref));
    }
    
    inline const boost::uint64_t& getUBigInt(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<boost::uint64_t>(getPointer(term_ref)));
        return boost::get<const boost::uint64_t&>(*getPointer(term_ref));
    }
    
    inline const float& getFloat(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<float>(getPointer(term_ref)));
        return boost::get<const float&>(*getPointer(term_ref));
    }

    inline const double& getDouble(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<double>(getPointer(term_ref)));
        return boost::get<const double&>(*getPointer(term_ref));
    }
    
    inline const long double& getLongDouble(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<long double>(getPointer(term_ref)));
        return boost::get<const long double&>(*getPointer(term_ref));
    }
    
    inline const PionDateTime& getDateTime(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<const PionDateTime&>(getPointer(term_ref)));
        return boost::get<const PionDateTime&>(*getPointer(term_ref));
    }
    
    inline const CharType *getString(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<const BlobType&>(getPointer(term_ref)));
        return boost::get<const BlobType&>(*getPointer(term_ref)).get();
    }
    
    inline const BlobType& getBlob(const Vocabulary::TermRef& term_ref) const {
        PION_ASSERT(getPointer(term_ref)!=NULL && boost::get<const BlobType&>(getPointer(term_ref)));
        return boost::get<const BlobType&>(*getPointer(term_ref));
    }
    
    template <typename T>
    inline bool getInt(const Vocabulary::TermRef& term_ref, T& v) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            v = boost::get<const boost::int32_t&>(*param_ptr);
            return true;
        }
        return false;
    }
    
    template <typename T>
    inline bool getUInt(const Vocabulary::TermRef& term_ref, T& v) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            v = boost::get<const boost::uint32_t&>(*param_ptr);
            return true;
        }
        return false;
    }
    
    template <typename T>
    inline bool getBigInt(const Vocabulary::TermRef& term_ref, T& v) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            v = boost::get<const boost::int64_t&>(*param_ptr);
            return true;
        }
        return false;
    }
    
    template <typename T>
    inline bool getUBigInt(const Vocabulary::TermRef& term_ref, T& v) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            v = boost::get<const boost::uint64_t&>(*param_ptr);
            return true;
        }
        return false;
    }
    
    template <typename T>
    inline bool getFloat(const Vocabulary::TermRef& term_ref, T& v) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            v = boost::get<const float&>(*param_ptr);
            return true;
        }
        return false;
    }

    template <typename T>
    inline bool getDouble(const Vocabulary::TermRef& term_ref, T& v) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            v = boost::get<const double&>(*param_ptr);
            return true;
        }
        return false;
    }
    
    template <typename T>
    inline bool getLongDouble(const Vocabulary::TermRef& term_ref, T& v) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            v = boost::get<const long double&>(*param_ptr);
            return true;
        }
        return false;
    }
    
    template <typename T>
    inline bool getDateTime(const Vocabulary::TermRef& term_ref, T& v) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            v = boost::get<const PionDateTime&>(*param_ptr);
            return true;
        }
        return false;
    }
    
    template <typename T>
    inline bool getBlob(const Vocabulary::TermRef& term_ref, T& v) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            v = boost::get<const BlobType&>(*param_ptr);
            return true;
        }
        return false;
    }

    inline bool getBlob(const Vocabulary::TermRef& term_ref, std::string& str) const {
        const ParameterValue *param_ptr = getPointer(term_ref);
        if (param_ptr) {
            str = boost::get<const BlobType&>(*param_ptr).get();
            return true;
        }
        return false;
    }

    template <typename T>
    inline bool getString(const Vocabulary::TermRef& term_ref, T& v) const {
        return getBlob(term_ref, v);
    }

    inline bool getString(const Vocabulary::TermRef& term_ref, std::string& str) const {
        return getBlob(term_ref, str);
    }

    template <typename T>
    inline void setInt(const Vocabulary::TermRef& term_ref, T value) {
        insert(term_ref, boost::int32_t(value));
    }

    inline void setInt(const Vocabulary::TermRef& term_ref, const std::string& value) {
        insert(term_ref, boost::lexical_cast<boost::int32_t>(value));
    }

    template <typename T>
    inline void setUInt(const Vocabulary::TermRef& term_ref, T value) {
        insert(term_ref, boost::uint32_t(value));
    }
    
    inline void setUInt(const Vocabulary::TermRef& term_ref, const std::string& value) {
        insert(term_ref, boost::lexical_cast<boost::uint32_t>(value));
    }
    
    template <typename T>
    inline void setBigInt(const Vocabulary::TermRef& term_ref, T value) {
        insert(term_ref, boost::int64_t(value));
    }
    
    inline void setBigInt(const Vocabulary::TermRef& term_ref, const std::string& value) {
        insert(term_ref, boost::lexical_cast<boost::int64_t>(value));
    }
    
    template <typename T>
    inline void setUBigInt(const Vocabulary::TermRef& term_ref, T value) {
        insert(term_ref, boost::uint64_t(value));
    }
    
    inline void setUBigInt(const Vocabulary::TermRef& term_ref, const std::string& value) {
        insert(term_ref, boost::lexical_cast<boost::uint64_t>(value));
    }
    
    inline void setFloat(const Vocabulary::TermRef& term_ref, const float value) {
        insert(term_ref, value);
    }
    
    inline void setFloat(const Vocabulary::TermRef& term_ref, const std::string& value) {
        insert(term_ref, boost::lexical_cast<float>(value));
    }
    
    inline void setDouble(const Vocabulary::TermRef& term_ref, const double value) {
        insert(term_ref, value);
    }

    inline void setDouble(const Vocabulary::TermRef& term_ref, const std::string& value) {
        insert(term_ref, boost::lexical_cast<double>(value));
    }

    inline void setLongDouble(const Vocabulary::TermRef& term_ref, const long double value) {
        insert(term_ref, value);
    }
    
    inline void setLongDouble(const Vocabulary::TermRef& term_ref, const std::string& value) {
        insert(term_ref, boost::lexical_cast<long double>(value));
    }
    
    inline void setDateTime(const Vocabulary::TermRef& term_ref, const PionDateTime& value) {
        insert(term_ref, value);
    }
    
    inline void setBlob(const Vocabulary::TermRef& term_ref,
                          const CharType *value, std::size_t len)
    {
        insert(term_ref, make_blob(value, len));
    }
    
    inline void setBlob(const Vocabulary::TermRef& term_ref, const CharType *value) {
        insert(term_ref, make_blob(value, strlen(value)));
    }
    
    inline void setBlob(const Vocabulary::TermRef& term_ref, const std::string& value) {
        insert(term_ref, make_blob(value));
    }
    
    inline void setBlob(const Vocabulary::TermRef& term_ref, const BlobType& value) {
        insert(term_ref, value);
    }
    
    inline void setString(const Vocabulary::TermRef& term_ref,
                          const CharType *value, std::size_t len)
    {
        setBlob(term_ref, value, len);
    }
    
    inline void setString(const Vocabulary::TermRef& term_ref, const CharType *value) {
        setBlob(term_ref, value);
    }
    
    inline void setString(const Vocabulary::TermRef& term_ref, const std::string& value) {
        setBlob(term_ref, value);
    }
    
    inline void setString(const Vocabulary::TermRef& term_ref, const BlobType& value) {
        setBlob(term_ref, value);
    }
    
    inline void set(const Vocabulary::Term& t, const std::string& value)
    {
        switch (t.term_type) {
        case Vocabulary::TYPE_NULL:
        case Vocabulary::TYPE_OBJECT:
            // not serializable
            throw TermTypeNotSerializableException();
            break;
        case Vocabulary::TYPE_INT8:
        case Vocabulary::TYPE_INT16:
        case Vocabulary::TYPE_INT32:
            setInt(t.term_ref, value);
            break;
        case Vocabulary::TYPE_UINT8:
        case Vocabulary::TYPE_UINT16:
        case Vocabulary::TYPE_UINT32:
            setUInt(t.term_ref, value);
            break;
        case Vocabulary::TYPE_INT64:
            setBigInt(t.term_ref, value);
            break;
        case Vocabulary::TYPE_UINT64:
            setUBigInt(t.term_ref, value);
            break;
        case Vocabulary::TYPE_FLOAT:
            setFloat(t.term_ref, value);
            break;
        case Vocabulary::TYPE_DOUBLE:
            setDouble(t.term_ref, value);
            break;
        case Vocabulary::TYPE_LONG_DOUBLE:
            setLongDouble(t.term_ref, value);
            break;
        case Vocabulary::TYPE_DATE_TIME:
        case Vocabulary::TYPE_DATE:
        case Vocabulary::TYPE_TIME:
            {
            pion::PionTimeFacet f(t.term_format);
            const pion::PionDateTime pdt(f.fromString(value));
            setDateTime(t.term_ref, pdt);
            break;
            }
        case Vocabulary::TYPE_SHORT_STRING:
        case Vocabulary::TYPE_STRING:
        case Vocabulary::TYPE_LONG_STRING:
        case Vocabulary::TYPE_CHAR:
        case Vocabulary::TYPE_BLOB:
        case Vocabulary::TYPE_ZBLOB:
            setString(t.term_ref, value);
            break;
        }
    }
    
    static inline bool write(std::ostream& str, const ParameterValue& value,
        const Vocabulary::Term& t)
    {
        switch (t.term_type) {
        case Vocabulary::TYPE_NULL:
        case Vocabulary::TYPE_OBJECT:
            // not serializable
            throw TermTypeNotSerializableException();
            break;
        case Vocabulary::TYPE_INT8:
        case Vocabulary::TYPE_INT16:
        case Vocabulary::TYPE_INT32:
            str << boost::get<const boost::int32_t&>(value);
            break;
        case Vocabulary::TYPE_UINT8:
        case Vocabulary::TYPE_UINT16:
        case Vocabulary::TYPE_UINT32:
            str << boost::get<const boost::uint32_t&>(value);
            break;
        case Vocabulary::TYPE_INT64:
            str << boost::get<const boost::int64_t&>(value);
            break;
        case Vocabulary::TYPE_UINT64:
            str << boost::get<const boost::uint64_t&>(value);
            break;
        case Vocabulary::TYPE_FLOAT:
            str << boost::get<const float&>(value);
            break;
        case Vocabulary::TYPE_DOUBLE:
            str << boost::get<const double&>(value);
            break;
        case Vocabulary::TYPE_LONG_DOUBLE:
            str << boost::get<const long double&>(value);
            break;
        case Vocabulary::TYPE_SHORT_STRING:
        case Vocabulary::TYPE_STRING:
        case Vocabulary::TYPE_LONG_STRING:
        case Vocabulary::TYPE_CHAR:
        case Vocabulary::TYPE_BLOB:
        case Vocabulary::TYPE_ZBLOB:
            str << boost::get<const BlobType&>(value).get();
            break;
        case Vocabulary::TYPE_DATE_TIME:
        case Vocabulary::TYPE_DATE:
        case Vocabulary::TYPE_TIME:
            {
            pion::PionTimeFacet f(t.term_format);
            f.write(str, boost::get<const PionDateTime&>(value));
            break;
            }
        }
    }
    
    static inline std::string& write(std::string& str, const ParameterValue& value,
        const Vocabulary::Term& t)
    {
        switch (t.term_type) {
        case Vocabulary::TYPE_NULL:
        case Vocabulary::TYPE_OBJECT:
            // not serializable
            throw TermTypeNotSerializableException();
            break;
        case Vocabulary::TYPE_INT8:
        case Vocabulary::TYPE_INT16:
        case Vocabulary::TYPE_INT32:
            str = boost::lexical_cast<std::string>( boost::get<const boost::int32_t&>(value) );
            break;
        case Vocabulary::TYPE_UINT8:
        case Vocabulary::TYPE_UINT16:
        case Vocabulary::TYPE_UINT32:
            str = boost::lexical_cast<std::string>( boost::get<const boost::uint32_t&>(value) );
            break;
        case Vocabulary::TYPE_INT64:
            str = boost::lexical_cast<std::string>( boost::get<const boost::int64_t&>(value) );
            break;
        case Vocabulary::TYPE_UINT64:
            str = boost::lexical_cast<std::string>( boost::get<const boost::uint64_t&>(value) );
            break;
        case Vocabulary::TYPE_FLOAT:
            str = boost::lexical_cast<std::string>( boost::get<const float&>(value) );
            break;
        case Vocabulary::TYPE_DOUBLE:
            str = boost::lexical_cast<std::string>( boost::get<const double&>(value) );
            break;
        case Vocabulary::TYPE_LONG_DOUBLE:
            str = boost::lexical_cast<std::string>( boost::get<const long double&>(value) );
            break;
        case Vocabulary::TYPE_SHORT_STRING:
        case Vocabulary::TYPE_STRING:
        case Vocabulary::TYPE_LONG_STRING:
        case Vocabulary::TYPE_CHAR:
        case Vocabulary::TYPE_BLOB:
        case Vocabulary::TYPE_ZBLOB:
            str = boost::get<const BlobType&>(value).get();
            break;
        case Vocabulary::TYPE_DATE_TIME:
        case Vocabulary::TYPE_DATE:
        case Vocabulary::TYPE_TIME:
            {
            pion::PionTimeFacet f(t.term_format);
            str = f.toString( boost::get<const PionDateTime&>(value) );
            break;
            }
        }
        return str;
    }
    
    inline BlobParams make_blob(const std::string& str) const {
        return BlobParams(*m_alloc_ptr, str.c_str(), str.size());
    }
    
    inline BlobParams make_blob(const CharType *ptr, const std::size_t len) const {
        return BlobParams(*m_alloc_ptr, ptr, len);
    }

    inline BlobParams make_blob(const CharType *ptr) const {
        return BlobParams(*m_alloc_ptr, ptr, strlen(ptr));
    }

    inline boost::uint32_t getReferences(void) const { return m_references; }
    
    
protected:
    
    friend class EventPtr;
    
    friend class EventFactory;

    inline void addReference(void) { ++m_references; }
    
    inline boost::uint32_t removeReference(void) { return --m_references; }
    
    inline AllocType *getAllocator(void) { return m_alloc_ptr; }
    
    template <typename T>   
    inline void insert(const Vocabulary::TermRef& term_ref, const T& value) {
        PION_ASSERT(term_ref != Vocabulary::UNDEFINED_TERM_REF);
        ParameterNode *new_param_ptr = createParameter(term_ref, value);
        tree_algo::insert_equal_upper_bound(&m_param_tree,
            new_param_ptr, m_item_compare);
    }
    
    template <typename T>   
    inline ParameterNode *createParameter(const Vocabulary::TermRef& term_ref, const T& value) {
        void *mem_ptr = m_alloc_ptr->malloc(sizeof(ParameterNode));
        return new (mem_ptr) ParameterNode(term_ref, value);
    }
    
    inline void destroyParameter(ParameterNode *param_ptr) {
        param_ptr->~ParameterNode();
        m_alloc_ptr->free(param_ptr, sizeof(ParameterNode));
    }
    

    struct ParameterNodeCompare {
        inline bool operator()(const ParameterNode *a, const ParameterNode *b) const {
            return (a->term_ref < b->term_ref);
        }
    };  
    
    struct ParameterKeyCompare {
        inline bool operator()(const ParameterNode *a, const Vocabulary::TermRef& b) const {
            return (a->term_ref < b);
        }
        inline bool operator()(const Vocabulary::TermRef& a, const ParameterNode *b) const {
            return (a < b->term_ref);
        }
    };  
    
    struct ParameterNodeTraits {
        typedef ParameterNode               node;
        typedef ParameterNode *             node_ptr;
        typedef const ParameterNode *       const_node_ptr;
        typedef boost::uint8_t              color;
        static node_ptr get_parent(const_node_ptr n)       {  return n->m_parent_ptr;   }  
        static void set_parent(node_ptr n, node_ptr parent){  n->m_parent_ptr = parent; }  
        static node_ptr get_left(const_node_ptr n)         {  return n->m_left_ptr;     }  
        static void set_left(node_ptr n, node_ptr left)    {  n->m_left_ptr = left;     }  
        static node_ptr get_right(const_node_ptr n)        {  return n->m_right_ptr;    }  
        static void set_right(node_ptr n, node_ptr right)  {  n->m_right_ptr = right;   }  
        static color get_color(const_node_ptr n)           {  return n->m_tree_color;   }  
        static void set_color(node_ptr n, color c)         {  n->m_tree_color = c;      }
        static color black()                               {  return color(0);     }
        static color red()                                 {  return color(1);     }        
    };
    
    typedef boost::intrusive::rbtree_algorithms<ParameterNodeTraits>    tree_algo;

    
private:
    
    const EventType                 m_event_type;
    
    ParameterNode                   m_param_tree;
    
    ParameterNodeCompare            m_item_compare;
    
    ParameterKeyCompare             m_key_compare;
    
    AllocType * const               m_alloc_ptr;
    
    boost::detail::atomic_count     m_references;
};

    
#ifdef PION_EVENT_USE_POOL_ALLOCATORS

    typedef PionPoolAllocator<16, 256>          EventAllocator;

#else
    
    struct DummyEventAllocator {
        inline void *malloc(std::size_t n) { return ::malloc(n); }
        
        inline void free(void *ptr, std::size_t n) { ::free(ptr); }
    };
    
    typedef DummyEventAllocator         EventAllocator;

#endif
    
    
typedef BasicEvent<char, EventAllocator>    Event;
    
    
class EventPtr {
public:
    
    ~EventPtr() { reset(); }
    
    EventPtr(void) : m_event_ptr(NULL) {}

    EventPtr(const EventPtr& ptr)
        : m_event_ptr(ptr.m_event_ptr)
    {
        if (m_event_ptr != NULL)
            m_event_ptr->addReference();
    }
    
    inline EventPtr& operator=(const EventPtr& ptr) { reset(ptr); return *this; }
    
    inline Event& operator*() const { return *m_event_ptr; }
    
    inline Event* operator->() const { return m_event_ptr; }

    inline Event *get(void) const { return m_event_ptr; }
    
    inline bool is_safe(void) const {
        return (m_event_ptr != NULL && m_event_ptr->getReferences()==1);
    }
    
    inline void reset(void) {
        if (m_event_ptr != NULL) {
            if (m_event_ptr->removeReference() == 0) {
                EventAllocator *alloc_ptr = m_event_ptr->getAllocator();
                m_event_ptr->~Event();
                alloc_ptr->free(m_event_ptr, sizeof(Event));
            }
            m_event_ptr = NULL;
        }
    }
    
    inline void reset(const EventPtr& ptr) {
        reset();
        m_event_ptr = ptr.m_event_ptr;
        if (m_event_ptr != NULL)
            m_event_ptr->addReference();
    }

    inline void swap(EventPtr& ptr) {
        Event *tmp_event_ptr(ptr.m_event_ptr);
        ptr.m_event_ptr = m_event_ptr;
        m_event_ptr = tmp_event_ptr;
    }
    
    
protected:

    friend class EventFactory;
    
    EventPtr(Event *event_ptr)
        : m_event_ptr(event_ptr)
    {
        if (m_event_ptr != NULL)
            m_event_ptr->addReference();
    }
    
    
private:
    
    Event *         m_event_ptr;
};
    
    
class PION_PLATFORM_API EventFactory :
    private boost::noncopyable
{
public:

    ~EventFactory() {}
    
    EventFactory(void)
        : m_event_alloc(EventAllocatorFactory::getAllocator())
    {}
    
    explicit EventFactory(EventAllocator& alloc)
        : m_event_alloc(alloc)
    {}

    explicit EventFactory(Event& e)
        : m_event_alloc(*e.getAllocator())
    {}
    
    inline EventPtr create(const Event::EventType t) {
        void *mem_ptr = m_event_alloc.malloc(sizeof(Event));
        return EventPtr(new (mem_ptr) Event(t, &m_event_alloc));
    }

    inline void create(EventPtr& ptr, const Event::EventType t) {
        if (ptr.is_safe() && ptr->getType() == t)
            ptr->clear();
        else
            ptr = create(t);
    }
    
    inline EventAllocator& getAllocator(void) { return m_event_alloc; }
    
    inline Event::BlobParams make_blob(const std::string& str) const {
        return Event::BlobParams(m_event_alloc, str.c_str(), str.size());
    }
    
    inline Event::BlobParams make_blob(const char *ptr, const std::size_t len) const {
        return Event::BlobParams(m_event_alloc, ptr, len);
    }

    inline Event::BlobParams make_blob(const char *ptr) const {
        return Event::BlobParams(m_event_alloc, ptr, strlen(ptr));
    }
    
    
private:
    
    class EventAllocatorFactory {
    public:
        
        ~EventAllocatorFactory() {
#ifdef PION_EVENT_USE_POOL_ALLOCATORS
            // lock access to the Event allocators
            boost::unique_lock<boost::mutex> alloc_lock(m_alloc_mutex);
            // destruct all the EventAllocators that have been generated
            for (std::list<EventAllocator*>::iterator i = m_active_allocs.begin();
                 i != m_active_allocs.end(); ++i)
            {
                delete *i;
            }
            for (std::list<EventAllocator*>::iterator i = m_inactive_allocs.begin();
                 i != m_inactive_allocs.end(); ++i)
            {
                delete *i;
            }
            // release thread-specific storage for the last thread remaining,
            // the current thread, which is performing static global cleanup
            // (this is the only time this destructor would ever be called)
            m_thread_alloc.release();
#endif
        }
        
        inline static EventAllocator& getAllocator(void) {
            boost::call_once(EventAllocatorFactory::createInstance, m_instance_flag);
            EventAllocator *alloc_ptr;
#ifdef PION_EVENT_USE_POOL_ALLOCATORS
            alloc_ptr = m_instance_ptr->m_thread_alloc.get();
            if (alloc_ptr == NULL) {
                // no allocator found for this thread
                boost::unique_lock<boost::mutex> alloc_lock(m_instance_ptr->m_alloc_mutex);
                if (m_instance_ptr->m_inactive_allocs.empty()) {
                    // no inactive allocators we can reuse -> create a new one
                    alloc_ptr = new EventAllocator();
                } else {
                    // recycle an inactive allocator that already exists
                    alloc_ptr = m_instance_ptr->m_inactive_allocs.front();
                    m_instance_ptr->m_inactive_allocs.pop_front();
                    // release unused memory
                    alloc_ptr->release_memory();
                }
                // add the allocator to the active EventAllocator
                m_instance_ptr->m_active_allocs.push_back(alloc_ptr);
                // store the new thread-specific allocator
                m_instance_ptr->m_thread_alloc.reset(alloc_ptr);
            }
#else
            alloc_ptr = & m_instance_ptr->m_single_alloc;
#endif
            return *alloc_ptr;
        }

        
    private:
        
        EventAllocatorFactory(void)
#ifdef PION_EVENT_USE_POOL_ALLOCATORS
            : m_thread_alloc(&EventAllocatorFactory::releaseAllocator)
#endif
        {}
        
        static void createInstance(void);
        
        static void releaseAllocator(EventAllocator *ptr) {
#ifdef PION_EVENT_USE_POOL_ALLOCATORS
            // do not free the EventAllocator since other threads may still need to dealloate Events!
            boost::unique_lock<boost::mutex> alloc_lock(m_instance_ptr->m_alloc_mutex);
            // remove allocator from active list
            for (std::list<EventAllocator*>::iterator i = m_instance_ptr->m_active_allocs.begin();
                 i != m_instance_ptr->m_active_allocs.end(); ++i)
            {
                if (ptr == *i) {
                    m_instance_ptr->m_active_allocs.erase(i);
                    break;
                }
            }
            // release unused memory
            ptr->release_memory();
            // add allocator to the inactive list
            m_instance_ptr->m_inactive_allocs.push_back(ptr);
#endif
        }
        
        
#ifdef PION_EVENT_USE_POOL_ALLOCATORS
        boost::thread_specific_ptr<EventAllocator>      m_thread_alloc;
        
        std::list<EventAllocator*>                      m_active_allocs;
        
        std::list<EventAllocator*>                      m_inactive_allocs;
        
        boost::mutex                                    m_alloc_mutex;
#else
        EventAllocator                                  m_single_alloc;
#endif
        
        static EventAllocatorFactory *                  m_instance_ptr;
        
        static boost::once_flag                         m_instance_flag;
    };
    
    
    EventAllocator &        m_event_alloc;
};


typedef std::vector<EventPtr>   EventContainer;


}   // end namespace platform
}   // end namespace pion

#endif

---