Config.cpp

Go to the documentation of this file.

#include <stdio.h>

#include <Config.h>


Config::Config(char *fName)
{
  code.clear();
  codeVal.clear();
  FILE *f = fopen(fName, "r");
  if (!f)
  {
    configExist = false;
  }
  else
  {
    configExist = true;
    std::vector < char >sectionName;
    std::vector < char >paramName;
    std::vector < char >paramValue;
    bool sectionFill = false;
    bool paramFill = false;
    bool valueFill = false;
    bool checkSimple = false;
    bool isSimple = false;
    char leter;

    sectionName.clear();
    paramName.clear();
    paramValue.clear();
    while (!feof(f))
    {
      int readCount = fread(&leter, sizeof(char), 1, f);
      if (readCount)
      {
        if (leter == '[')
        {
          sectionFill = false;
          sectionName.clear();
          continue;
        }
        if (leter == ']')
        {
          sectionName.push_back(0);
          sectionFill = true;
          continue;
        }
        //filling the section name
        if (!sectionFill && leter != ' ')
        {
          sectionName.push_back(leter);
          continue;
        }
        //filling the paramName section
        if (!paramFill)
        {
          if (leter != ' ' && leter != '\n')
          {
            if (leter != '=')
            {
              paramName.push_back(leter);
              continue;
            }
            else
            {
              paramName.push_back(0);
              paramFill = true;
              checkSimple = true;
              continue;
            }
          }
        }
        if (!valueFill && paramFill)
        {
          if (checkSimple)
          {
            checkSimple = false;
            if (leter == '"')
            {
              isSimple = false;
              continue;
            }
            else
            {
              isSimple = true;
            }
          }
          if (!isSimple)
          {
            if (leter == '\n')
            {
              valueFill = true;
              paramValue[paramValue.size() - 1] = 0;
              paramValue.push_back(0);
              createRecord(&sectionName, &paramName, &paramValue);
              valueFill = false;
              paramFill = false;
              isSimple = true;
            }
            else
            {
              paramValue.push_back(leter);
            }
          }
          else
          {
            if (leter != ' ')
            {
              if (leter == '\n')
              {
                valueFill = true;
                paramValue.push_back(0);
                createRecord(&sectionName, &paramName, &paramValue);
                valueFill = false;
                paramFill = false;
                isSimple = true;
              }
              else
              {
                paramValue.push_back(leter);
              }
            }
          }
        }
      }
    }

    if (paramValue.size() > 0)
    {
      paramValue.push_back(0);
    }
    createRecord(&sectionName, &paramName, &paramValue);
    fclose(f);
  }
}


Config::~Config()
{
  for (unsigned int i = 0; i < code.size(); i++)
  {
    delete[]code[i];
    delete[]codeVal[i];
  }
}

void Config::print()
{
  for (unsigned int i = 0; i < code.size(); i++)
  {
    printf("pair %s - %s\n", code[i], codeVal[i]);
  }
}


void Config::getAsString(const char *sectionName,const  char *paramName, char *&value,
                         const char *defValue)
{
  char *findValue = new char[strlen(sectionName) + strlen(paramName) + 1];
  strcpy(findValue, sectionName);
  strcat(findValue, paramName);
  int index = getIndex(findValue);
  if (index < 0)
  {
    //no find
    value = new char[strlen(defValue) + 1];
    strcpy(value, defValue);
  }
  else
  {
    value = new char[strlen(codeVal[index]) + 1];
    strcpy(value, codeVal[index]);
  }
  delete[]findValue;
}


void Config::getAsInt(const char *sectionName, const char *paramName, int &value,
                      int defValue)
{
  char *findValue = new char[strlen(sectionName) + strlen(paramName) + 1];
  strcpy(findValue, sectionName);
  strcat(findValue, paramName);
  int index = getIndex(findValue);
  if (index < 0)
  {
    //no find
    value = defValue;
  }
  else
  {
    value = atoi(codeVal[index]);
  }
  delete[]findValue;
}


