it_bus_pdk/persistent_map_base.h

#ifndef _IT_BUS_PERSISTENT_MAP_BASE_H_
#define _IT_BUS_PERSISTENT_MAP_BASE_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//

#include <it_dsa/types.h>
#include <it_bus_pdk/dbm.h>
#include <it_bus_pdk/db_config.h>

//
// When implementing a PersistenceHandler, you must ensure that it contains
// implementations of the following functions, with these exact signatures:
//
//    void*&
//    writebuf();
//
//    void*
//    readbuf();
//
//    IT_ULong&
//    writebuflen();
//
//    IT_ULong
//    readbuflen() const;
//
//    AllocFunc
//    allocator();
//    
//    void
//    update_read_buffer_after_write();
//
// See the documentation for more details on the purposes of these methods
// and how to properly implement them.
// 

namespace IT_Bus
{
    typedef void* (*AllocFunc)(size_t);
    
    template<class T>
    class PODPersistenceHandler
    {
      public:
        IT_EXPLICIT PODPersistenceHandler(
            const T& t
        ) :
            m_t(IT_CONST_CAST(T&, t)),
            m_p(&m_t),
            m_sz(sizeof(T))
        {}
        IT_EXPLICIT PODPersistenceHandler(
            T& t
        ) :
            m_t(t),
            m_p(&m_t),
            m_sz(sizeof(T))
        {}

        void*&
        writebuf()
        {
            return m_p;
        }    

        void*
        readbuf()
        {
            return &m_t;
        }    

        IT_ULong&
        writebuflen()
        {
            return m_sz;
        }

        IT_ULong
        readbuflen() const
        {
            return sizeof(T);
        }

        AllocFunc
        allocator()
        {
            return 0;
        }

        void
        update_read_buffer_after_write() {}

      private:
        T&       m_t;
        void*    m_p;
        IT_ULong m_sz;

        // private and unimplemented to prevent copying
        PODPersistenceHandler(const PODPersistenceHandler<T>&);
        void operator=(const PODPersistenceHandler<T>&);
    };

    template<class Key, class Data, class KeyHandler, class DataHandler>
    class PersistentMapBase;

    //
    // The following class should be nested inside PersistentMapBase
    // as class iterator, but unfortunately MSVC6 can't handle
    // that. We instead put it here and then typedef its name into the
    // PersistentMapBase class.
    //
    template<class Key, class Data, class KeyHandler, class DataHandler>
    class PersistentMapBaseIterator
    {
        typedef PersistentMapBase<Key, Data, KeyHandler, DataHandler> MapType;

      public:
        PersistentMapBaseIterator(
        ) :
            m_map(0),
            m_it(0, 0, 0, 0)
        {
            // complete
        }

        ~PersistentMapBaseIterator() {}

        PersistentMapBaseIterator&
        operator=(
            const PersistentMapBaseIterator& it
        );

        IT_Bool
        operator==(
            const PersistentMapBaseIterator& it
        ) const
        {
            return m_map == it.m_map && m_it == it.m_it;
        }

        IT_Bool
        operator!=(
            const PersistentMapBaseIterator& it
        ) const
        {
            return !operator==(it);
        }

        const IT_Pair<const Key, Data>&
        operator*() const;

        PersistentMapBaseIterator&
        operator++()
        {
            ++m_it;
            return *this;
        }

        PersistentMapBaseIterator
        operator++(int)
        {
            PersistentMapBaseIterator save = *this;
            ++*this;
            return save;
        }

        PersistentMapBaseIterator(
            MapType*   mp,
            DBIterator it
        ) :
            m_map(mp),
            m_it(it)
        {
            // complete
        }

      private:
        MapType*                 m_map;
        DBIterator               m_it;
        IT_Pair<const Key, Data> m_value;

      friend class PersistentMapBase<Key, Data, KeyHandler, DataHandler>;
    };

    template<class Key, class Data, class KeyHandler, class DataHandler>
    class PersistentMapBase
    {
      public:
        typedef Key                      key_type;
        typedef Data                     data_type;
        typedef Data&                    reference_type;
        typedef const Data&              const_reference_type;
        typedef IT_Pair<const Key, Data> value_type;
        typedef size_t                   size_type;
        typedef ptrdiff_t                difference_type;

        typedef PersistentMapBase<Key, Data, KeyHandler, DataHandler> MapType;

        typedef PersistentMapBaseIterator <Key, Data,
                                           KeyHandler, DataHandler> iterator;

        PersistentMapBase(      
            const char* id,
            DBConfig*   cfg
        );
        PersistentMapBase(
            const char*       id,
            DBConfig*         cfg,
            const value_type* first,
            const value_type* last
        );
        PersistentMapBase(
            const PersistentMapBase<Key, Data, KeyHandler, DataHandler>& mp
        );
        ~PersistentMapBase();

        PersistentMapBase<Key, Data, KeyHandler, DataHandler>&
        operator=(
            const PersistentMapBase<Key, Data, KeyHandler, DataHandler>& mp
        );

        iterator
        begin() const;

        iterator
        end() const;

        IT_Pair<iterator, IT_Bool>
        insert(
            const value_type& val,
            IT_Bool           overwrite = IT_FALSE
        );

        void
        insert(
            const value_type* first,
            const value_type* last,
            IT_Bool           overwrite = IT_FALSE
        );

        size_type
        erase(
            const key_type& key
        );

        void
        erase(
            const iterator& pos
        );

        void
        erase(
            const iterator& first,
            const iterator& last
        );

        iterator
        find(
            const key_type& key
        ) const;

        IT_Bool
        empty() const;

        size_type
        size() const;

      private:
        DBM       m_dbm;
        String    m_id;
        DBConfig* m_cfg;
    };

    //
    // Inlined functions
    //
    template<class Key, class Data, class KeyHandler, class DataHandler>
    inline IT_TYPENAME PersistentMapBase<Key, Data, KeyHandler, DataHandler>::iterator
    PersistentMapBase<Key, Data, KeyHandler, DataHandler>::begin() const
    {
        MapType* ncthis = IT_CONST_CAST(MapType*, this);
        return iterator(ncthis, m_dbm.begin());
    }

    template<class Key, class Data, class KeyHandler, class DataHandler>
    inline IT_TYPENAME PersistentMapBase<Key, Data, KeyHandler, DataHandler>::iterator
    PersistentMapBase<Key, Data, KeyHandler, DataHandler>::end() const
    {
        MapType* ncthis = IT_CONST_CAST(MapType*, this);
        return iterator(ncthis, m_dbm.end());
    }

    template<class Key, class Data, class KeyHandler, class DataHandler>
    inline IT_Bool
    PersistentMapBase<Key, Data, KeyHandler, DataHandler>::empty() const
    {
        return size() == 0;
    }

    template<class Key, class Data, class KeyHandler, class DataHandler>
    inline IT_TYPENAME PersistentMapBase<Key, Data, KeyHandler, DataHandler>::size_type
    PersistentMapBase<Key, Data, KeyHandler, DataHandler>::size() const
    {
        return m_dbm.get_size();
    }
}

#if IT_SUPPORTS_COMPILE_TIME_INSTANTIATION
#include <it_bus_pdk/persistent_map_base.cxx>
#endif

#endif  

---