it_bus_pdk/dbm.h

#ifndef _IT_BUS_DBM_H_
#define _IT_BUS_DBM_H_

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

#include <it_dsa/types.h>
#include <it_ts/recursive_mutex.h>
#include <it_bus/logging_defs.h>
#include <it_bus/types.h>
#include <it_bus/api_defines.h>
#include <it_bus_pdk/db_exception.h>
#include <it_bus_pdk/db_config.h>

namespace IT_Bus
{
    class IT_DBM_API DBM;

    // Database iterator
    //
    class IT_DBM_API DBIterator
    {
      public:
        DBIterator(
            DBM*     db,
            DBC*     cursor,
            void*    key,
            IT_ULong key_len
        );
        DBIterator(
            const DBIterator& it
        );
        ~DBIterator();

        DBIterator&
        operator=(
            const DBIterator& it
        );

        void
        get_value(
            void*&    key,
            IT_ULong& key_len,
            void*&    val,
            IT_ULong& val_len,
            void*     (*alloc_key)(size_t)   = 0,
            void*     (*alloc_value)(size_t) = 0
        );

        IT_Bool
        operator==(
            const DBIterator& dbi
        ) const;

        IT_Bool
        operator!=(
            const DBIterator& dbi
        ) const
        {
            return !operator==(dbi);
        }

        DBIterator&
        operator++();

      private:
        char     m_store[64];
        DBM*     m_db;
        DBC*     m_cursor;
        void*    m_key;
        IT_ULong m_key_len;
        IT_Bool  m_heap;

      friend class DBM;
    };

    // Database manager
    //
    class IT_DBM_API DBM
    {
      public:
        DBM(
            const char* db_name,
            DBConfig*   cfg
        ) throw((DBException));

        ~DBM();

        void
        open_db(
            const char* name
        ) throw((DBException));

        IT_Pair<DBIterator, IT_Bool>
        insert(
            void*    key,
            IT_ULong key_len,
            void*    val,
            IT_ULong val_len,
            IT_Bool  overwrite = IT_FALSE
        ) throw((DBException));

        DBIterator
        find(
            void*       key,
            IT_ULong    key_len,
            IT_Bool     have_recursed = IT_FALSE
        ) const throw((DBException));

        IT_Bool
        erase(
            void*    key,
            IT_ULong key_len
        ) throw((DBException));

        IT_ULong
        get_size() const throw((DBException));

        DBIterator
        begin(
            IT_Bool have_recursed = IT_FALSE
        ) const;

        inline DBIterator
        end() const;    

      protected:
        IT_DECLARE_BUS_LOGGER_MEM

      private:

        void
        mark_db_for_reopening();

        void
        reopen_db();

        void
        close_db();

        IT_String           m_db_name;
        IT_Bool             m_should_reopen_db;
        DB*                 m_db;
        DBC*                m_cur;
        DBConfig*           m_cfg;      
        DBEnv*              m_env;
        IT_RecursiveMutex   m_mutex;

        // private and unimplemented to prevent copying
        DBM(const DBM&);
        void operator=(const DBM&);

        friend class DBEnv;
    };

    IT_DBM_API DBIterator
    DBM::end() const
    {
        DBM* ncthis = IT_CONST_CAST(DBM*, this);
        return DBIterator(ncthis, 0, 0, 0);
    }

}

#endif  

---