jAPIcollectors.h

Go to the documentation of this file.

//---------------------------------------------------------------------------

#ifndef jAPIcollectorsH
#define jAPIcollectorsH
//---------------------------------------------------------------------------

#include <map.h>
#include "jAPItexts.h"
#include "jAPImemory.h"

/*
* jAPICollectors
* (part of the C++ Builder jAPI)
* Author : Jean-Etienne GOUBARD
* Description :
*       contains objects that act like hashtable, value are stored and are indexed by their ID 
*/

class jBitmap;

// Virtual class for all these objects
class jMap
{
        public:

        bool __fastcall load(AnsiString _location);
        bool __fastcall save(AnsiString _location);        
        virtual bool __fastcall load(FILE * _fichier)=0;
        virtual bool __fastcall save(FILE * _fichier)=0;
        virtual bool __fastcall load(TStream * _str)=0;        
        virtual bool __fastcall save(TStream * _str)=0;

        virtual bool __fastcall clear()=0;
        virtual int __fastcall  count()=0;
};

// An Hashtable of integers
class IntMap : public jMap
{
        protected:
        map<AnsiString, int, less<AnsiString> >       m_data;

        public:
        IntMap();
        ~IntMap();

        bool __fastcall load(FILE * _fichier);
        bool __fastcall save(FILE * _fichier);
        bool __fastcall load(TStream * _str);
        bool __fastcall save(TStream * _str);

        bool __fastcall clear();
        int  __fastcall count();
        bool __fastcall add(AnsiString _key, int _value);
        bool __fastcall remove(int _pos);
        bool __fastcall remove(AnsiString _key);

        int __fastcall at(int _pos);
        int __fastcall getValue(int _pos);
        AnsiString __fastcall getKey(int _pos);
        int __fastcall maxKey(); 

        int __fastcall at(AnsiString _key);
};

// An Hashtable of Strings
class StringMap : public jMap
{
        protected:
        map<AnsiString, AnsiString, less<AnsiString> >       m_strings;

        public:
        StringMap();
        ~StringMap();

        bool __fastcall load(FILE * _fichier);
        bool __fastcall save(FILE * _fichier);
        bool __fastcall load(TStream * _str);
        bool __fastcall save(TStream * _str);        

        bool __fastcall clear();
        int  __fastcall count();
        bool __fastcall add(AnsiString _key, AnsiString _value);
        bool __fastcall modify(AnsiString _key, AnsiString _value);        
        bool __fastcall remove(unsigned int _pos);
        bool __fastcall remove(AnsiString _key);

        AnsiString __fastcall at(int _pos);
        AnsiString __fastcall getValue(int _pos);
        AnsiString __fastcall getKey(int _pos); 

        AnsiString __fastcall at(AnsiString _key);
};

// An Reversed Hashtable of Strings, wich acts like an bijective association
class StringAssociationMap : public StringMap
{
        map<AnsiString, AnsiString, less<AnsiString> >       m_reverseStrings;

        public:
        StringAssociationMap();
        ~StringAssociationMap();

        bool __fastcall clear();
        int  __fastcall count();

        bool __fastcall load(FILE * _fichier);
        bool __fastcall save(FILE * _fichier);        
        bool __fastcall load(TStream * _str);
        bool __fastcall save(TStream * _str);

        bool __fastcall add(AnsiString _key, AnsiString _value);

        bool __fastcall remove(unsigned int _pos);        
        bool __fastcall removeFromKey(AnsiString _key);
        bool __fastcall removeFromValue(AnsiString _key);        

        AnsiString __fastcall getValueFromKey(AnsiString _key);
        AnsiString __fastcall getKeyFromValue(AnsiString _value);
};

// A HashTable of anything
class VoidMap : public jMap
{
        map<AnsiString, void *, less<AnsiString> >       m_data;

        public:

        VoidMap();
        ~VoidMap();

        bool __fastcall clear();
        int  __fastcall count();

        bool __fastcall load(FILE * _fichier);
        bool __fastcall save(FILE * _fichier);        
        bool __fastcall load(TStream * _str);
        bool __fastcall save(TStream * _str);
        
        bool __fastcall modify(AnsiString _key, void * _value);

