AStorageHandler.cpp

Go to the documentation of this file.

#include <AStorageHandler.h>
#include <ErrorNo.h>
int StorageHash::dump(const char* filename)
{
  FileWriter fd; 
  if(!fd.open(filename))
  {
    return fd.getLastErrNo();
  }
  for(unsigned long i = 0; i < count; i++)
  {
    Items *buf = items[i];
    while(buf)
    {
      unsigned int len = buf->key.length(); 
      if(!fd.write(&len, sizeof(len)))return fd.getLastErrNo();
      if(!fd.write((void*)buf->key.c_str(), len))return fd.getLastErrNo();
      if(!fd.write(&(buf->data.count), sizeof(buf->data.count)))return fd.getLastErrNo();
      for(int j = 0; j < buf->data.count; j++)
      {
        if(!fd.write(&(buf->data.type[j]), sizeof(buf->data.type[j])))return fd.getLastErrNo();
        switch(buf->data.type[j])
        {
          case StorageData::EMPTY: break;
          case StorageData::INTEGER:
          {
            if(!fd.write(&(buf->data.data[j].integer), sizeof(buf->data.data[j].integer)))return fd.getLastErrNo();
            break;
          }
          case StorageData::REAL:
          {
            if(!fd.write(&(buf->data.data[j].real), sizeof(buf->data.data[j].real)))return fd.getLastErrNo();
            break;
          }
          case StorageData::STRING:
          {
            char *str = buf->data.data[j].string;
            len = strlen(str);
            if(!fd.write(&(len), sizeof(len)))return fd.getLastErrNo();
            if(!fd.write(str, len))return fd.getLastErrNo();
            break;
          }
        }
      }
      buf = buf->next;
    }
  }
  fd.close();
  return 0;
}

bool StorageHash::load(const char* filename)
{
  int fd = open(filename, O_RDONLY);
  if(fd > 0)
  {
    unsigned long oldCount = count;
    destroy();
    count = oldCount;
    memset(items, 0, sizeof(Items*) * count);
    unsigned int bufLen = 256;
    char *buf = (char*)malloc(bufLen);
    unsigned int len = 0;
    while(1)
    {
      if(read(fd, &len, sizeof(len)) != sizeof(len))break;
      if(bufLen < len){bufLen = len; buf = (char*)realloc(buf, bufLen);}
      if(read(fd, buf, len) != (int)len)break;
      String key(buf, len);
      StorageData data;
      if(read(fd, &data.count, sizeof(data.count)) != sizeof(data.count))break;
      if(data.count)
      {       
        data.data = (StorageData::_Data*)malloc(sizeof(StorageData::_Data) * data.count);
        data.type = (StorageData::DataType*)malloc(sizeof(StorageData::DataType) * data.count);
        if(data.data && data.type)
        {
          for(int j = 0; j < data.count; j++)
          {
            if(read(fd, &data.type[j], sizeof(data.type[j])) != sizeof(data.type[j]))break;
            switch(data.type[j])
            {
              case StorageData::EMPTY:break;
              case StorageData::INTEGER:
              {
                read(fd, &(data.data[j].integer), sizeof(data.data[j].integer));
                break;
              }
              case StorageData::REAL:
              {
                read(fd, &(data.data[j].real), sizeof(data.data[j].real));
                break;
              }
              case StorageData::STRING:
              {
                read(fd, &(len), sizeof(len));
                if(bufLen < len + 1){bufLen = len + 1; buf = (char*)realloc(buf, bufLen);}
                read(fd, buf, len);
                buf[len] = '\0';
                data.data[j].string = strdup(buf);
                break;
              }
            }
          }
          insert(key, data);
        }
      }
    }
    close(fd);
    free(buf);
    return true;
  }
  return false;
}

void* AStorageHandler::handle(char code, ...)
{
  va_list list;
  va_start(list, code);
  void *ret = handle(code, list);
  va_end(list);
  return ret;
}

void* AStorageHandler::handle(char code, va_list &list)
{
  char *name = va_arg(list, char*);
  String sname(name);
  sname.urlDecode();
  String **params = sname.split(",");
  String retVal;
  String comma(","), commaL(";");
  String null("NULL");
  for(unsigned int i = 0; params[i]; i++)
  {
    StorageData *data = hash.find(*(params[i]));
    delete params[i];
    String ret;
    if(data)
    {
      for(int j = 0; j < data->count; j++)
      {
        String buf;
        switch(data->type[j])
        {
          case StorageData::EMPTY:break;
          case StorageData::INTEGER:
          {
            buf.fromInt64(data->data[j].integer);            
            break;
          }
          case StorageData::REAL:
          {
            char buffer[80];
            sprintf(buffer, "%f", data->data[j].real);
            buf = String(buffer);
            buf.urlEncode();
            break;
          }
          default:
          {
            buf = String(data->data[j].string);
            buf.urlEncode();
          }
        }
        if(buf.length() && j < data->count - 1)
        {
          buf = buf + commaL;
        }
        ret = ret + buf;
      }
    }
    if(ret.length())
    {
      retVal = retVal + ret + comma;
    }
    else
    {
      retVal = retVal + null + comma;
    }
  }
  delete []params;
  char *ret = new(std::nothrow) char[retVal.length() + 1];
  if(!ret)
  {
    setError(E_MEMORY, "No memory");
    return NULL;
  }
  memcpy(ret, retVal.c_str(), retVal.length());
  ret[retVal.length()] = '\0';
  return ret;
}

