• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMConfigOptions.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

//
// Inner includes
//

#include "../include/PCMConfigOptions.h"

#include "../include/PCMTimer.h"

#include "../include/PCMFileSystemManager.h"

#include "../include/PCMStringConverter.h"

//
// Outer includes
//

#include <iostream>
#include <fstream>

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  ConfigOptions::ConfigOptions()
        // You have to initialize the following attributes:
        // - mOptions
        // - mInitialized
  {
        mOptions = new Container < ConfigOptions::Option, Mutex >;
        mInitialized = false;

        Logger::getInstance()->log(Logger::NOTICE, "Application option container has been created.");
  }

 /*----------------------------------------------------------------------*/

  ConfigOptions::~ConfigOptions()
  {
        if(mInitialized)
         finalize();

        Logger::getInstance()->log(Logger::NOTICE, "Application option container has been destroyed.");
  }

 /*----------------------------------------------------------------------*/

  //
  // Methods
  //

  void ConfigOptions::initialize()
  {
        Assert(!mInitialized, INVALID_OPERATION_ERROR, "ConfigOptions::finalize()");

        mInitialized = true;
        Logger::getInstance()->log(Logger::NOTICE, "Application option container has been initialized.");
  }

 /*----------------------------------------------------------------------*/

  void ConfigOptions::finalize()
  {
        Assert(mInitialized, INVALID_OPERATION_ERROR, "ConfigOptions::finalize()");

        mInitialized = false;
        Logger::getInstance()->log(Logger::NOTICE, "Application option container has been finalized.");
  }

 /*----------------------------------------------------------------------*/

  bool ConfigOptions::hasOption(const std::string & name)
  {
        mOptions.lock();
        bool r = mOptions->has(name);

        mOptions.unlock();
        return r;
  }

 /*----------------------------------------------------------------------*/

  std::string ConfigOptions::getString(const std::string & name)
  {
        return *static_cast < std::string * >(getValue(name, STRING)->value);
  }

 /*----------------------------------------------------------------------*/

  bool ConfigOptions::getBool(const std::string & name)
  {
        return *static_cast < bool * >(getValue(name, BOOL)->value);
  }

 /*----------------------------------------------------------------------*/

  s32 ConfigOptions::getInteger(const std::string & name)
  {
        return *static_cast < s32 * >(getValue(name, INTEGER)->value);
  }

 /*----------------------------------------------------------------------*/

  Real ConfigOptions::getReal(const std::string & name)
  {
        return *static_cast < Real * >(getValue(name, REAL)->value);
  }

 /*----------------------------------------------------------------------*/

  bool ConfigOptions::testString(const std::string & name, const std::string & value)
  {
        return hasOption(name) && getString(name) == value;
  }

 /*----------------------------------------------------------------------*/

  void ConfigOptions::setString(const std::string & name, const std::string & value,
                                const std::string & description)
  {
        setValue(name, (void *) &value, STRING, description);
        Logger::getInstance()->log(Logger::DEBUG, "Option " + name + "=`" + value + "\' has been set.");
  }

 /*----------------------------------------------------------------------*/

  void ConfigOptions::setBool(const std::string & name, const bool & value,
                                const std::string & description)
  {
        setValue(name, (void *) &value, BOOL, description);
        Logger::getInstance()->log(Logger::DEBUG,
                                 "Option " + name + "=`" + StringConverter::toString(value) + "\' has been set.");
  }

 /*----------------------------------------------------------------------*/

  void ConfigOptions::setInteger(const std::string & name, const s32 & value,
                                 const std::string & description)
  {
        setValue(name, (void *) &value, INTEGER, description);
        Logger::getInstance()->log(Logger::DEBUG,
                                 "Option " + name + "=`" + StringConverter::toString(value) + "\' has been set.");
  }

 /*----------------------------------------------------------------------*/

  void ConfigOptions::setReal(const std::string & name, const Real & value,
                                const std::string & description)
  {
        setValue(name, (void *) &value, REAL, description);
        Logger::getInstance()->log(Logger::DEBUG,
                                 "Option " + name + "=`" + StringConverter::toString(value) + "\' has been set.");
  }

 /*----------------------------------------------------------------------*/

  void ConfigOptions::removeOption(const std::string & name)
  {
        Assert(hasOption(name), INVALID_NAME_ERROR, "ConfigOptions::removeOption()");

        mOptions.lock();
        mOptions->remove(name);
        mOptions.unlock();
  }

 /*----------------------------------------------------------------------*/

  void ConfigOptions::saveToIniFile(const std::string & filename)
  {
        FileSystemManager::CppFilePointer fp(FileSystemManager::getInstance()->
                                          openAppFileCpp(filename, FileSystemManager::WRITE));

        *fp.getPtr() << "# Filename: " << FileSystemManager::getInstance()->getAppDirectory() << filename << std::endl;
        *fp.getPtr() << "# Created at " << Timer::getTimeDateString(false) << std::endl;
        *fp.getPtr() << "# Autogenerated configuration options" << std::endl << std::endl;

        // Write config options
        for(Container < ConfigOptions::Option, Mutex >::Iterator i = mOptions->begin(); i != mOptions->end(); i++)
        {
         if(i->second->description.length())
                *fp.getPtr() << "# " << i->second->description << std::endl;
         *fp.getPtr() << i->first << '=' << optionToString(i->second) << std::endl << std::endl;
        }

        // Write hint options
        if(!hasOption("lowLevelScriptFile"))
         *fp.getPtr() << "# Explicit low level script file" << std::
                endl << "#lowLevelScriptFile=scripts/low-level/<script file name>" << std::endl << std::endl;
        if(!hasOption("dynamicScriptFile"))
         *fp.getPtr() << "# Second level (cluster dynamic) script file" << std::
                endl << "#dynamicScriptFile=scripts/dynamic/<script file name>" << std::endl << std::endl;
        if(!hasOption("outputFile"))
         *fp.getPtr() << "# Explicit output file" << std::endl << "#outputFile=<output file name>" << std::
                endl << std::endl;
        if(!hasOption("pcLibraryPath"))
         *fp.getPtr() << "# PC library path" << std::
                endl << "#pcLibraryPath=<path to PC dynamic load library>" << std::endl << std::endl;

        FileSystemManager::getInstance()->closeFile(fp);

        if(Logger::getInstance())
         Logger::getInstance()->log(Logger::NOTICE,
                                   "Ini file `" + FileSystemManager::getInstance()->getAppDirectory() + filename +
                                   "\' created.");
  }

 /*----------------------------------------------------------------------*/

  void ConfigOptions::loadFromIniFile(const std::string & filename)
  {
        FileSystemManager::CppFilePointer fp(FileSystemManager::getInstance()->
                                          openAppFileCpp(filename, FileSystemManager::READ));

        const u32 lineBufSize = 1024;
        char lineBuf[lineBufSize];

        std::string line = "";
        u32 lineNumber = 0;

        while(!fp->eof())
        {
         // Read line, trim, and test comment
         fp->getline(lineBuf, lineBufSize);
         lineNumber++;

         line = lineBuf;
         StringConverter::trim(line);
         if(!line.length() || line[0] == '#')
                continue;

         // Check error
         if(line.find('=') == std::string::npos)
                Except(FILE_FORMAT_ERROR, "ConfigOptions::loadFromIniFile()",
                   "Error in config file `" + FileSystemManager::getInstance()->getAppDirectory() + filename +
                   "\':" + StringConverter::toString(lineNumber) + ": " + line);

         // Get name and value
         std::string name = line.substr(0, line.find('='));
         std::string value = line.substr(line.find('=') + 1);

         // TODO: howto handle other values 
         setString(name, value);
        }

        FileSystemManager::getInstance()->closeFile(fp);

        if(Logger::getInstance())
         Logger::getInstance()->log(Logger::NOTICE,
                                   "Ini file `" + FileSystemManager::getInstance()->getAppDirectory() + filename +
                                   "\' loaded.");
  }

 /*----------------------------------------------------------------------*/

  ConfigOptions::Option::Pointer ConfigOptions::getValue(const std::string & name,
                                                         const ConfigOptions::OptionType & type)
  {
        Assert(hasOption(name), INVALID_NAME_ERROR, "ConfigOptions::getValue()");

        mOptions.lock();
        Option::Pointer p(mOptions->get(name));
        if(p->type != type)
        {
         mOptions.unlock();
         Except(INVALID_CLASS_ERROR, "ConfigOptions::getValue()",
                 "Config option `" + name + "\' has different type.");
        }
        mOptions.unlock();
        return p;
  }

 /*----------------------------------------------------------------------*/

  void ConfigOptions::setValue(const std::string & name, const void *value,
                                 const ConfigOptions::OptionType & type, const std::string & description)
  {
        mOptions.lock();
        Option::Pointer p(new Option());

        // Set type
        p->type = type;

        // Copy value
        if(type != STRING)
        {
         u32 vSize = getOptionTypeSize(type);

         p->value = new u8[vSize];
         memcpy(p->value, value, vSize);
        } else
        {
         const std::string * s = new std::string(*static_cast < const std::string * >(value));

         p->value = (void *) s;
        }

        // Set description
        p->description = description;

        // Add to container
        if(mOptions->has(name))
        {
         mOptions->remove(name);
         mOptions->add(name, p);
        } else
         mOptions->add(name, p);

        mOptions.unlock();
  }

 /*----------------------------------------------------------------------*/

  u32 ConfigOptions::getOptionTypeSize(const ConfigOptions::OptionType & type)
  {
        switch (type)
        {
         case STRING:
                return sizeof(std::string);
         case BOOL:
                return sizeof(bool);
         case INTEGER:
                return sizeof(s32);
         case REAL:
                return sizeof(Real);
        }

        // To avoid warning
        return 1;
  }

 /*----------------------------------------------------------------------*/

  std::string ConfigOptions::optionToString(ConfigOptions::Option::Pointer & option)
  {
        switch (option->type)
        {
         case STRING:
                return *static_cast < std::string * >(option->value);
         case BOOL:
                return StringConverter::toString(*static_cast < bool * >(option->value));
         case INTEGER:
                return StringConverter::toString(*static_cast < s32 * >(option->value));
         case REAL:
                return StringConverter::toString(*static_cast < Real * >(option->value));
        }

        return "(unknown)";
  }

 /*----------------------------------------------------------------------*/

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team