jAPImemory.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
#ifndef jAPImemoryH
#define jAPImemoryH
//---------------------------------------------------------------------------

#include <math.h>

#include <NMUDP.hpp>
#include <scktcomp.hpp>
#include <vector.h>

class VoidMap;
class jSound;
class jBitmap;

#define TBITMAP Graphics::TBitmap

bool __fastcall jUDPsend(TNMUDP * udp, AnsiString adr, int prt, void * buffer, unsigned long len, int prt_lcl=0);
bool __fastcall jUDPreceive(TNMUDP * udp, void * buffer, unsigned long len, int prt_lcl=0);

bool __fastcall jTCPestablish(TClientSocket * cs, AnsiString adr, int prt);
bool __fastcall jTCPsend(TClientSocket * cs, void * buffer, unsigned long len, unsigned long timeout);
bool __fastcall jTCPreceive(TClientSocket * cs, void * buffer, unsigned long len, unsigned long timeout);

// DEBUG : ne marchent pas encore
AnsiString jHSTlocalName()
{
        hostent host;
        return host.h_name;
}

AnsiString jHSTlocalAdress()
{
        hostent host;
        return host.h_addr_list[0];
}

/* jMEMdata : a class that can store any type of data
*/
class jMEMdata
{
        public:
        enum Type {TYP_None=0, TYP_AnsiString, TYP_TBitmap, TYP_TStream, TYP_TDateTime, TYP_Int, TYP_Error, TYP_JSound, TYP_JBitmapJpg};

        private:
        void * data;
        Type type;

        public:
        __fastcall jMEMdata();
        __fastcall jMEMdata(AnsiString _data);
        __fastcall jMEMdata(TBITMAP * _bitmap);
        __fastcall jMEMdata(TStream * _stream);
        __fastcall jMEMdata(TDateTime _dateTime);
        __fastcall jMEMdata(int       _data);
        __fastcall jMEMdata(char *    _data);
        __fastcall jMEMdata(jSound *  _sound);
        __fastcall jMEMdata(jBitmap * _bitmap);
        __fastcall jMEMdata(jBitmap * _bitmap, Type _type);

        __fastcall jMEMdata::jMEMdata(const jMEMdata & _data);
        __fastcall jMEMdata::jMEMdata(const jMEMdata * _data);
        void __fastcall jMEMdata::operator=(const jMEMdata & _data);
        void __fastcall jMEMdata::operator=(const jMEMdata * _data);
        
        __fastcall ~jMEMdata();

        bool __fastcall clear();

        bool __fastcall assign(const jMEMdata & _data);
        bool __fastcall assign(const jMEMdata * _data);        

        bool __fastcall set(char *    _data);
        bool __fastcall set(jSound *  _sound);
        bool __fastcall set(jBitmap *  _bitmap, Type _type);
        bool __fastcall set(AnsiString _data);
        bool __fastcall set(TBITMAP * _bitmap);
        bool __fastcall set(TStream * _stream);
        bool __fastcall set(TDateTime _dateTime);
        bool __fastcall set(int       _data);
        bool __fastcall setError(); 

        bool __fastcall isEmpty();
        bool __fastcall isError();                

        bool __fastcall toStream(TStream * _stream);
        bool __fastcall fromStream(TStream * _stream);

        AnsiString getAnsiString();
        TBITMAP *  getTBitmapPtr();
        TStream *  getTStreamPtr();
        jSound  *  getJSoundPtr();        
        TDateTime  getTDateTime();
        int        getInt();
};

class jMEMdataBundle
{
        jMEMdata error;  // to return an error eventually
        bool isAnError;

        VoidMap * datas;

        bool __fastcall add(AnsiString _ref, const jMEMdata & _data);
        bool __fastcall add(AnsiString _ref, const jMEMdata * _data);

        public:

        __fastcall jMEMdataBundle();
        __fastcall jMEMdataBundle(const jMEMdataBundle & _dataBundle);
        __fastcall jMEMdataBundle(const jMEMdataBundle * _dataBundle);

        void __fastcall operator=(const jMEMdataBundle & _dataBundle);

        __fastcall ~jMEMdataBundle();