void AStorageHandler::setValue(const char *name, long long value, int slot)
{
  if(!name || !*name)return;
  StorageData data, *old = NULL;
  mutex.lock();
  if((old = hash.find(String(name))) == NULL)
  {
    data.init(slot + 1);
    data.type[slot] = StorageData::INTEGER;
    data.data[slot].integer = value;
    hash.insert(String(name), data);
  }
  else
  {
    if(old->count < slot + 1)
    {
      old->resize(slot + 1);    
      old->type[slot] = StorageData::INTEGER;
    }
    if(old->type[slot] == StorageData::INTEGER)
    {
      old->data[slot].integer = value;
    }
  }
  mutex.unlock();
}

void AStorageHandler::setValue(const char *name, double value, int slot)
{
  if(!name || !*name)return;
  StorageData data, *old = NULL;
  mutex.lock();
  if((old = hash.find(String(name))) == NULL)
  {
    data.init(slot + 1);
    data.type[slot] = StorageData::REAL;
    data.data[slot].real = isnan(value)!=0 ? 0.0:value;
    hash.insert(String(name), data);
  }
  else
  {
    if(old->count < slot + 1)
    {
      old->resize(slot + 1);    
      old->type[slot] = StorageData::REAL;
    }
    if(old->type[slot] == StorageData::REAL && !isnan(value) && !isinf(value))
    {
      old->data[slot].real = value;
    }
  }
  mutex.unlock();
}

void AStorageHandler::setValue(const char *name, const char *value, int slot)
{
  if(!value || !name || !*name)return;
  StorageData data, *old = NULL;
  mutex.lock();
  if((old = hash.find(String(name))) == NULL)
  {
    data.init(slot + 1);
    data.type[slot] = StorageData::STRING;
    data.data[slot].string = strdup(value);
    hash.insert(String(name), data);
  }
  else
  {
    if(old->count < slot + 1)
    {
      old->resize(slot + 1);    
      old->type[slot] = StorageData::STRING;
    }
    if(old->type[slot] == StorageData::STRING)
    {
      free(old->data[slot].string);
      old->data[slot].string = strdup(value);
    }
  }
  mutex.unlock();
}

bool AStorageHandler::addToValue(const char *name, long long delta, int slot)
{
  mutex.lock();
  StorageData *data = hash.find(String(name));
  if(data != NULL && slot < data->count)
  {
    if(data->type[slot] == StorageData::INTEGER)
    {
      data->data[slot].integer += delta;
      mutex.unlock();
      return true;
    }
    if(data->type[slot] == StorageData::REAL)
    {
      data->data[slot].real += delta;
      mutex.unlock();
      return true;
    }
  }
  mutex.unlock();
  return false;
}

bool AStorageHandler::addToValue(const char *name, double delta, int slot)
{
  mutex.lock();
  StorageData *data = hash.find(String(name));
  if(data != NULL && slot < data->count)
  {
    if(data->type[slot] == StorageData::REAL && !isnan(delta) && !isinf(delta))
    {
      data->data[slot].real += delta;
      mutex.unlock();
      return true;
    }
  }
  mutex.unlock();
  return false;
}

long long AStorageHandler::getInteger(const char *name, int slot)
{
  mutex.lock();
  StorageData *data = hash.find(String(name));
  mutex.unlock();
  if(data && slot < data->count)
  {
    return data->data[slot].integer;
  }
  return 0;
}

double AStorageHandler::getFloat(const char *name, int slot)
{
  mutex.lock();
  StorageData *data = hash.find(String(name));
  mutex.unlock();
  if(data && slot < data->count)
  {
    if(isnan(data->data[slot].real) || isinf(data->data[slot].real))
    {
      data->data[slot].real = 0.0;
    }
    return data->data[slot].real;
  }
  return 0.0f;
}

char* AStorageHandler::getString(const char *name, int slot)
{
  mutex.lock();
  StorageData *data = hash.find(String(name));
  mutex.unlock();
  if(data && slot < data->count)
  {
    if(data->type[slot] == StorageData::STRING)
    return data->data[slot].string;
  }
  return NULL;
}