SystemProperties.cpp

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////////////
/*! \file SystemProperties.cpp
 *  \brief Method definitions for the SystemProperties class.
 *  \author     $Author: rsharo $
 *  \version $Revision: 1.3 $
 *  \date    $Date: 2004/04/07 13:47:12 $
*////////////////////////////////////////////////////////////////////////////

#include "Utils/SystemProperties.h"

#include "ace/Configuration_Import_Export.h"

#include <string.h>

#include <sstream>
#include <algorithm>


SystemProperties * s_pInstance = NULL;


SystemProperties *SystemProperties::Instance(const char *configFilename,
                                                                                         bool registryFormat)
{
        if (s_pInstance == NULL)
        {
                s_pInstance = new SystemProperties();

                if (registryFormat)
                {
                        s_pInstance->ImportPropertiesRegistry(configFilename);
                }
                else
                {
                        s_pInstance->ImportPropertiesIni(configFilename);
                }
        }

        return s_pInstance;
}



SystemProperties::SystemProperties()
{
        this->open();
}



int SystemProperties::GetStringEntry(const char *sectionName, const char *name,
                                                                         std::string &value)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        return GetStringEntry(current, name, value);
}


int SystemProperties::GetIntegerEntry(const char *sectionName,
                                                                          const char *name, unsigned int &value)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        return GetIntegerEntry(current, name, value);
}


int SystemProperties::GetDoubleEntry(const char *sectionName,
                                                                         const char *name, double &value)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        return GetDoubleEntry(current, name, value);
}


int SystemProperties::GetBinaryEntry(const char *sectionName, const char *name,
                                                                         void * &value, size_t &length)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        return GetBinaryEntry(current, name, value, length);

}



int SystemProperties::GetBooleanEntry(const char *sectionName,
                                                                          const char *name, bool &value)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        return GetBooleanEntry(current, name, value);
}




int SystemProperties::GetStringEntry(const SectionKey_t &parent,
                                                                         const char *name, std::string &value)
{
        ACE_TString tstring;

        int retVal = this->get_string_value(parent, name, tstring);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to get system property: %s\n", name), retVal);

        value = tstring.c_str();
        return 0;
}


int SystemProperties::GetIntegerEntry(const SectionKey_t &parent,
                                                                          const char *name, unsigned int &value)
{
        int retVal = this->get_integer_value(parent, name, value);

        //
        // If the property isn't stored as an integer, it might be encoded as a
        // string. This would be the case if the properties were read from an
        // INI-style file.
        if (retVal)
        {
                ACE_TString tstring;
                retVal = this->get_string_value(parent, name, tstring);
                
                if (retVal)
                        ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to get system property: %s\n", name), retVal);
                
                const char * buf=tstring.c_str();
                char * endptr;
                value = strtol(buf, &endptr, 0);
                if ((buf + tstring.length()) != endptr)
                {
                        ACE_ERROR_RETURN((LM_ERROR,
                                "(%N:%l) System property '%s' did not convert to an integer correctly.\n",
                                name), retVal);
                }
        }

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to get system property: %s\n", name), retVal);

        return 0;
}


int SystemProperties::GetDoubleEntry(const SectionKey_t &parent,
                                                                         const char *name, double &value)
{
        ACE_TString tstring;
        int retVal = this->get_string_value(parent, name, tstring);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to get system property: %s\n", name), retVal);

        const char * buf=tstring.c_str();
        char * endptr;
        value = strtod(buf, &endptr);
        if ((buf + tstring.length()) != endptr)
        {
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) System property '%s' did not convert to a double correctly.\n",
                        name), retVal);
        }

        return 0;
}