        bool __fastcall add(AnsiString _key, void * _value);
        bool __fastcall remove(unsigned int _pos);
        bool __fastcall remove(AnsiString _key);

        void * __fastcall atPos(int _pos);
        void * __fastcall getValue(int _pos);
        AnsiString __fastcall getKey(int _pos); 

        void * __fastcall at(AnsiString _key);
};

// A HashTable of jBitmap, that physically caries the image
class BitmapMap : public jMap
{
        map<AnsiString, jBitmap *, less<AnsiString> >       m_bitmaps;

        public:

        BitmapMap();
        ~BitmapMap();

        bool __fastcall load(FILE * _fichier);
        bool __fastcall save(FILE * _fichier);
        bool __fastcall clear();
        int  __fastcall count();
        bool __fastcall add(AnsiString _key, jBitmap * _value);

        jBitmap * __fastcall at(int _pos);
        jBitmap * __fastcall at(AnsiString _key);
};

class BitmapVector : public jMap
{
        vector<jBitmap *>       m_bitmaps;

        public:
        BitmapVector();
        ~BitmapVector();

        bool __fastcall load(FILE * _fichier);
        bool __fastcall save(FILE * _fichier);
        bool __fastcall load(TStream * _str);
        bool __fastcall save(TStream * _str);
                        
        bool __fastcall clear();
        int  __fastcall count();
        bool __fastcall add(jBitmap * _value);

        bool __fastcall remove(unsigned int _pos);
        jBitmap * __fastcall at(unsigned int _pos);
};

class FileDBMap : public StringAssociationMap
{
        AnsiString m_location;
        AnsiString m_indexName;

        bool __fastcall save();
        bool __fastcall load();
        bool __fastcall load(TStream * _str) { return false; }
        bool __fastcall save(TStream * _str) { return false; }

        bool __fastcall setLocation(AnsiString _location);
        bool __fastcall setIndex(AnsiString _indexName);

        public:
        
        static FileDBMap * __fastcall getInstance(AnsiString _location, AnsiString _indexName);

        bool __fastcall connect(AnsiString _location, AnsiString _indexName);

        bool __fastcall clear();

        AnsiString __fastcall add(AnsiString _key, TMemoryStream * _stream);
        bool __fastcall removeFromKey(AnsiString _key);
        bool __fastcall removeFromRef(AnsiString _ref);
        bool __fastcall getFromKey(AnsiString _key, TMemoryStream * _stream);
        bool __fastcall getFromRef(AnsiString _ref, TMemoryStream * _stream);
        bool __fastcall synchronize();
};

class DBMap
{
        private:
        int m_indexRef;


        protected:
        HANDLE mutexHandle;

        int             start;          // real start of the stream
        int             idxStart;       // position where to find the Index reference
        int             dbStart;        // start of the avaibable storage space (header excluded)
        IntMap          index;
        AnsiString      m_header;
        jMemoryManager  m_mgr;
        TStream *       m_stream;

        bool __fastcall loadIndex();
        bool __fastcall saveIndex();
        bool __fastcall checkHeader();
        bool __fastcall writeHeader();

        public:

        DBMap()   { m_header = "J_DBMAP"; m_stream = NULL; start = 0; SECURITY_ATTRIBUTES l_attributes; mutexHandle = CreateMutex(&l_attributes, true, "orders_mutex"); }
        ~DBMap()  { disconnect(); }
        static DBMap * __fastcall getInstance(AnsiString _location);

        bool __fastcall connect(AnsiString _location);
        bool __fastcall connect(TStream * _stream, bool _create = false);
        bool __fastcall disconnect();

        bool __fastcall clear();
        int  __fastcall count() { return index.count(); }
        int  __fastcall maxRef();

        int  __fastcall add(TStream * _stream);
        bool __fastcall remove(int _ref);
        int  __fastcall removeAtPos(int _pos);        
        bool __fastcall replace(int _ref, TStream * _stream);
        int  __fastcall atPos(int _pos, TStream * _stream);
        bool __fastcall at(int _key, TStream * _stream);
        bool __fastcall atPtr(int _key, TStream ** _stream, int & _size);
        int  __fastcall getKey(int _pos)  { return index.getKey(_pos).ToIntDef(-1); }

