settings.h

Go to the documentation of this file.

/*
    Ishtar - A network transparent read/write interface with
    probing and enumeration support.
    settings part : settings file parsing and writing
    Copyright (C) 2003-2005 Stephane Magnenat <stephane at magnenat dot net>

    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
*/

/*
    Settings
    
    Provides setting registrar that is itself an Ishtar server
*/

#ifndef __ISHTAR_SETTINGS_H
#define __ISHTAR_SETTINGS_H

#include <ishtar/network.h>
#include <ishtar/services.h>
#include <sstream>
#include <set>
#include <string>
#include <valarray>
#include <iterator>


namespace Ishtar
{
    typedef std::vector<std::string> ParsedValues;
    typedef std::map<std::string, ParsedValues> ParserTable;
    
    class Settings: public ServicesServer
    {
    public:
        ParserTable parsedTable;
    
    public:
        Settings(UInt16 port);
        virtual ~Settings();
        
        void loadConfigFile(const std::string &name);
        void loadConfigString(const std::string &config);
        void dumpTable(void);
        void saveConfigFile(const std::string &name);
    };
    
    
    extern Settings *settings;
    
    void initSettings(int argc = 0, char *argv[] = NULL);
    
    void cleanupSettings(void);
    
    template<typename T, bool ro, Size s>
    class GenericVarService:public Service
    {
    private:
        unsigned refCount;
        
    public:
        T v[s];
        
    public:
        GenericVarService(const std::string &name)
        {
            description.name = name;
            description.type = TypeResolver<T>::type;
            description.flags = ro ? ServiceDescription::READ_ONLY : 0;
            description.length = s;
            refCount = 1;
        }
        
        virtual ValueVector *getValues(void)
        {
            ValueVectorTemplate<T> *vvt = new ValueVectorTemplate<T>(s);
            std::copy(&v[0], &v[s], vvt->value.begin());
            return vvt;
        }
        
        virtual void setValues(ValueVector *values)
        {
            ValueVectorTemplate<T> *vvt = dynamic_cast<ValueVectorTemplate<T> *>(values);
            assert(vvt->value.size() == s);
            if (vvt)
            {
                std::copy(vvt->value.begin(), vvt->value.end(), &v[0]);
            }
            else
            {
                const std::string &name = description.name;
                std::cerr << "!!! Wrong type passed to " << name << "::setValues" << std::endl;
            }
        }
        
        void decCount() { refCount--; if (refCount==0) settings->eraseService(this); }
        void incCount() { refCount++; }
    };
    
    template<bool ro, Size s>
    class GenericVarService<std::string, ro, s>:public Service
    {
    private:
        unsigned refCount;
        
    public:
        std::string v;
        
    public:
        GenericVarService(const std::string &name)
        {
            description.name = name;
            description.type = ValueVector::UCHAR;
            description.flags = ro ? ServiceDescription::READ_ONLY : 0;
            description.length = 0;
            refCount = 1;
        }
        
        virtual ValueVector *getValues(void)
        {
            return new CharValueVector(v);
        }
        
        virtual void setValues(ValueVector *values)
        {
            CharValueVector *vvt = dynamic_cast<CharValueVector *>(values);
            if (vvt)
            {
                v = *vvt;
            }
            else
            {
                const std::string &name = description.name;
                std::cerr << "!!! Wrong type passed to " << name << "::setValues" << std::endl;
            }
        }
        
        void decCount() { refCount--; if (refCount==0) settings->eraseService(this); }
        void incCount() { refCount++; }
    };
    
    template<typename T, bool ro = false, Size s = 1, bool warningWhenInitializedWithDefaultValue = true>
    class Variable
    {
    private:
        GenericVarService<T, ro, s> *ptr;
        
    public:
        Variable(const std::string &name, T defaultValue = T())
        {
            associate(name, defaultValue);
        }
        
        ~Variable()
        {
            assert(ptr);
            ptr->decCount();
        }
        
        void associate(const std::string &name, T defaultValue)
        {
            assert(settings);
            
            // Find service
            Service *service = settings->findService(name);
            
            if (service == NULL)
            {
                // Service does not exists, create it
                ptr = new GenericVarService<T, ro, s>(name);
                settings->addService(ptr);
                
                // Set default value
                std::fill(&ptr->v[0], &ptr->v[s], defaultValue);
                
                // Get initial value from settings
                ParserTable::iterator i = settings->parsedTable.find(name);
                if (i != settings->parsedTable.end())
                {
                    if (s == i->second.size())
                    {
                        for (Size j=0; j<i->second.size(); j++)
                        {
                            std::istringstream iss(i->second[j]);
                            T tv;
                            iss >> tv;
                            ptr->v[j] = tv;
                        }
                    }
                    else
                    {
                        std::cerr << "!!! Config entry " << name << " has wrong number of parameter" << std::endl;
                    }
                }
                else if (warningWhenInitializedWithDefaultValue)
                {
                    std::cout << "Ishtar::Variable::associate : service named " << name << " was initialized with default value (" << defaultValue << ")." << std::endl;
                }
            }
            else
            {
                ptr = dynamic_cast<GenericVarService<T, ro, s> *> (service);
                if (ptr)
                {
                    ptr->incCount();
                }
                else
                {
                    std::cerr << "!!! Ishtar::Variable::associate : a service named " << name << " of another type already exists !" << std::endl;
                    assert(false);
                }
            }
        }
        
