Param.hh

Go to the documentation of this file.

/*
 * Copyright 2012 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/

#ifndef _SDF_PARAM_HH_
#define _SDF_PARAM_HH_

#ifndef Q_MOC_RUN  // See: https://bugreports.qt-project.org/browse/QTBUG-22829
# include <boost/lexical_cast.hpp>
# include <boost/bind.hpp>
# include <boost/algorithm/string.hpp>
# include <boost/variant.hpp>
# include <boost/any.hpp>
# include <boost/function.hpp>
# include <boost/shared_ptr.hpp>
#endif

#include <typeinfo>
#include <string>
#include <vector>

#include "sdf/Console.hh"
#include "sdf/Types.hh"
#include "sdf/system_util.hh"

namespace sdf
{
  class SDFORMAT_VISIBLE Param;

  typedef boost::shared_ptr<Param> ParamPtr;

  typedef std::vector<ParamPtr> Param_V;

  class SDFORMAT_VISIBLE Param
  {
    public: Param(const std::string &_key, const std::string &_typeName,
                  const std::string &_default, bool _required,
                  const std::string &_description = "");

    public: virtual ~Param();

    public: std::string GetAsString() const;

    public: std::string GetDefaultAsString() const;

    public: bool SetFromString(const std::string &_value);

    public: void Reset();

    public: const std::string &GetKey() const {return this->key;}

    public: const std::type_info &GetType() const;

    public: const std::string &GetTypeName() const;

    public: bool GetRequired() const {return this->required;}

    public: bool GetSet() const {return this->set;}

    public: boost::shared_ptr<Param> Clone() const;

    public: template<typename T> void SetUpdateFunc(T _updateFunc)
            {this->updateFunc = _updateFunc;}

    public: void Update();

    public: template<typename T>
            bool Set(const T &_value)
            {
              try
              {
                this->SetFromString(boost::lexical_cast<std::string>(_value));
              }
              catch(...)
              {
                sdferr << "Unable to set parameter[" << this->key << "]."
                       << "Type type used must have a stream input and output"
                       << "operator, which allow boost::lexical_cast to"
                       << "function properly.\n";
                return false;
              }
              return true;
            }

    public: template<typename T>
            bool Get(T &_value)
            {
              try
              {
                if (typeid(T) == typeid(bool) && this->typeName == "string")
                {
                  std::string strValue =
                    boost::lexical_cast<std::string>(this->value);
                  if (strValue == "true" || strValue  == "1")
                    _value = boost::lexical_cast<T>("1");
                  else
                    _value = boost::lexical_cast<T>("0");
                }
                else
                {
                  _value = boost::lexical_cast<T>(this->value);
                }
              }
              catch(...)
              {
                sdferr << "Unable to convert parameter[" << this->key << "] "
                       << "whose type is[" << this->typeName << "], to "
                       << "type[" << typeid(T).name() << "]\n";
                return false;
              }
              return true;
            }

    public: template<typename T>
            bool GetDefault(T &_value)
            {
              try
              {
                _value = boost::lexical_cast<T>(this->defaultValue);
              }
              catch(...)
              {
                sdferr << "Unable to convert parameter[" << this->key << "] "
                       << "whose type is[" << this->typeName << "], to "
                       << "type[" << typeid(T).name() << "]\n";
                return false;
              }
              return true;
            }

    public: Param &operator =(const Param &_param)
            {
              this->value = _param.value;
              this->defaultValue  = _param.defaultValue;
              return *this;
            }

    public: void SetDescription(const std::string &_desc);

    public: std::string GetDescription() const;

    public: friend std::ostream &operator<<(std::ostream &_out,
                                             const Param &_p)
            {
              _out << _p.GetAsString();
              return _out;
            }

    private: template<typename T>
            void Init(const std::string &_value)
            {
              try
              {
                this->value = boost::lexical_cast<T>(_value);
              }
              catch(...)
              {
                if (this->typeName == "bool")
                {
                  std::string strValue = _value;
                  boost::algorithm::to_lower(strValue);
                  if (strValue == "true" || strValue == "1")
                    this->value = true;
                  else
                    this->value = false;
                }
                else
                  sdferr << "Unable to init parameter value from string["
                    << _value << "]\n";
              }

              this->defaultValue = this->value;
              this->set = false;
            }

    private: std::string key;

    private: bool required;

    private: bool set;

    private: std::string typeName;

    private: std::string description;

    private: boost::function<boost::any ()> updateFunc;

    private: typedef boost::variant<bool, char, std::string, int,
               unsigned int, double, float, sdf::Vector3, sdf::Vector2i,
               sdf::Vector2d, sdf::Quaternion, sdf::Pose, sdf::Color,
               sdf::Time> ParamVariant;

    protected: ParamVariant value;

    protected: ParamVariant defaultValue;
  };
}
#endif