        bool __fastcall getIndex(TStrings * _sl);

        void    __fastcall lock();
        void    __fastcall unlock();        

        bool __fastcall debug(TStrings * _sl, TCanvas * _cv = NULL, TRect rect = TRect(0, 0, 0, 0));
};

class DBMapDataBundle : public DBMap
{
        public:
        int     __fastcall add(const jMEMdataBundle & _dataBundle);
        bool    __fastcall at(int _ref, jMEMdataBundle & _order);
        int     __fastcall atPos(int _pos, jMEMdataBundle & _order);
        bool    __fastcall replace(int _ref, jMEMdataBundle & _order);
};

class IndexedDBMap
{
        StringAssociationMap ids;
        DBMap                dbmap;
        AnsiString           m_header;
        TStream *            m_stream;
        int                  start;          // real start of the stream        
        int                  dbStart;        // start of the avaibable storage space (header excluded)
        int                  idsStart;       // position where to find the Ids reference


        bool __fastcall loadIds();
        bool __fastcall saveIds();

        bool __fastcall checkHeader();
        bool __fastcall writeHeader();        

        public:

        IndexedDBMap()   { m_header = "J_INDEXED_DBMAP"; m_stream = NULL; start = 0; }        
        bool __fastcall connect(AnsiString _location);
        bool __fastcall connect(TStream * _stream, bool _create = false);
        bool __fastcall disconnect();

        int  __fastcall maxRef();
        int  __fastcall count() { return dbmap.count(); }        

        bool __fastcall clear();

        int  __fastcall add(AnsiString _id, TStream * _stream);
        bool __fastcall remove(AnsiString _id);
        bool __fastcall remove(int _ref);

        bool __fastcall replace(AnsiString _id, TStream * _stream, AnsiString _newID = "");
        bool __fastcall replace(int _ref, AnsiString _id, TStream * _stream = NULL);
        bool __fastcall replace(int _ref, TStream * _stream);        

        int        __fastcall at(AnsiString _id, TStream * _stream = NULL);
        AnsiString __fastcall at(int _ref, TStream * _stream = NULL);
        AnsiString __fastcall getId(int _ref) { return at(_ref); }

        bool __fastcall getRefsAndIDs(TStrings * _sl);        
        bool __fastcall getRefsAndIDs(vector<int> * _refs, TStrings * _sl);
        bool __fastcall getRefs(vector<int> * _refs);
        bool __fastcall getRefs(TStrings * _sl);
        bool __fastcall getIds(TStrings * _sl);        

        bool __fastcall debug(TStrings * _sl, TCanvas * _cv = NULL, TRect rect = TRect(0, 0, 0, 0));
};

class IndexedDBMapDataBundle : public IndexedDBMap
{
        public:
        int             __fastcall add(AnsiString _id, const jMEMdataBundle & _dataBundle);
        int             __fastcall set(AnsiString _id, const jMEMdataBundle & _dataBundle);
        AnsiString      __fastcall at(int _ref, jMEMdataBundle & _order);
        int             __fastcall at(AnsiString _id, jMEMdataBundle & _order);

        bool            __fastcall replace(int _ref, const jMEMdataBundle & _order);
        bool            __fastcall replace(AnsiString _id, const jMEMdataBundle & _stream, AnsiString _newID = "");
        bool            __fastcall replace(int _ref, AnsiString _id, const jMEMdataBundle & _stream);
};

class IndexedDBMapData : public IndexedDBMap
{
        public:
        int             __fastcall add(AnsiString _id, const jMEMdata & _data);
        int             __fastcall set(AnsiString _id, const jMEMdata & _data);
        AnsiString      __fastcall at(int _ref, jMEMdata & _order);
        int             __fastcall at(AnsiString _id, jMEMdata & _order);

        bool            __fastcall replace(int _ref, const jMEMdata & _order);
        bool            __fastcall replace(AnsiString _id, const jMEMdata & _stream, AnsiString _newID = "");
        bool            __fastcall replace(int _ref, AnsiString _id, const jMEMdata & _stream);
};

#endif

---