        bool __fastcall clear();
        int  __fastcall count();
        bool __fastcall assign(const jMEMdataBundle & _databundle);
        bool __fastcall assign(const jMEMdataBundle * _databundle);
        bool __fastcall remove(AnsiString _ref);
        bool __fastcall remove(int _pos);
        bool __fastcall set(AnsiString _ref, const jMEMdata & _data);
        bool __fastcall set(AnsiString _ref, const jMEMdata * _data);
        bool __fastcall setPos(int _pos, const jMEMdata & _data);
        bool __fastcall setPos(int _pos, const jMEMdata * _data);
        jMEMdata & __fastcall atPos(int _pos);
        jMEMdata * __fastcall atPosPtr(int _pos);
        jMEMdata & __fastcall at(AnsiString _ref);
        jMEMdata * __fastcall atPtr(AnsiString _ref);

        void __fastcall setError();
        bool __fastcall isError();
//        bool __fastcall set(AnsiString _ref, AnsiString _value);

        bool __fastcall toStream(TStream * _stream);
        bool __fastcall fromStream(TStream * _stream);
        bool __fastcall fromTStrings(TStrings * _strings);
        AnsiString __fastcall toString();
};

// charge un fichier dans un flux memoire
bool __fastcall jMEMloadFromFile(AnsiString FileName, TMemoryStream * ms);
bool __fastcall jMEMsaveToFile(AnsiString FileName, TMemoryStream * ms);

bool __fastcall jMEMcrypt(void * ms, unsigned long len);
bool __fastcall jMEMunCrypt(void * ms, unsigned long len) { return jMEMcrypt(ms, len); }

bool __fastcall jMEMcrypt(void * ms, unsigned long len, void * key, unsigned long lenKey);
bool __fastcall jMEMunCrypt(void * ms, unsigned long len, void * key, unsigned long lenKey) { return jMEMcrypt(ms, len, key, lenKey); }

bool __fastcall jMEMcrypt(TMemoryStream * ms, unsigned long len);
bool __fastcall jMEMunCrypt(TMemoryStream * ms, unsigned long len) { return jMEMcrypt(ms, len); }

bool __fastcall jMEMfill(void * buffer, unsigned long len, AnsiString octets);

void            __fastcall jMEMcopy(void * dest, void * src, int offset, int nb);
unsigned long   __fastcall jMEMchars2Ulong(unsigned char * data, unsigned long pos, unsigned long len);
AnsiString      __fastcall jMEMdata2str(char * src, unsigned long length);

bool            __fastcall jMEMwriteInt(int _data, TStream * _stream);
int             __fastcall jMEMreadInt(TStream * _stream);

unsigned char __fastcall jMEMstring2byte(AnsiString val);

struct jMemoryEntry
{
        int  position;
        int  size;
        bool taken;
};

// this class manage a stream with memory managment algorithm
class jMemoryManager
{
        TStream * stream;
        int             start;
        int             idxStart;
        int             idxLength;
        AnsiString header;

        vector<jMemoryEntry> entries;

        jMemoryEntry * __fastcall getEntry(int _pos);
        bool __fastcall  write(int _position, TStream * _stream);
        bool __fastcall  read(int _position, int _size, TStream * _stream);        
        jMemoryEntry * __fastcall  findFreeEntry(int _size, int & _ref);
        bool __fastcall  setEntry(int _size, jMemoryEntry *, int _ref);
        bool __fastcall  readIndex();
        bool __fastcall  writeIndex();
        bool __fastcall  resize();
        
        bool __fastcall checkHeader();
        bool __fastcall writeHeader();

        public:

        jMemoryManager();
        jMemoryManager(TStream * _stream);
        bool __fastcall setStream(TStream * _stream);
        
        int  __fastcall size() { if (!stream)   return -1; return stream->Size; }        

        bool __fastcall clear();

        int  __fastcall add(TStream * _stream);
        bool __fastcall at(int _pos, TStream * _stream);
        bool __fastcall atPtr(int _pos, TStream ** _stream, int & _size);     
        bool __fastcall remove(int _pos);

        bool __fastcall display(TStrings * sl);
        bool __fastcall display(TCanvas * sl, const TRect & rect);
};

#endif

---