GenericParam.h

/*********************************************************************
* Software License Agreement (BSD License)
*
*  Copyright (c) 2011, Willow Garage
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*   * Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*   * Redistributions in binary form must reproduce the above
*     copyright notice, this list of conditions and the following
*     disclaimer in the documentation and/or other materials provided
*     with the distribution.
*   * Neither the name of the Willow Garage nor the names of its
*     contributors may be used to endorse or promote products derived
*     from this software without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
*********************************************************************/

/* Author: Ioan Sucan */

#ifndef OMPL_BASE_GENERIC_PARAM_
#define OMPL_BASE_GENERIC_PARAM_

#include "ompl/util/Console.h"
#include "ompl/util/ClassForward.h"
#include <functional>
#include <boost/lexical_cast.hpp>
#include <iostream>
#include <string>
#include <vector>
#include <map>

namespace ompl
{
    namespace base
    {


        OMPL_CLASS_FORWARD(GenericParam);

        class GenericParam
        {
        public:

            GenericParam(const std::string &name) : name_(name)
            {
            }

            virtual ~GenericParam()
            {
            }

            const std::string& getName() const
            {
                return name_;
            }

            void setName(const std::string &name)
            {
                name_ = name;
            }

            virtual bool setValue(const std::string &value) = 0;

            virtual std::string getValue() const = 0;

            template<typename T>
            GenericParam& operator=(const T &value)
            {
                try
                {
                    setValue(boost::lexical_cast<std::string>(value));
                }
                catch (boost::bad_lexical_cast &e)
                {
                    OMPL_WARN("Invalid value format specified for parameter '%s': %s", name_.c_str(), e.what());
                }
                return *this;
            }

            void setRangeSuggestion(const std::string &rangeSuggestion)
            {
                rangeSuggestion_ = rangeSuggestion;
            }

            const std::string& getRangeSuggestion() const
            {
                return rangeSuggestion_;
            }

        protected:

            template<typename T>
            const std::string& maybeWrapBool(const std::string &value) const
            {
                return boost::is_same<T, bool>::value ? truthValueTo01Str(value) : value;
            }

            std::string name_;

            std::string rangeSuggestion_;

         private:
            static const std::string& truthValueTo01Str(const std::string &value);
        };


        template<typename T>
        class SpecificParam : public GenericParam
        {
        public:

            typedef std::function<void(T)> SetterFn;

            typedef std::function<T()>     GetterFn;

            SpecificParam(const std::string &name, const SetterFn &setter, const GetterFn &getter = GetterFn()) :
                GenericParam(name), setter_(setter), getter_(getter)
            {
                if (!setter_ && !getter_)
                    OMPL_ERROR("At least one setter or getter function must be specified for parameter");
            }

            virtual ~SpecificParam()
            {
            }

            virtual bool setValue(const std::string &value)
            {
                bool result = true;
                try
                {
                    if (setter_)
                        setter_(boost::lexical_cast<T>(GenericParam::maybeWrapBool<T>(value)));
                }
                catch (boost::bad_lexical_cast &e)
                {
                    result = false;
                    OMPL_WARN("Invalid value format specified for parameter '%s': %s", name_.c_str(), e.what());
                }

                if (getter_)
                    OMPL_DEBUG("The value of parameter '%s' is now: '%s'", name_.c_str(), getValue().c_str());
                else
                    OMPL_DEBUG("The value of parameter '%s' was set to: '%s'", name_.c_str(), value.c_str());
                return result;
            }

            virtual std::string getValue() const
            {
                if (getter_)
                    try
                    {
                        return boost::lexical_cast<std::string>(getter_());
                    }
                    catch (boost::bad_lexical_cast &e)
                    {
                        OMPL_WARN("Unable to parameter '%s' to string: %s", name_.c_str(), e.what());
                        return "";
                    }
                else
                    return "";
            }

        protected:

            SetterFn setter_;

            GetterFn getter_;
        };


        OMPL_CLASS_FORWARD(ParamSet);

        class ParamSet
        {
        public:

            template<typename T>
            void declareParam(const std::string &name, const typename SpecificParam<T>::SetterFn &setter,
                              const typename SpecificParam<T>::GetterFn &getter = typename SpecificParam<T>::GetterFn())
            {
                params_[name].reset(new SpecificParam<T>(name, setter, getter));
            }

            void add(const GenericParamPtr &param);

            void remove(const std::string &name);

            void include(const ParamSet &other, const std::string &prefix = "");

            bool setParam(const std::string &key, const std::string &value);

            bool getParam(const std::string &key, std::string &value) const;

            bool setParams(const std::map<std::string, std::string> &kv, bool ignoreUnknown = false);

            void getParams(std::map<std::string, std::string> &params) const;

            void getParamNames(std::vector<std::string> &params) const;

            void getParamValues(std::vector<std::string> &vals) const;

            const std::map<std::string, GenericParamPtr>& getParams() const;

            const GenericParamPtr& getParam(const std::string &key) const;

            bool hasParam(const std::string &key) const;

            GenericParam& operator[](const std::string &key);

            std::size_t size() const
            {
                return params_.size();
            }

            void clear();

            void print(std::ostream &out) const;

        private:

            std::map<std::string, GenericParamPtr> params_;
        };
    }
}

#endif