---

Properties.cpp

Go to the documentation of this file.

/*
 * Properties.cpp
 *
 * Copyright 2003, MobileSpear Inc. (www.mobilespear.com). All rights reserved.
 * Copyright 2003, David Resnick. All rights reserved.
 *
 * See the file doc\license.txt for the terms of usage and distribution.
 */

#include <bogotel/Portability.h>
#include <bogotel/Properties.h>

#include <sstream>

namespace bogotel {

    // CPropertiesFailure
    CPropertiesFailure::CPropertiesFailure(const std::string& reason) :
        std::runtime_error(reason) {
    }

    // CProperties

    const char * const CProperties::szKeyTerminators = "=:";
    const std::string CProperties::_strBlank = "";

    CProperties::CProperties()
    {
    }

    CProperties::~CProperties()
    {
    }

    void CProperties::load(const std::string filename) throw (CPropertiesFailure)
    {
        if (filename == "") {
            throw CPropertiesFailure(std::string("No filename specified"));
        }

        std::ifstream initFile(filename.c_str());
    
        if (!initFile) {
            throw CPropertiesFailure(std::string("Config File ") + filename + " does not exist or is unreadable");
        }

        clear();

        std::string strValue;
        std::string strKey;
        std::string strReader;
    
        while (std::getline(initFile, strReader)) {
            std::istringstream reader(strReader);
    
            if (!(reader >> strReader)) {
                continue;
            }

            // skip comment lines 
            if (strReader[0] == '#' || strReader[0] == '!') {
                continue;
            }

            std::string::size_type iTermPos;
            // check for key termination character in key
            if ((iTermPos = strReader.find_first_of(szKeyTerminators)) != std::string::npos) {
                strKey = strReader.substr(0, iTermPos);
                // eat whitespace
                reader >> std::ws;
                // check for characters directly following the key terminator
                if ((strReader.length() - 1) > iTermPos) {
                    strValue = strReader.substr(iTermPos + 1);
                    // get rest of line
                    if (std::getline(reader, strReader)) {
                        // append rest of line
                        strValue += strReader;
                    }
                } else {
                    // get rest of line
                    if (std::getline(reader, strReader)) {
                        // check for key termination character
                        if ((iTermPos = strReader.find_first_of(szKeyTerminators)) == std::string::npos) {
                            // no key termination char -- rest of line is value
                            strValue = strReader;
                        } else {
                            strValue = strReader.substr(iTermPos);
                        }
                    }
                }
            } else {
                strKey = strReader;
                if (!(reader >> strReader)) {
                    // there is nothing more on the line, value is blank
                    strValue = "";
                } else {
                    // check for key termination character
                    if ((iTermPos = strReader.find_first_of(szKeyTerminators)) == std::string::npos) {
                        // no key termination char -- rest of line is value
                        strValue = strReader;
                    } else {
                        if (strReader.length() > 1) {
                            // the remainder of the string is the value
                            strValue = strReader.substr(1);
                        } else {
                            strValue = "";
                        }
                        // get the rest of the line
                        if (reader >> strReader) {
                            strValue += strReader;
                        }
                    }
                }
            }
            operator[](strKey) = strValue;
        }
    }

    const std::string CProperties::getProperty(const std::string& strKey)
    {
        return getProperty(strKey, _strBlank);
    }

    const std::string CProperties::getProperty(const std::string& strKey, const std::string& strDefault)
    {
        StringMap::const_iterator i = find(strKey);
        if (i != end()) {
            return i->second;
        } else {
            return strDefault;
        }
    }

    const int CProperties::getProperty(const std::string& strKey, const int iDefault)
    {
        std::ostringstream o;
        o << iDefault;
        return atoi(getProperty(strKey, std::string(o.str())).c_str());
    }

    const long CProperties::getProperty(const std::string& strKey, const long lDefault)
    {
        std::ostringstream o;
        o << lDefault;
        return atol(getProperty(strKey, std::string(o.str())).c_str());
    }

    const unsigned long CProperties::getProperty(const std::string& strKey, const unsigned long ulDefault)
    {
        std::ostringstream o;
        o << ulDefault;
        return strtoul(getProperty(strKey, std::string(o.str())).c_str(), NULL, 10);
    }

    const std::string CProperties::setProperty(const std::string& strKey, const std::string& strValue)
    {
        std::string strPrev = getProperty(strKey);
        operator[](strKey) = strValue;
        return strPrev;
    }

    const int CProperties::setProperty(const std::string& strKey, const int iValue)
    {
        std::ostringstream o;
        o << iValue;
        return atoi(setProperty(strKey, o.str()).c_str());
    }

    void CProperties::list(std::ostream& out)
    {
        StringMap::const_iterator iter = begin();
        while (iter != end()) {
            out << '\"'
                << iter->first
                << '\"'
                << '='
                << '\"'
                << iter->second
                << '\"'
                << std::endl;

            iter++;
        }
    }

    void CProperties::putAll(CProperties& src)
    {
        for (StringMap::iterator iter = src.begin();
             iter != src.end();
             iter++) {
            operator[](iter->first) = iter->second;
        }
    
    }
}

---