        Variable(const Variable<T, ro, s>& v) { ptr = v.ptr; ptr->incCount(); }
        
        Variable& operator=(const Variable<T, ro, s>& v) { GenericVarService<T, ro, s> *oPtr = ptr; ptr = v.ptr; ptr->incCount(); oPtr->decCount(); return *this; }
        
        operator T&() const
        {
            assert(ptr);
            return ptr->v[0];
        }
        
        T& operator[](Size index) const
        {
            assert(ptr);
            assert(index < s);
            return ptr->v[index];
        }
        
        Variable & operator=(const T &val)
        {
            assert(ptr);
            ptr->v[0] = val;
            return *this;
        }
        
        Variable & operator=(const T val[s])
        {
            assert(ptr);
            memcpy(ptr->v, val, s * sizeof(T));
            return *this;
        }
    };
    
    template<bool ro, bool warningWhenInitializedWithDefaultValue>
    class Variable<std::string, ro, 1, warningWhenInitializedWithDefaultValue>
    {
    private:
        GenericVarService<std::string, ro, 1> *ptr;
        
    public:
        Variable(const std::string &name, const std::string &defaultValue = "")
        {
            associate(name, defaultValue);
        }
        
        ~Variable()
        {
            assert(ptr);
            ptr->decCount();
        }
        
        void associate(const std::string &name, const std::string &defaultValue)
        {
            // Find service
            Service *service = settings->findService(name);
            
            if (service == NULL)
            {
                // Service does not exists, create it
                ptr = new GenericVarService<std::string, ro, 1>(name);
                settings->addService(ptr);
                
                // Set default value
                ptr->v = defaultValue;
                
                // Get initial value from settings
                ParserTable::iterator i = settings->parsedTable.find(name);
                if (i != settings->parsedTable.end())
                {
                    if (i->second.size() == 1)
                    {
                        ptr->v = i->second[0];
                    }
                    else
                    {
                        std::cerr << "!!! Config entry " << name << " should be of type string and thus have only one parameter" << std::endl;
                    }
                }
                else if (warningWhenInitializedWithDefaultValue)
                {
                    std::cout << "Ishtar::Variable::associate : service named " << name << " was initialized with default value (" << defaultValue << ")." << std::endl;
                }
            }
            else
            {
                ptr = dynamic_cast<GenericVarService<std::string, ro, 1> *> (service);
                if (ptr)
                {
                    ptr->incCount();
                }
                else
                {
                    std::cerr << "!!! Ishtar::Variable::associate : a service named " << name << " of another type already exists !" << std::endl;
                    assert(false);
                }
            }
        }
        
        Variable(const Variable<std::string, ro, 1>& v) { ptr = v.ptr; ptr->incCount(); }
        
        Variable& operator=(const Variable<std::string, ro, 1>& v) { GenericVarService<std::string, ro, 1> *oPtr = ptr; ptr = v.ptr; ptr->incCount(); oPtr->decCount(); return *this; }
        
        operator std::string &() const
        {
            assert(ptr);
            return ptr->v;
        }
        
        operator const char *() const
        {
            assert(ptr);
            return ptr->v.c_str();
        }
        
        Variable & operator=(const std::string &s)
        {
            assert(ptr);
            ptr->v = s;
            return *this;
        }
        
        Variable & operator=(const char *s)
        {
            assert(ptr);
            ptr->v = s;
            return *this;
        }
    };
    
    template<typename T>
    class ValuesAccumulator : public std::vector<T>
    {
    public:
        ValuesAccumulator &operator +(const T &v) { push_back(v); return *this; }
    };
    
    typedef ValuesAccumulator<std::string> StringsAccumulator;
    
    template<typename T, bool ro = false, Size s = 1, bool warningWhenInitializedWithDefaultValue = false>
    class VarAccessService : public Service
    {
    protected:
        T *valuesPtr;
        
    public:
        VarAccessService()
        {
            valuesPtr = NULL;
        }
        
