configuration/configuration.hpp

//
// (c) Copyright 2012 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpnicore.
//
// libpnicore 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.
//
// libpnicore 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 libpnicore.  If not, see <http://www.gnu.org/licenses/>.
//
// ============================================================================
//
// Created on: Dec 27, 2012
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//

#pragma once

#include <iostream>
#include <boost/program_options.hpp>
#include <boost/filesystem.hpp>
#include <boost/tokenizer.hpp>
#include "../types.hpp"
#include "../error/exceptions.hpp"
#include "config_option.hpp"
#include "config_argument.hpp"

//set an abriviation for the namespace
namespace popts = boost::program_options;

namespace pni{
namespace core{

    class configuration 
    {
        private:
            popts::variables_map _vmap;

            popts::options_description _visible_opts;

            popts::options_description _hidden_opts;

            popts::positional_options_description _oargs;

            template<typename T> 
            string default_value_string(const T &v)
            {
                return boost::lexical_cast<string>(v);
            }

            template<typename T>
            string default_value_string(const std::vector<T> &v)
            {
                if(v.empty())
                    throw index_error(EXCEPTION_RECORD,
                            "Default value container is empty!");

                return boost::lexical_cast<string>(v[0]);
            }
        protected:
            std::ostream &print(std::ostream &o) const;
        public:
            //===================constructors and destructor====================
            configuration();

            configuration(const configuration &c) = delete;

            configuration(configuration &&c);

            //------------------------------------------------------------------
            ~configuration() {}

            //=====================public member functions====================== 
            const popts::options_description &visible_options() const
            {
                return _visible_opts;
            }

            //-----------------------------------------------------------------
            const popts::options_description &hidden_options() const
            {
                return _hidden_opts;
            }

            //-----------------------------------------------------------------
            const popts::positional_options_description &arguments() const
            {
                return _oargs;
            }

            //-----------------------------------------------------------------
            const popts::variables_map &map() const
            {
                return  _vmap;
            }

            //-----------------------------------------------------------------
            bool has_option(const string &name) const;

            //------------------------------------------------------------------
            template<typename T> T value(const string &name) const
            {
                if(has_option(name)) return _vmap[name].as<T>();
                {
                    cli_option_error error(EXCEPTION_RECORD,
                            "Program option ["+name+"] not passed or "
                            "inappropriate value!");
                    throw error;
                }
            }

            //------------------------------------------------------------------
            template<typename T>
            void add_option(const config_option<T> &opt,bool visible=true)
            {
                typedef boost::shared_ptr<popts::option_description> option_sptr;
                //assemble the name of the option
                string oname = opt.long_name();

                if(!opt.short_name().empty())
                    oname += ","+opt.short_name();

                //assemble the sematnic value
                auto value =
                    popts::value<T>(const_cast<T*>(opt.external_reference()));
                if(opt.has_default())
                    value->default_value(opt.default_value(),
                                         default_value_string(opt.default_value()));

                option_sptr option_ptr (new popts::option_description(oname.c_str(),
                                        value,opt.description().c_str()));

                //finally we cann add the option
                if(visible)
                    _visible_opts.add(option_ptr);
                else
                    _hidden_opts.add(option_ptr);
                
            }

            //------------------------------------------------------------------
            void add_option(const config_option<bool> &opt,bool visible=true);

            //-----------------------------------------------------------------
            template<typename T> 
            void add_argument(const config_argument<T> &arg)
            {
                typedef boost::shared_ptr<popts::option_description> option_sptr;
                //assemble the name of the option
                string oname = arg.long_name();

                //assemble the sematnic value
                auto value =
                    popts::value<T>(const_cast<T*>(arg.external_reference()));

                option_sptr option_ptr (new popts::option_description(oname.c_str(),
                                        value,arg.description().c_str()));

                //finally we cann add the option
                _hidden_opts.add(option_ptr);

                _oargs.add(arg.long_name().c_str(),arg.position());
            }


            friend std::ostream &operator<<(std::ostream &o,const configuration &c);

    };

//end of namespace
}
}