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 SDFORMAT_PARAM_HH_
#define SDFORMAT_PARAM_HH_

#include <any>
#include <algorithm>
#include <cctype>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <limits>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <typeinfo>
#include <variant>
#include <vector>

#include <ignition/math.hh>

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

#ifdef _WIN32
// Disable warning C4251 which is triggered by
// std::unique_ptr
#pragma warning(push)
#pragma warning(disable: 4251)
#endif

namespace sdf
{
  // Inline bracket to help doxygen filtering.
  inline namespace SDF_VERSION_NAMESPACE {
  //

  class SDFORMAT_VISIBLE Param;

  typedef std::shared_ptr<Param> ParamPtr;

  typedef std::vector<ParamPtr> Param_V;

  class ParamPrivate;

  template<class T>
  struct ParamStreamer
  {
    const T &val;
  };

  template<class T> ParamStreamer(T) -> ParamStreamer<T>;

  template<class T>
  std::ostream& operator<<(std::ostream &os, ParamStreamer<T> s)
  {
    os << s.val;
    return os;
  }

  template<>
  inline std::ostream& operator<<(std::ostream &os, ParamStreamer<double> s)
  {
    os << std::setprecision(std::numeric_limits<double>::max_digits10) << s.val;
    return os;
  }

  template<>
  inline std::ostream& operator<<(std::ostream &os, ParamStreamer<float> s)
  {
    os << std::setprecision(std::numeric_limits<float>::max_digits10) << s.val;
    return os;
  }

  template<class... Ts>
  std::ostream& operator<<(std::ostream& os,
                           ParamStreamer<std::variant<Ts...>> sv)
  {
    std::visit([&os](auto const &v)
      {
        os << ParamStreamer{v};
      }, sv.val);
    return os;
  }

  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: Param(const std::string &_key, const std::string &_typeName,
                  const std::string &_default, bool _required,
                  const std::string &_minValue, const std::string &_maxValue,
                  const std::string &_description = "");

    public: Param(const Param &_param);

    public: Param(Param &&_param) noexcept = default;

    public: Param &operator=(const Param &_param);

    public: Param &operator=(Param &&_param) noexcept = default;

    public: virtual ~Param();

    public: std::string GetAsString() const;

    public: std::string GetDefaultAsString() const;

    public: std::optional<std::string> GetMinValueAsString() const;

    public: std::optional<std::string> GetMaxValueAsString() const;

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

    public: void Reset();

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

    public: template<typename Type>
            bool IsType() const;

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

    public: bool GetRequired() const;

    public: bool GetSet() const;

    public: ParamPtr Clone() const;

    public: template<typename T>
            void SetUpdateFunc(T _updateFunc);

    public: void Update();

    public: template<typename T>
            bool Set(const T &_value);

    public: bool GetAny(std::any &_anyVal) const;

    public: template<typename T>
            bool Get(T &_value) const;

    public: template<typename T>
            bool GetDefault(T &_value) const;

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

    public: std::string GetDescription() const;

    public: bool ValidateValue() const;

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

    private: bool ValueFromString(const std::string &_value);

    private: std::unique_ptr<ParamPrivate> dataPtr;
  };

  class ParamPrivate
  {
    public: std::string key;

    public: bool required;

    public: bool set;

    public: std::string typeName;

    public: std::string description;

    public: std::function<std::any ()> updateFunc;

    public: typedef std::variant<bool, char, std::string, int, std::uint64_t,
                                   unsigned int, double, float, sdf::Time,
                                   ignition::math::Angle,
                                   ignition::math::Color,
                                   ignition::math::Vector2i,
                                   ignition::math::Vector2d,
                                   ignition::math::Vector3d,
                                   ignition::math::Quaterniond,
                                   ignition::math::Pose3d> ParamVariant;

    public: ParamVariant value;

    public: ParamVariant defaultValue;

    public: std::optional<ParamVariant> minValue;

    public: std::optional<ParamVariant> maxValue;
  };

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

  template<typename T>
  bool Param::Set(const T &_value)
  {
    try
    {
      std::stringstream ss;
      ss << _value;
      return this->SetFromString(ss.str());
    }
    catch(...)
    {
      sdferr << "Unable to set parameter["
             << this->dataPtr->key << "]."
             << "Type used must have a stream input and output operator,"
             << "which allows proper functioning of Param.\n";
      return false;
    }
  }

  template<typename T>
  bool Param::Get(T &_value) const
  {
    try
    {
      if (typeid(T) == typeid(bool) && this->dataPtr->typeName == "string")
      {
        std::string strValue = std::get<std::string>(this->dataPtr->value);
        std::transform(strValue.begin(), strValue.end(), strValue.begin(),
            [](unsigned char c)
            {
              return static_cast<unsigned char>(std::tolower(c));
            });

        std::stringstream tmp;
        if (strValue == "true" || strValue  == "1")
        {
          tmp << "1";
        }
        else
        {
          tmp << "0";
        }
        tmp >> _value;
      }
      else
      {
        T *value = std::get_if<T>(&this->dataPtr->value);
        if (value)
          _value = *value;
        else
        {
          std::stringstream ss;
          ss << ParamStreamer{this->dataPtr->value};
          ss >> _value;
        }
      }
    }
    catch(...)
    {
      sdferr << "Unable to convert parameter["
             << this->dataPtr->key << "] "
             << "whose type is["
             << this->dataPtr->typeName << "], to "
             << "type[" << typeid(T).name() << "]\n";
      return false;
    }
    return true;
  }

  template<typename T>
  bool Param::GetDefault(T &_value) const
  {
    std::stringstream ss;

    try
    {
      ss << ParamStreamer{this->dataPtr->defaultValue};
      ss >> _value;
    }
    catch(...)
    {
      sdferr << "Unable to convert parameter["
             << this->dataPtr->key << "] "
             << "whose type is["
             << this->dataPtr->typeName << "], to "
             << "type[" << typeid(T).name() << "]\n";
      return false;
    }

    return true;
  }

  template<typename Type>
  bool Param::IsType() const
  {
    return std::holds_alternative<Type>(this->dataPtr->value);
  }
  }
}

#ifdef _WIN32
#pragma warning(pop)
#endif

#endif