get_param_options.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <list>
#include <string>
 
#include <XmlRpcValue.h>
 
#include <cras_cpp_common/string_utils.hpp>
#include <cras_cpp_common/xmlrpc_value_utils.hpp>
 
namespace cras
{
 
template<typename ResultType, typename ParamServerType>
struct DefaultToResultFn
{
  static ResultType toResult(const ParamServerType& value)
  {
    return static_cast<ResultType>(value);
  };
};
 
template<typename ParamServerType>
struct DefaultToParamFn
{
  static bool toParam(const ::XmlRpc::XmlRpcValue& x, ParamServerType& v, bool skipNonConvertible = false,
    ::std::list<::std::string>* errors = nullptr)
  {
    return ::cras::convert(x, v, skipNonConvertible, errors);
  };
};
 
template<typename T>
struct ParamToStringFn
{
  static ::std::string to_string(const T& value)
  {
    return ::cras::to_string(value);
  };
};
 
template<typename ResultType>
struct DefaultParamServerType
{
  typedef ResultType type;
};
 
template<typename ResultType, typename ParamServerType = typename ::cras::DefaultParamServerType<ResultType>::type>
struct GetParamOptions
{
  typedef ::std::function<ResultType(const ParamServerType& value)> ToResultFn;
 
  typedef ::std::function<bool(
      const ::XmlRpc::XmlRpcValue& xmlValue,
      ParamServerType& value,
      const bool skipNonConvertible,
      ::std::list<::std::string>* errors)> ToParamFn;
 
  bool printMessages {true};
 
  bool printDefaultAsWarn {false};
 
  bool throwIfConvertFails {false};
 
  bool allowNestedParams {true};
 
  ::std::string origNamespace {};
 
  ::std::string origParamName {};
 
  ::cras::ToStringFn<ParamServerType> paramToStr = &::cras::ParamToStringFn<ParamServerType>::to_string;
 
  ::cras::ToStringFn<ResultType> resultToStr = &::cras::ParamToStringFn<ResultType>::to_string;
 
  ToResultFn toResult = &::cras::DefaultToResultFn<ResultType, ParamServerType>::toResult;
 
  ToParamFn toParam = &::cras::DefaultToParamFn<ParamServerType>::toParam;
 
  template<typename R1, typename P1>
  GetParamOptions& operator=(const ::cras::GetParamOptions<R1, P1>& other)
  {
    this->printMessages = other.printMessages;
    this->printDefaultAsWarn = other.printDefaultAsWarn;
    this->throwIfConvertFails = other.throwIfConvertFails;
    this->allowNestedParams = other.allowNestedParams;
    this->origNamespace = other.origNamespace;
    this->origParamName = other.origParamName;
    return *this;
  }
 
  GetParamOptions& operator=(const ::cras::GetParamOptions<ResultType, ParamServerType>& other)
  {
    this->printMessages = other.printMessages;
    this->printDefaultAsWarn = other.printDefaultAsWarn;
    this->throwIfConvertFails = other.throwIfConvertFails;
    this->allowNestedParams = other.allowNestedParams;
    this->origNamespace = other.origNamespace;
    this->origParamName = other.origParamName;
    this->paramToStr = other.paramToStr;
    this->resultToStr = other.resultToStr;
    this->toResult = other.toResult;
    this->toParam = other.toParam;
    return *this;
  }
 
  template<typename NewParamServerType>
  ::cras::GetParamOptions<ResultType, NewParamServerType> asType(
    typename ::cras::GetParamOptions<ResultType, NewParamServerType>::ToResultFn newToResult =
      &::cras::DefaultToResultFn<ResultType, NewParamServerType>::toResult,
    ::cras::ToStringFn<NewParamServerType> newParamToStr =
      [](const NewParamServerType& s){ return ::cras::to_string(s); },
    typename ::cras::GetParamOptions<ResultType, NewParamServerType>::ToParamFn newToParam =
      [](const ::XmlRpc::XmlRpcValue& x, NewParamServerType& v, bool skipNonConvertible = false,
          ::std::list<::std::string>* errors = nullptr) -> bool {
        return ::cras::convert(x, v, skipNonConvertible, errors);
      }) const
  {
    // We can't initialize the object with the default values of toParam and toResult because they are ill-formed
    ::cras::GetParamOptions<ResultType, NewParamServerType> options =
      {{}, {}, {}, {}, {}, {}, {}, {}, newToResult, newToParam};
    options = *this;
    options.resultToStr = this->resultToStr;
    options.paramToStr = newParamToStr;
    return options;
  }
};
 
}