OW_HDB.hpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2001-2004 Vintela, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
*  - Redistributions of source code must retain the above copyright notice,
*    this list of conditions and the following disclaimer.
*
*  - Redistributions in binary form must reproduce the above copyright notice,
*    this list of conditions and the following disclaimer in the documentation
*    and/or other materials provided with the distribution.
*
*  - Neither the name of Vintela, Inc. nor the names of its
*    contributors may be used to endorse or promote products derived from this
*    software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Vintela, Inc. OR THE CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/

#ifndef OW_HDB_HPP_INCLUDE_GUARD_
#define OW_HDB_HPP_INCLUDE_GUARD_
#include "OW_config.h"
#include "OW_HDBCommon.hpp"
#include "OW_String.hpp"
#include "OW_Index.hpp"
#include "OW_IntrusiveReference.hpp"
#include "OW_IntrusiveCountableBase.hpp"
#include "OW_File.hpp"
#include "OW_HDBNode.hpp"
#include "OW_RWLocker.hpp"
#include "OW_MutexLock.hpp"
#include <cstdio>

namespace OW_NAMESPACE
{

class HDB;
class OW_HDB_API HDBHandle
{
private:
   struct HDBHandleData : public IntrusiveCountableBase
   {
      HDBHandleData(HDB* pdb, const File& file) :
         m_pdb(pdb), m_file(file), m_writeDone(false),
         m_userVal(0L) {}
      HDBHandleData() :
         m_pdb(NULL), m_file(), m_writeDone(false),
         m_userVal(0L) {}
      ~HDBHandleData();
   
      HDB* m_pdb;
      File m_file;
      bool m_writeDone;
      Int32 m_userVal;  // Handle user can store any long data here
   };
   typedef IntrusiveReference<HDBHandleData> HDBHandleDataRef;
public:
   HDBHandle(const HDBHandle& x) : m_pdata(x.m_pdata) {}
   HDBHandle();
   HDBHandle& operator= (const HDBHandle& x)
   {
      m_pdata = x.m_pdata;
      return *this;
   }
   void flush();
   HDBNode getNode(const String& key);
   HDBNode getParent(HDBNode& node);
   HDBNode getFirstChild(HDBNode& node);
   HDBNode getLastChild(HDBNode& node);
   HDBNode getNextSibling(HDBNode& node);
   HDBNode getPrevSibling(HDBNode& node);
   HDBNode getFirstRoot();
   bool addRootNode(HDBNode& node);
   bool addChild(HDBNode& parentNode, HDBNode& childNode);
   bool addChild(const String& parentKey, HDBNode& childNode);
   bool removeNode(HDBNode& node);
   bool removeNode(const String& key);
   bool updateNode(HDBNode& node, Int32 dataLen, const unsigned char* data);
   void turnFlagsOn(HDBNode& node, UInt32 flags);
   void turnFlagsOff(HDBNode& node, UInt32 flags);
   void setUserValue(Int32 value) { m_pdata->m_userVal = value; }
   Int32 getUserValue() const { return m_pdata->m_userVal; }

   typedef HDBHandleDataRef HDBHandle::*safe_bool;
   operator safe_bool () const
      {  return m_pdata ? &HDBHandle::m_pdata : 0; }
   bool operator!() const
      {  return !m_pdata; }
private:
   HDBHandle(HDB* pdb, const File& file);
   File getFile() { return m_pdata->m_file; }
   HDB* getHDB() { return m_pdata->m_pdb; }
   Int32 registerWrite();
   IndexEntry findFirstIndexEntry(const char* key=NULL);
   IndexEntry findNextIndexEntry();
   IndexEntry findPrevIndexEntry();
   IndexEntry findIndexEntry(const char* key);
   bool addIndexEntry(const char* key, Int32 offset);
   bool removeIndexEntry(const char* key);
   bool updateIndexEntry(const char* key, Int32 newOffset);
   friend class HDB;
   friend class HDBNode;

#ifdef OW_WIN32
#pragma warning (push)
#pragma warning (disable: 4251)
#endif

   HDBHandleDataRef m_pdata;

#ifdef OW_WIN32
#pragma warning (pop)
#endif

};
class OW_HDB_API HDB
{
public:
   
   HDB();
   ~HDB();
   void open(const char* fileName);
   void close();
   HDBHandle getHandle();

   typedef bool HDB::*safe_bool;
   operator safe_bool () const
      {  return m_opened ? &HDB::m_opened : 0; }
   bool operator!() const
      {  return !m_opened; }
   int getHandleCount() const { return m_hdlCount; }
   String getFileName() const { return m_fileName; }
   static void writeBlock(HDBBlock& fblk, File& file, Int32 offset);
   static void readBlock(HDBBlock& fblk, const File& file, Int32 offset);
private:
   bool createFile();
   void checkFile();
   void setOffsets(File& file, Int32 firstRootOffset, Int32 lastRootOffset,
      Int32 firstFreeOffset);
   void setFirstRootOffSet(File& file, Int32 offset);
   void setLastRootOffset(File& file, Int32 offset);
   void setFirstFreeOffSet(File& file, Int32 offset);
   Int32 getFirstRootOffSet() { return m_hdrBlock.firstRoot; }
   Int32 getLastRootOffset() { return m_hdrBlock.lastRoot; }
   Int32 getFirstFreeOffSet() { return m_hdrBlock.firstFree; }
   Int32 findBlock(File& file, int size);
   void removeBlockFromFreeList(File& file, HDBBlock& fblk);
   void addRootNode(File& file, HDBBlock& fblk, Int32 offset);
   void addBlockToFreeList(File& file, const HDBBlock& parmblk,
      Int32 offset);
   Int32 getVersion() { return m_version; }
   Int32 incVersion();
   void decHandleCount();
   IndexEntry findFirstIndexEntry(const char* key=NULL);
   IndexEntry findNextIndexEntry();
   IndexEntry findPrevIndexEntry();
   IndexEntry findIndexEntry(const char* key);
   bool addIndexEntry(const char* key, Int32 offset);
   bool removeIndexEntry(const char* key);
   bool updateIndexEntry(const char* key, Int32 newOffset);
   void flushIndex();

#ifdef OW_WIN32
#pragma warning (push)
#pragma warning (disable: 4251)
#endif

   HDBHeaderBlock m_hdrBlock;
   File m_lockFile;
   String m_fileName;
   Int32 m_version;
   int m_hdlCount;
   bool m_opened;
   IndexRef m_pindex;
   Mutex m_indexGuard;
   Mutex m_guard;
   friend class HDBNode;
   friend class HDBHandle;
   friend struct HDBHandle::HDBHandleData;

#ifdef OW_WIN32
#pragma warning (pop)
#endif

};

} // end namespace OW_NAMESPACE

#endif

---