get_param.hpp

Go to the documentation of this file.

#ifndef MLPACK_BINDINGS_CLI_GET_PARAM_HPP
#define MLPACK_BINDINGS_CLI_GET_PARAM_HPP

#include <mlpack/prereqs.hpp>
#include "parameter_type.hpp"

namespace mlpack {
namespace bindings {
namespace cli {

template<typename T>
T& GetParam(
    util::ParamData& d,
    const typename boost::disable_if>::type* = 0,
    const typename boost::disable_if<data::HasSerialize>::type* = 0,
    const typename boost::disable_if         std::tuple>>::type* = 0) {   // No mapping is needed, so just cast it directly.   return *boost::any_cast(&d.value); }  template<typename T> T& GetParam(     util::ParamData& d,     const typename boost::enable_if>::type* = 0) {   // If the matrix is an input matrix, we have to load the matrix.  'value'   // contains the filename.  It's possible we could load empty matrices many   // times, but I am not bothered by that---it shouldn't be something that   // happens.   typedef std::tuple::type> TupleType;   TupleType& tuple = *boost::any_cast(&d.value);   const std::string& value = std::get<1>(tuple);   T& matrix = std::get<0>(tuple);   if (d.input && !d.loaded)   {     // Call correct data::Load() function.     if (arma::is_Row::value || arma::is_Col::value)       data::Load(value, matrix, true);     else       data::Load(value, matrix, true, !d.noTranspose);     d.loaded = true;   }    return matrix; }  template<typename T> T& GetParam(     util::ParamData& d,     const typename boost::enable_if         std::tuple>>::type* = 0) {   // If this is an input parameter, we need to load both the matrix and the   // dataset info.   typedef std::tuple TupleType;   TupleType* tuple = boost::any_cast(&d.value);   const std::string& value = std::get<1>(*tuple);   T& t = std::get<0>(*tuple);   if (d.input && !d.loaded)   {     data::Load(value, std::get<1>(t), std::get<0>(t), true, !d.noTranspose);     d.loaded = true;   }    return t; }  template<typename T> T*& GetParam(     util::ParamData& d,     const typename boost::disable_if>::type* = 0,     const typename boost::enable_if<data::HasSerialize>::type* = 0) {   // If the model is an input model, we have to load it from file.  'value'   // contains the filename.   typedef std::tuple TupleType;   TupleType* tuple = boost::any_cast(&d.value);   const std::string& value = std::get<1>(*tuple);   if (d.input && !d.loaded)   {     T* model = new T();     data::Load(value, "model", *model, true);     d.loaded = true;     std::get<0>(*tuple) = model;   }   return std::get<0>(*tuple); }  template<typename T> void GetParam(util::ParamData& d, const void* /* input */, void* output) {   // Cast to the correct type.   *((T**) output) = &GetParam::type>(d); }  } // namespace cli } // namespace bindings } // namespace mlpack  #endif











        std::tuple>>::type* = 0)
{
  // No mapping is needed, so just cast it directly.
  return *boost::any_cast(&d.value);
}

template<typename T>
T& GetParam(
    util::ParamData& d,
    const typename boost::enable_if>::type* = 0)
{
  // If the matrix is an input matrix, we have to load the matrix.  'value'
  // contains the filename.  It's possible we could load empty matrices many
  // times, but I am not bothered by that---it shouldn't be something that
  // happens.
  typedef std::tuple::type> TupleType;
  TupleType& tuple = *boost::any_cast(&d.value);
  const std::string& value = std::get<1>(tuple);
  T& matrix = std::get<0>(tuple);
  if (d.input && !d.loaded)
  {
    // Call correct data::Load() function.
    if (arma::is_Row::value || arma::is_Col::value)
      data::Load(value, matrix, true);
    else
      data::Load(value, matrix, true, !d.noTranspose);
    d.loaded = true;
  }

  return matrix;
}

template<typename T>
T& GetParam(
    util::ParamData& d,
    const typename boost::enable_if         std::tuple>>::type* = 0) {   // If this is an input parameter, we need to load both the matrix and the   // dataset info.   typedef std::tuple TupleType;   TupleType* tuple = boost::any_cast(&d.value);   const std::string& value = std::get<1>(*tuple);   T& t = std::get<0>(*tuple);   if (d.input && !d.loaded)   {     data::Load(value, std::get<1>(t), std::get<0>(t), true, !d.noTranspose);     d.loaded = true;   }    return t; }  template<typename T> T*& GetParam(     util::ParamData& d,     const typename boost::disable_if>::type* = 0,     const typename boost::enable_if<data::HasSerialize>::type* = 0) {   // If the model is an input model, we have to load it from file.  'value'   // contains the filename.   typedef std::tuple TupleType;   TupleType* tuple = boost::any_cast(&d.value);   const std::string& value = std::get<1>(*tuple);   if (d.input && !d.loaded)   {     T* model = new T();     data::Load(value, "model", *model, true);     d.loaded = true;     std::get<0>(*tuple) = model;   }   return std::get<0>(*tuple); }  template<typename T> void GetParam(util::ParamData& d, const void* /* input */, void* output) {   // Cast to the correct type.   *((T**) output) = &GetParam::type>(d); }  } // namespace cli } // namespace bindings } // namespace mlpack  #endif











        std::tuple>>::type* = 0)
{
  // If this is an input parameter, we need to load both the matrix and the
  // dataset info.
  typedef std::tuple TupleType;
  TupleType* tuple = boost::any_cast(&d.value);
  const std::string& value = std::get<1>(*tuple);
  T& t = std::get<0>(*tuple);
  if (d.input && !d.loaded)
  {
    data::Load(value, std::get<1>(t), std::get<0>(t), true, !d.noTranspose);
    d.loaded = true;
  }

  return t;
}

template<typename T>
T*& GetParam(
    util::ParamData& d,
    const typename boost::disable_if>::type* = 0,
    const typename boost::enable_if<data::HasSerialize>::type* = 0)
{
  // If the model is an input model, we have to load it from file.  'value'
  // contains the filename.
  typedef std::tuple TupleType;
  TupleType* tuple = boost::any_cast(&d.value);
  const std::string& value = std::get<1>(*tuple);
  if (d.input && !d.loaded)
  {
    T* model = new T();
    data::Load(value, "model", *model, true);
    d.loaded = true;
    std::get<0>(*tuple) = model;
  }
  return std::get<0>(*tuple);
}

template<typename T>
void GetParam(util::ParamData& d, const void* /* input */, void* output)
{
  // Cast to the correct type.
  *((T**) output) = &GetParam::type>(d);
}

} // namespace cli
} // namespace bindings
} // namespace mlpack

#endif