        void associate(const std::string &name, T *variables, const StringsAccumulator &subnames = StringsAccumulator())
        {
            description.name = name;
            description.type = TypeResolver<T>::type;
            description.flags = ro ? ServiceDescription::READ_ONLY : 0;
            description.length = s;
            
            // if each variable in the array is named
            if (subnames.size() != 0)
            {
                description.flags |= ServiceDescription::NAMED_VALUES;
                description.subnames.resize(subnames.size());
                for (size_t i = 0; i < subnames.size(); i++)
                    description.subnames[i] = subnames[i];
            }
            
            valuesPtr = variables;
            
            // Get initial value from settings
            ParserTable::iterator i = settings->parsedTable.find(name);
            if (i != settings->parsedTable.end())
            {
                if (s == i->second.size())
                {
                    for (Size j=0; j<i->second.size(); j++)
                    {
                        std::istringstream iss(i->second[j]);
                        T tv;
                        iss >> tv;
                        valuesPtr[j] = tv;
                    }
                }
                else
                {
                    std::cerr << "!!! Config entry " << name << " has wrong number of parameter" << std::endl;
                }
            }
            else if (warningWhenInitializedWithDefaultValue)
            {
                std::cout << "Ishtar::VarAccessService::associate : service named " << name << " was not initialized with config file." << std::endl;
            }
            
            settings->addService(this);
        }
        
        virtual ~VarAccessService()
        {
        }
        
        virtual ValueVector *getValues(void)
        {
            ValueVectorTemplate<T> *vvt = new ValueVectorTemplate<T>(s);
            std::copy(valuesPtr, valuesPtr+s, &vvt->value[0]);
            return vvt;
        }
        
        virtual void setValues(ValueVector *values)
        {
            ValueVectorTemplate<T> *vvt = dynamic_cast<ValueVectorTemplate<T> *>(values);
            assert(vvt->value.size() == s);
            if (vvt)
            {
                std::copy(&vvt->value[0], &vvt->value[s], valuesPtr);
            }
            else
            {
                const std::string &name = description.name;
                std::cerr << "!!! Wrong type passed to " << name << "::setValues" << std::endl;
            }
        }
    };
    
    class VariablesPublisher
    {
    protected:
        std::vector<Service *> accessors;
        std::string root;
        
    public:
        VariablesPublisher(const std::string &root = "")
        {
            this->root = root;
        }
        
        virtual ~VariablesPublisher()
        {
            for (size_t i=0; i<accessors.size(); i++)
                settings->eraseService(accessors[i]);
        }
        
        void setRoot(const std::string &root) { this->root = root; }
        
        template<typename T, bool ro, Size sz, bool warningWhenInitializedWithDefaultValue>
        void add(T *var, const std::string &name, const StringsAccumulator &subnames = StringsAccumulator())
        {
            VarAccessService<T, ro, sz, warningWhenInitializedWithDefaultValue> *s = new VarAccessService<T, ro, sz, warningWhenInitializedWithDefaultValue>();
            s->associate(root + name, var, subnames);
            accessors.push_back(s);
        }
        
        template<typename T, bool ro, Size sz>
        void add(T *var, const std::string &name, const StringsAccumulator &subnames = StringsAccumulator())
        {
            add<T, ro, sz, false>(var, name, subnames);
        }
        
        template<typename T, bool ro>
        void add(T *var, const std::string &name, const StringsAccumulator &subnames = StringsAccumulator())
        {
            add<T, ro, 1>(var, name, subnames);
        }
        
        template<typename T>
        void add(T *var, const std::string &name, const StringsAccumulator &subnames = StringsAccumulator())
        {
            add<T, false>(var, name, subnames);
        }
    };
    
    /*template<typename T, bool ro = false, Size s = 1>
    class FastVariable
    {
    protected:
        T var;
        FastVarService<T, ro, s> service;
        
    public:
        FastVariable(const std::string &name , const std::string &defaultValue = "")
        {
            service.associate(name, &var, NULL);
        }
    
        operator T&() { return var; }
        operator const T&() const { return var; }
    };*/
    
    class ArrayHelper
    {
    protected:
        std::string root;
        Variable<unsigned, true, 1> maxIndex;
        
    public:
        ArrayHelper(const std::string &root)
            :maxIndex(root + ".count", 0)
        {
            this->root = root;
        }
        
        std::string getNewRoot(void)
        {
            std::ostringstream oss;
            oss << root << "." << maxIndex;
            maxIndex = maxIndex + 1;
            // TODO : duplicate values from default value
            return oss.str();
        }
        
        unsigned getMaxIndex(void) { return maxIndex; }
        
        std::string getRoot(unsigned index)
        {
            std::ostringstream oss;
            oss << root << "." << index;
            return oss.str();
        }
        
        size_t getSettingsCount(void)
        {
            size_t i = 0;
            while (true)
            {
                std::ostringstream oss;
                oss << root << "." << i;
                const std::string &rootToTest = oss.str();
                bool found = false;
                for (ParserTable::iterator it = settings->parsedTable.begin(); it != settings->parsedTable.end(); ++it)
                {
                    if (it->first.compare(0, rootToTest.length(), rootToTest) == 0)
                        found = true;
                }
                if (!found)
                    break;
                i++;
            }
            return i;
        }
    };
}

#endif

---