iniparser_data_structures.h

//===========================================================================
#ifndef unt_INIParserDataStructuresH
#define unt_INIParserDataStructuresH
//===========================================================================
// Заготовка модуля INIParserDataStructures была сгенерирована CASE средством разработки SA2-DE.
// Все права защищены. (2011)
//
// В данном файле представлен исходный текст основного заголовочного файла модуля.
//
// ======================================= //
//       Параметры новой разработки.      
// ======================================= //
// Имя комплекса:  CommonTools  (com)
// Имя решения:    FileTools (fil)   (прочерк если модуль относится лишь к комплексу)
// Имя проекта:    INIParserLib_vs8  (ini)   (прочерк если модуль относится лишь к решению)
// Полный SID:     comfilini
// Время создания: 10:47:28    
// Дата создания:  04.05.2011     
// ======================================= //
// ============================================================================================ //
//                             Параметры ревизии(версии):                   
// ============================================================================================ //
// [prd]Period:                     5/2011
// [aut]Author:                     Александр Соколов
// [did]DeveloperID:                sa
// [pid]ProblemID:                  00001
// [rvs = did.date.pid]Revision:    //#sa.04.05.2011.00001
// [dsc]Description:                Структуры данных, используемые INI парсером.
// [ccm]CodeComment:                rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
// ============================================================================================ //
#include "libtools.h"
#include "iniparser.h"

#include <string>
#include <list>
#include <map>

#include <boost/spirit/include/qi.hpp>

namespace com
{
    namespace ini
    {
        //------------------------------------------------------------------------
        template<typename charType>
        class strAppend
        {
            std::basic_string<charType, std::char_traits<charType>, std::allocator<charType> >& mStr;
        public:
            strAppend(std::basic_string<charType, std::char_traits<charType>, std::allocator<charType> >& o_destStr)
                :mStr(o_destStr)
            {
                mStr.clear();
            }

            void operator()(charType v_ch, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
                mStr.push_back(v_ch);
            }
        };
        //------------------------------------------------------------------------
        template<typename charType>
        class slistAdd
        {
            std::list< std::basic_string<charType, std::char_traits<charType>, std::allocator<charType> > >& mList;
            std::basic_string<charType, std::char_traits<charType>, std::allocator<charType> >& mAddition;
        public:
            slistAdd(std::list< std::basic_string<charType, std::char_traits<charType>, std::allocator<charType> > >& o_list,
                        std::basic_string<charType, std::char_traits<charType>, std::allocator<charType> >& p_addition)
                :mList(o_list)
                ,mAddition(p_addition)
            {}

            void operator()(charType v_indicator, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
                mList.push_back(mAddition);
                mAddition.clear();
            }
        };
        //------------------------------------------------------------------------
        template<template<typename, typename> class Container, typename Data>
        class twoDimContainerPushBack
        {
            Container<Data, std::allocator<Data> >& mList;
            Container<Container<Data, std::allocator<Data>>, std::allocator<Container<Data, std::allocator<Data> > > >& mLList;
        public:
            twoDimContainerPushBack(Container<Data, std::allocator<Data>>& o_list,
                                    Container<Container<Data, std::allocator<Data>>, std::allocator<Container<Data, std::allocator<Data> > > >& o_llist)
                :mList(o_list)
                ,mLList(o_llist)
            {}

            void operator()(char const& ch, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
                mLList.push_back(mList);
                mList.clear();
            }
        };

        template<template<typename, typename> class Container, class Data>
        class containerPushBack
        {
            Container<Data, std::allocator<Data> >& mList;
        public:
            containerPushBack(Container<Data, std::allocator<Data> >& o_list)
                :mList(o_list)
            {}

            void operator()(const Data& v_param, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
                mList.push_back(v_param);
            }
        };

        template<template<typename, typename> class Container, class Data>
        class containerPushBackLast
        {
            Container<Data, std::allocator<Data> >& mList;
            Data& mBuf;

        public:
            containerPushBackLast(Data& o_buf, Container<Data, std::allocator<Data> >& o_list)
                :mList(o_list)
                ,mBuf(o_buf)
            {}

            void operator()(const std::string& dummy, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
                mList.push_back(mBuf);
                mBuf.clear();
            }

            void operator()(const char& dummy, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
                mList.push_back(mBuf);
                mBuf.clear();
            }
        };

/*
        template<template<typename, typename> class Container, class Data>
        class containerPushBack
        {
            Container<Data, std::allocator<Data> >& mList;
        public:
            containerPushBack(Container<Data, std::allocator<Data> >& o_list)
                :mList(o_list)
            {}

            void operator()(const Data& v_param, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
                mList.push_back(v_param);
            }
        };
*/

/*
        template<class Container, class Data>
        class twoDimContainerPushBack
        {
            std::list< double >& mList;
            std::list< std::list< double > >& mLList;
        public:
            twoDimListPushBack(std::list< double >& o_list, std::list< std::list< double > >& o_llist)
                :mList(o_list)
                ,mLList(o_llist)
            {}

            void operator()(char const& ch, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
                mLList.push_back(mList);
                mList.clear();
            }
        };
        //------------------------------------------------------------------------
        //------------------------------------------------------------------------
        template<class T>
        class containerPushBack
        {
            std::list< T >& mList;
        public:
            listPushBack(std::list< T >& o_list)
                :mList(o_list)
            {}

            void operator()(T const& v_param, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
                mList.push_back(v_param);
            }
        };
*/
        //------------------------------------------------------------------------
        // A function object 3
        template<class Key, class Data>
        class mapPushBack
        {
            std::map< Key, Data >& mMap;
            Key& mKey;
            Data& mData;
        public:
            mapPushBack(std::map< Key, Data >& o_map, Key& o_key, Data& o_data)
                :mMap(o_map)
                ,mKey(o_key)
                ,mData(o_data)
            {}

            void operator()(char v_indicator, boost::spirit::qi::unused_type, boost::spirit::qi::unused_type) const
            {
              mMap[mKey] = mData;
              mKey = Key();
              mData = Data();
            }
        };

        //------------------------------------------------------------------------
        INIParser::ErrorCode stringListFromString(const std::string& p_inputStr,
                                                  char p_leftBracket,
                                                  char p_rightBracket,
                                                  char p_separator,
                                                  std::list< std::string >& o_list);

        INIParser::ErrorCode twoDimDoubleArrayFromString(const std::string& p_inputStr,
                                                         char p_leftBracket,
                                                         char p_rightBracket,
                                                         char p_separator,
                                                         std::vector< std::vector<double> >& o_list,
                                                         double& o_currentValue,
                                                         std::vector<std::string>& o_units);

        INIParser::ErrorCode strDoubleMapFromString(const std::string& p_inputStr,
                                                    char p_leftBracket,
                                                    char p_rightBracket,
                                                    char p_separator,
                                                    std::map< std::string, double >& o_map);

        INIParser::ErrorCode strMapFromString(const std::string& p_inputStr,
                                              char p_leftBracket,
                                              char p_rightBracket,
                                              char p_separator,
                                              std::map< std::string, std::string >& o_map);

        //------------------------------------------------------------------------
        INIParser::ErrorCode setValueWithEnumerationValues(const std::string& p_inputStr,
                                                           std::string& o_current_value,
                                                           std::list< std::string >& o_valuelist);

        std::string removeParamSpecification(const std::string& p_inputParamNameWithSpec);
    }
}

//===========================================================================
#endif
//===========================================================================