AStorageHandler.h

Go to the documentation of this file.

#ifndef ASTORAGEHANDLER_H
#define ASTORAGEHANDLER_H
#include <stdio.h> 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <new>
#include <BaseHandler.h>
#include <THash.h>
#include <CRC32.h>
#include <String.h>
#include <Thread_t.h>
#include <FileWriter.h>

class StorageData
{
  public:
    StorageData():data(NULL),type(NULL),count(0){}
    StorageData(const StorageData &storageData)
    {
      count = storageData.count;
      data = (_Data*)malloc(sizeof(_Data) * count);
      type = (DataType*)malloc(sizeof(DataType) * count);
      memcpy(data, storageData.data, sizeof(_Data) * count);
      memcpy(type, storageData.type, sizeof(DataType) * count);
    }
    ~StorageData()
    {
      if(data)free(data);
      if(type)free(type);
    }
    void init(int count)
    {
      this->count = count;
      data = (_Data*)malloc(sizeof(_Data) * count);
      type = (DataType*)malloc(sizeof(DataType) * count);
      for(int i = 0; i < count; i++)type[i] = EMPTY;
    }
    void resize(int count)
    {
      data = (_Data*)realloc(data, sizeof(_Data) * count);
      type = (DataType*)realloc(type, sizeof(DataType) * count);
      for(int i = this->count; i < count; i++)type[i] = EMPTY;      
      this->count = count;
    }
    StorageData& operator=(StorageData &storageData)
    {
      if(this->data)free(this->data);
      if(this->type)free(this->type);
      init(storageData.count);
      memcpy(data, storageData.data, sizeof(_Data) * count);
      memcpy(type, storageData.type, sizeof(DataType) * count);
      return *this;
    }
    enum DataType
    {
      EMPTY = 0, INTEGER , REAL, STRING
    };
    union _Data
    {
      long long integer;
      double real;
      char *string;
    }*data;
    DataType *type;
    int count;
};

class StorageHash: public THash<StorageData, String>
{
  public:
    StorageHash(unsigned long count):THash<StorageData, String>(count){}
    int dump(const char* filename);
    bool load(const char* filename);

  private:
    unsigned long hashFunc(String name){return crc.calc((char*)name.c_str(), name.length());}
    void destroyFunc(String name, StorageData data)
    {
      for(int i = 0; i < data.count; i++)
      {
        if(data.type[i] == StorageData::STRING)free(data.data[i].string);
      }
    }
    CRC32 crc;
};

class AStorageHandler:public BaseHandler
{
  public:
    AStorageHandler():BaseHandler(102), hash(113){}
    ~AStorageHandler(){hash.destroy();}
    virtual void *handle(char code, ...);
    void setValue(const char *name, long long value, int slot = 0);
    void setValue(const char *name, double value, int slot = 0);
    void setValue(const char *name, const char *value, int slot = 0);
    bool addToValue(const char *name, long long delta, int slot = 0);
    bool addToValue(const char *name, double delta, int slot = 0);
    long long getInteger(const char *name, int slot = 0);
    double getFloat(const char *name, int slot = 0);
    char* getString(const char *name, int slot = 0);
    int dump(const char* filename){return hash.dump(filename);}
    bool load(const char* filename)
    {
      long long oldStartDate = getInteger("StartDate");
      bool ok = hash.load(filename);
      if(oldStartDate)
      {
        setValue("StartDate", oldStartDate);
      }
      return ok;
    }

  protected:
    void *handle(char code, va_list &list);

  private:
   StorageHash hash;
   Mutex mutex;
};
#endif