param_data.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_UTIL_PARAM_DATA_HPP
#define MLPACK_CORE_UTIL_PARAM_DATA_HPP

#include <mlpack/prereqs.hpp>

#include <boost/any.hpp>

#define TYPENAME(x) (std::string(typeid(x).name()))

namespace mlpack {
namespace util {

template<typename T>
struct IsStdVector { const static bool value = false; };

template<typename T, typename A>
struct IsStdVector<std::vector<T, A>> { const static bool value = true; };

// Default: HasSerialize = false.
template<bool HasSerialize, typename T>
struct ParameterTypeDeducer
{
  typedef T type;
};

// If we have a Serialize() function, then the type is a string.
template<typename T>
struct ParameterTypeDeducer<true, T>
{
  typedef std::string type;
};

template<typename T>
struct ParameterType
{
  typedef typename ParameterTypeDeducer<data::HasSerialize<T>::value, T>::type
      type;
};

template<typename eT>
struct ParameterType<arma::Mat<eT>>
{
  typedef std::string type;
};

template<typename eT>
struct ParameterType<arma::Col<eT>>
{
  typedef std::string type;
};

template<typename eT>
struct ParameterType<arma::Row<eT>>
{
  typedef std::string type;
};

template<typename eT, typename PolicyType>
struct ParameterType<std::tuple<mlpack::data::DatasetMapper<PolicyType>,
                     arma::Mat<eT>>>
{
  typedef std::string type;
};

struct ParamData
{
  std::string name;
  std::string desc;
  std::string tname;
  char alias;
  bool isFlag;
  bool noTranspose;
  bool required;
  bool input;
  bool loaded;
  bool isMappedString;
  boost::any value;
  boost::any mappedValue;
  std::string boostName;
  void (*outputFunction)(const ParamData&);
  void (*printFunction)(const ParamData&);
  std::string (*defaultFunction)(const ParamData&);
  std::string (*stringTypeFunction)();
};

template<typename T>
std::string MapParameterName(
    const std::string& identifier,
    const typename boost::disable_if<arma::is_arma_type<T>>::type* = 0,
    const typename boost::disable_if<data::HasSerialize<T>>::type* = 0,
    const typename boost::disable_if<std::is_same<T,
        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>::type* = 0);

template<typename T>
std::string MapParameterName(
    const std::string& identifier,
    const typename boost::enable_if_c<
        arma::is_arma_type<T>::value ||
        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
                                   arma::mat>>::value ||
        data::HasSerialize<T>::value>::type* /* junk */ = 0);

template<typename T>
T& HandleParameter(
    typename util::ParameterType<T>::type& value,
    util::ParamData& d,
    const typename boost::disable_if<arma::is_arma_type<T>>::type* = 0,
    const typename boost::disable_if<data::HasSerialize<T>>::type* = 0,
    const typename boost::disable_if<std::is_same<T,
        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>::type* = 0);

template<typename T>
T& HandleParameter(
    typename util::ParameterType<T>::type& value,
    util::ParamData& d,
    const typename boost::enable_if<arma::is_arma_type<T>>::type* = 0);

template<typename T>
T& HandleParameter(
    typename util::ParameterType<T>::type& value,
    util::ParamData& d,
    const typename boost::enable_if<std::is_same<T,
        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>::type* = 0);

template<typename T>
T& HandleParameter(
    typename util::ParameterType<T>::type& value,
    util::ParamData& d,
    const typename boost::enable_if<data::HasSerialize<T>>::type* = 0);

template<typename T>
T& HandleRawParameter(
    typename util::ParameterType<T>::type& value,
    util::ParamData& /* d */,
    const typename boost::disable_if<arma::is_arma_type<T>>::type* = 0,
    const typename boost::disable_if<data::HasSerialize<T>>::type* = 0,
    const typename boost::disable_if<std::is_same<T,
        std::tuple<data::DatasetInfo, arma::mat>>>::type* = 0)
{
  return value;
}

template<typename T>
T& HandleRawParameter(
    typename util::ParameterType<T>::type& /* value */,
    util::ParamData& d,
    const typename boost::enable_if<arma::is_arma_type<T>>::type* = 0)
{
  return *boost::any_cast<T>(&d.mappedValue);
}

template<typename T>
T& HandleRawParameter(
    typename util::ParameterType<T>::type& /* value */,
    util::ParamData& d,
    const typename boost::enable_if<data::HasSerialize<T>>::type* = 0)
{
  return *boost::any_cast<T>(&d.mappedValue);
}

template<typename T>
T& HandleRawParameter(
    typename util::ParameterType<T>::type& /* value */,
    util::ParamData& d,
    const typename boost::enable_if<std::is_same<T,
        std::tuple<data::DatasetInfo, arma::mat>>>::type* = 0)
{
  return *boost::any_cast<T>(&d.mappedValue);
}

} // namespace util
} // namespace mlpack

#include "param_data_impl.hpp"

#endif