void Config::getAsUnsigned(const char *sectionName,const char *paramName,
                           unsigned int &value, unsigned int defValue)
{
  char *findValue = new char[strlen(sectionName) + strlen(paramName) + 1];
  strcpy(findValue, sectionName);
  strcat(findValue, paramName);
  int index = getIndex(findValue);
  if (index < 0)
  {
    //no find
    value = defValue;
  }
  else
  {
    value = (unsigned int) atoi(codeVal[index]);
  }
  delete[]findValue;
}

void Config::getAsInt64 (const char *sectionName, const char *paramName, u_int64_t &value, u_int64_t defValue)
{
  char *findValue = new char[strlen (sectionName) + strlen (paramName) + 1];
  strcpy (findValue, sectionName);
  strcat (findValue, paramName);
  int index = getIndex (findValue);
  if (index < 0)
  {
    //no find
    value = defValue;
  }
  else
  {
    value = (u_int64_t)atoll (codeVal[index]);
  }
  delete[] findValue;
}
                                  
void Config::getAsBool(const char *sectionName, const char *paramName, bool & value,
                       bool defValue)
{
  char *findValue = new char[strlen(sectionName) + strlen(paramName) + 1];
  strcpy(findValue, sectionName);
  strcat(findValue, paramName);
  int index = getIndex(findValue);
  if (index < 0)
  {
    //no find
    value = defValue;
  }
  else
  {
    value = atoi(codeVal[index]);
  }
  delete[]findValue;
}


void Config::getAsDouble(const char *sectionName, const char *paramName, double &value, double defValue)
{
  char *findValue = new char[strlen(sectionName) + strlen(paramName) + 1];
  strcpy(findValue, sectionName);
  strcat(findValue, paramName);
  int index = getIndex(findValue);
  if (index < 0)
  {
    //no find
    value = defValue;
  }
  else
  {
    value = atof(codeVal[index]);
  }
  delete[]findValue;
}

void Config::readSection(const char *sectionName, char **&values1, int &size)
{
  std::vector < char *>sectionParams;
  sectionParams.clear();
  int pos = 0;
  size = 0;
  for (unsigned int i = 0; i < code.size(); i++)
  {
    if (findSection(code[i], sectionName, pos))
    {
      size += 2;
      char *paramName = new char[strlen(code[i])];
      char *paramValue = new char[strlen(codeVal[i]) + 1];
      strcpy(paramValue, codeVal[i]);
      strcpy(paramName, code[i] + pos);
      sectionParams.push_back(paramName);
      sectionParams.push_back(paramValue);
    }
  }
  if (size != 0)
  {
    values1 = new char *[size];
    for (unsigned int i = 0; i < sectionParams.size(); i += 2)
    {
      values1[i] = new char[strlen(sectionParams[i]) + 1];
      strcpy(values1[i], sectionParams[i]);
      values1[i + 1] = new char[strlen(sectionParams[i + 1]) + 1];
      strcpy(values1[i + 1], sectionParams[i + 1]);
      delete[]sectionParams[i];
      delete[]sectionParams[i + 1];
    }
  }
}


bool Config::isConfigExist()
{
  return configExist;
}

void Config::createRecord(std::vector < char >*sectionName,
                          std::vector < char >*paramName,
                          std::vector < char >*paramValue)
{
  if (sectionName->size() && paramName->size() && paramValue->size())
  {
    char *key = new char[sectionName->size() + paramName->size() + 1];
    char *value = new char[paramValue->size() + 1];
    strcpy(key, &(*sectionName)[0]);
    strcat(key, &(*paramName)[0]);
    strcpy(value, &(*paramValue)[0]);
    code.push_back(key);
    codeVal.push_back(value);
    paramName->clear();
    paramValue->clear();
  }
}

int Config::getIndex(char *value)
{
  for (unsigned int i = 0; i < code.size(); i++)
  {
    if (strcmp(code[i], value) == 0)
    {
      return i;
    }
  }
  return -1;
}

bool Config::findSection(const char *codeValue, const char *sectionName, int &pos)
{
  pos = 0;
  while (*(sectionName + pos))
  {
    if (codeValue[pos] == 0 || sectionName[pos] != codeValue[pos])
    {
      return false;
    }
    pos++;
  }
  return true;
}