int SystemProperties::GetBinaryEntry(const SectionKey_t &parent,
                                                                         const char *name, void * &value,
                                                                         size_t &length)
{
        //
        // Try to get the binary value directly from the properties.
        int retVal = this->get_binary_value(parent, name, value, length);

        //
        // If the property isn't stored as a binary, it might be encoded as a
        // string. This would be the case if the properties were read from an
        // INI-style file.
        if (retVal == -1)
        {
                ACE_TString tstring;
                retVal = this->get_string_value(parent, name, tstring);

                if (retVal == 0)
                {
                        unsigned int slen = tstring.length();

                        //
                        // If we have a zero-length binary field, its perfectly valid.
                        // Just report a length of zero.
                        if (slen == 0)
                        {
                                value = NULL;
                                length = 0;
                        }
                        //
                        // Else, check to see if we have a valid number of characters.
                        // There are two hex digits per byte and one more byte chan commas.
                        // In other words, 2 chars for the first byte and 3 for every
                        // subsequent one.  For example: "0a,0b,0c,0d"
                        else
                        {
                                //
                                // This is where we will be holding the parsed bytes.
                                std::vector<u_char> data;

                                //
                                // Get a pointer to the string.
                                const char *idx = tstring.c_str();

                                //
                                // This pointer is used to find the commas between bytes.
                                char *end;

                                //
                                // Cut off any leading whitespace.
                                idx += strspn(idx, " \t\r\n");


                                //
                                // While there's a byte left to parse.
                                while(*idx != '\0')
                                {
                                        //
                                        // Get the byte value and a pointer to the end
                                        // of the hex representation.
                                        data.push_back( char(strtoul(idx, &end, 16)) );

                                        //
                                        // If the previous byte wasn't exactly 2 digits long,
                                        // then its an error.
                                        if (end != (idx+2))
                                        {
                                                ACE_ERROR_RETURN((LM_ERROR,
                                                        "(%N:%l) System property '%s' is not a valid"
                                                        " string of comma-separated hex bytes.\n",
                                                        name), -1);
                                        }

                                        //
                                        // Advance past any whitespace following the byte.
                                        idx = end + strspn(end, " \t\r\n");

                                        //
                                        // If that's the end of the string, then we're done.
                                        if (*idx == '\0')
                                                break;

                                        //
                                        // If there's more, then it must be a comma followed by
                                        // more bytes.
                                        if (*idx != ',')
                                        {
                                                ACE_ERROR_RETURN((LM_ERROR,
                                                        "(%N:%l) System property '%s' is not a valid"
                                                        " string of comma-separated hex bytes.\n",
                                                        name), -1);
                                        }

                                        //
                                        // Advance to the char immediately following the comma.
                                        ++idx;

                                        //
                                        // Cut off any leading whitespace.
                                        idx += strspn(idx, " \t\r\n");
                                }

                                //
                                // Set the size of the data.
                                length = data.size();

                                //
                                // Allocate the binary data
                                char *v = new char[length];
                                value = v;

                                //
                                // Copy the vector's contents into the value.
                                std::copy(data.begin(), data.end(), v);
                        }
                }
        }

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to get system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::GetBooleanEntry(const SectionKey_t &parent,
                                                                          const char *name, bool &value)
{
        Valuetype_t vt;

        //
        // Check the existance of the field and get its type.
        int retVal = this->find_value(parent, name, vt);
        if (retVal == -1)
        {
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property: %s\n", name), -1);
        }

        //
        // The field exists -- let's see what it is.
        switch (vt)
        {
        case SystemProperties::INTEGER:
                {
                        //
                        // Try to interpret it as zero/non-zero
                        unsigned int numeric;
                        int retVal = this->get_integer_value(parent, name, numeric);
                        if (retVal == 0)
                        {
                                value = (numeric != 0);
                                return 0;
                        }
                }
                break;

        case SystemProperties::STRING:
                {
                        //
                        // Else, try to read it as a zero/nonzero or YES/NO or TRUE/FALSE string.
                        ACE_TString tstring;
                        retVal = this->get_string_value(parent, name, tstring);
                        if (retVal == 0)
                        {
                                const char *val = tstring.c_str();
                                
                                char *end;

                                //
                                // Is it a numeric string? Can can tell if 
                                // strtol makes use of the entire string.
                                value = (strtol(val, &end, 0) != 0);
                                if (*end == '\0')
                                        return 0;
                                
                                //
                                // Else, assume its a yes/no or true/false string.
                                value = (ACE_OS::strncasecmp(tstring.c_str(), "FALSE", 5) != 0)
                                        && (ACE_OS::strncasecmp(tstring.c_str(), "NO", 5) != 0);
                                return 0;
                        }
                }

                case SystemProperties::BINARY:
                {
                        void *data = NULL;
                        size_t len = 0;

                        //
                        // Try to read it as a binary zero/nonzero value
                        retVal = this->get_binary_value(parent, name, data, len);
                        if (retVal == 0)
                        {
                                //
                                // Start just past the end of the block and work back.
                                char *it = static_cast<char *>(data) + len;
                                value = false;

                                //
                                // While we haven't found a nonzero byte and we haven't
                                // scanned the head of the data block, keep searching.
                                while (value == false && it != data)
                                {
                                        value = (*(--it) != 0);
                                }
                                
                                //
                                // We're done. Release the data block and report success.
                                delete [] static_cast<char *>(data);
                                return 0;
                        }
                }
                break;

        case SystemProperties::INVALID:
        default:
                break;
        }

        //
        // If none of the above branches returned a value, return an error.
        ACE_ERROR_RETURN((LM_ERROR,
                "(%N:%l) Unable to interpret field as a boolean: %s\n", name),
                -1);
}





int SystemProperties::SetStringEntry(const char *sectionName, const char *name,
                                                                         const char *value)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current, true);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        retVal = this->set_string_value(current, name, value);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::SetIntegerEntry(const char *sectionName,
                                                                          const char *name, unsigned int value)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current, true);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        retVal = this->set_integer_value(current, name, value);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::SetDoubleEntry(const char *sectionName, const char *name,
                                                                         double value)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current, true);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        std::ostringstream oss;
        oss << value;

        retVal = this->set_string_value(current, name, oss.str().c_str());

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::SetBinaryEntry(const char *sectionName,
                                                                         const char *name, const void * value,
                                                                         size_t length)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current, true);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        retVal = this->set_binary_value(current, name, value, length);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::SetBooleanEntry(const char *sectionName,
                                                                          const char *name, bool value)
{
        SectionKey_t current;
        int retVal = GetSectionKey(sectionName, current, true);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to find system property section: %s\n",
                        sectionName), retVal);

        retVal = this->set_integer_value(current, name, value);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::SetStringEntry(const SectionKey_t &parent,
                                                                         const char *name, const char *value)
{
        int retVal = this->set_string_value(parent, name, value);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::SetIntegerEntry(const SectionKey_t &parent,
                                                                          const char *name, unsigned int value)
{
        int retVal= this->set_integer_value(parent, name, value);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::SetDoubleEntry(const SectionKey_t &parent,
                                                                         const char *name, double value)
{
        std::ostringstream oss;
        oss << value;

        int retVal = this->set_string_value(parent, name, oss.str().c_str());

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::SetBinaryEntry(const SectionKey_t &parent,
                                                                         const char *name, const void * value,
                                                                         size_t length)
{
        int retVal = this->set_binary_value(parent, name, value, length);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::SetBooleanEntry(const SectionKey_t &parent,
                                                                          const char *name, bool value)
{
        int retVal= this->set_integer_value(parent, name, value);

        if (retVal)
                ACE_ERROR_RETURN((LM_ERROR,
                        "(%N:%l) Failed to set system property: %s\n", name), retVal);

        return 0;
}



int SystemProperties::EnumerateSections(int index, std::string &name)
{
        return EnumerateSections(this->root_section(), index, name);
}



int SystemProperties::EnumerateSections(const SectionKey_t &parent, int index,
                                                                                std::string &name)
{
        ACE_TString tStringName;
        int retVal = this->enumerate_sections(parent, index, tStringName);

        if (retVal != -1)
        {
                name = tStringName.c_str();
        }

        return retVal;
}



int SystemProperties::EnumerateEntries(int index, std::string &name,
                                                                           Valuetype_t &valuetype)
{
        return EnumerateEntries(this->root_section(), index, name, valuetype);
}



int SystemProperties::EnumerateEntries(const SectionKey_t &parent, int index,
                                                                           std::string &name,
                                                                           Valuetype_t &valuetype)
{
        ACE_TString tStringName;
        int retVal = this->enumerate_values(parent, index, tStringName, valuetype);

        if (retVal != -1)
        {
                name = tStringName.c_str();
        }

        return retVal;
}



int SystemProperties::GetSectionKey(const char *sectionName, SectionKey_t &key,
                                                                        bool createNew)
{
        return this->expand_path(this->root_section(),
                                                                sectionName, key, createNew);
}



int SystemProperties::GetSectionKey(const SectionKey_t &parent,
                                                                        const char *sectionName,
                                                                        SectionKey_t &key, bool createNew)
{
        return this->expand_path(parent, sectionName, key, createNew);
}



int SystemProperties::ImportPropertiesRegistry(const char * filename)
{
        ACE_Registry_ImpExp impexp(*this);

        return impexp.import_config(filename);
}



int SystemProperties::ExportPropertiesRegistry(const char * filename)
{
        ACE_Registry_ImpExp impexp(*this);

        return impexp.export_config(filename);
}



int SystemProperties::ImportPropertiesIni(const char * filename)
{
        ACE_Ini_ImpExp impexp(*this);

        return impexp.import_config(filename);
}



int SystemProperties::ExportPropertiesIni(const char * filename)
{
        ACE_Ini_ImpExp impexp(*this);

        return impexp.export_config(filename);
}

---