mlpack-3.4.2/doxygen/go_2print__input__processing_8hpp_source.html

 #ifndef MLPACK_BINDINGS_GO_PRINT_INPUT_PROCESSING_HPP
 #define MLPACK_BINDINGS_GO_PRINT_INPUT_PROCESSING_HPP

 #include <mlpack/prereqs.hpp>
 #include "get_type.hpp"
 #include "get_go_type.hpp"
 #include "strip_type.hpp"
 #include <mlpack/bindings/util/camel_case.hpp>

 namespace mlpack {
 namespace bindings {
 namespace go {

 template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
     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)
 {
   const std::string prefix(indent, ' ');

   std::string def = "nil";
   if (std::is_same::value)
     def = "false";

   // Capitalize the first letter of parameter name so it is
   // of exported type in Go.
   std::string paramName = d.name;
   std::string goParamName = paramName;
   if (!paramName.empty())
   {
     goParamName = util::CamelCase(goParamName, false);
   }

   std::cout << prefix << "// Detect if the parameter was passed; set if so."
             << std::endl;
   if (!d.required)
   {
     std::cout << prefix << "if param." << goParamName << " != ";

     // Print out default value.
     if (d.cppType == "std::string")
     {
       std::string value = boost::any_cast(d.value);
       std::cout << "\"" << value << "\"";
     }
     else if (d.cppType == "double")
     {
       double value = boost::any_cast<double>(d.value);
       std::cout << value;
     }
     else if (d.cppType == "int")
     {
       int value = boost::any_cast<int>(d.value);
       std::cout << value;
     }
     else if (d.cppType == "bool")
     {
       bool value = boost::any_cast<bool>(d.value);
       if (value == 0)
       std::cout << "false";
       else
       std::cout << "true";
     }
     else if (GetType(d) == "VecString" || GetType(d) == "VecInt")
     {
       std::cout << "nil";
     }

     // Print function call to set the given parameter into the io.
     std::cout << " {" << std::endl;
     std::cout << prefix << prefix << "setParam" << GetType(d) << "(\""
               << d.name << "\", param." << goParamName << ")" << std::endl;

     // Print function call to set the given parameter as passed.
     std::cout << prefix << prefix << "setPassed(\""
               << d.name << "\")" << std::endl;

     // If this parameter is "verbose", then enable verbose output.
     if (d.name == "verbose")
       std::cout << prefix << prefix << "enableVerbose()" << std::endl;

     std::cout << prefix << "}" << std::endl; // Closing brace.
   }
   else
   {
     goParamName = util::CamelCase(goParamName, true);
     // Print function call to set the given parameter into the io.
     std::cout << prefix << "setParam" << GetType(d) << "(\""
               << d.name << "\", " << goParamName << ")"
               << std::endl;

     // Print function call to set the given parameter as passed.
     std::cout << prefix << "setPassed(\"" << d.name << "\")" << std::endl;
   }
   std::cout << std::endl; // Extra line is to clear up the code a bit.
 }

 template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
     const typename boost::enable_if>::type* = 0)
 {
   const std::string prefix(indent, ' ');

   // Capitalize the first letter of parameter name so it is
   // of exported type in Go.
   std::string paramName = d.name;
   std::string goParamName = paramName;
   if (!paramName.empty())
   {
     goParamName = util::CamelCase(goParamName, false);
   }

   std::cout << prefix << "// Detect if the parameter was passed; set if so."
             << std::endl;
   if (!d.required)
   {
     std::cout << prefix << "if param." << goParamName
               << " != nil {" << std::endl;

     // Print function call to set the given parameter into the io.
     std::cout << prefix << prefix << "gonumToArma" << GetType(d)
               << "(\"" << d.name << "\", param." << goParamName
               << ")" << std::endl;

     // Print function call to set the given parameter as passed.
     std::cout << prefix << prefix << "setPassed(\"" << d.name << "\")"
               << std::endl;
     std::cout << prefix << "}" << std::endl; // Closing brace.
   }
   else
   {
     goParamName = util::CamelCase(goParamName, true);
     // Print function call to set the given parameter into the io.
     std::cout << prefix << "gonumToArma" << GetType(d)
               << "(\"" << d.name << "\", " << goParamName
               << ")" << std::endl;

     // Print function call to set the given parameter as passed.
     std::cout << prefix << "setPassed(\"" << d.name << "\")" << std::endl;
   }
   std::cout << std::endl; // Extra line is to clear up the code a bit.
 }

 template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
     const typename boost::enable_if         std::tuple>>::type* = 0)
 {
   const std::string prefix(indent, ' ');

   // Capitalize the first letter of parameter name so it is
   // of exported type in Go.
   std::string paramName = d.name;
   std::string goParamName = paramName;
   if (!paramName.empty())
   {
     goParamName = util::CamelCase(goParamName, false);
   }

   std::cout << prefix << "// Detect if the parameter was passed; set if so."
             << std::endl;
   if (!d.required)
   {
     std::cout << prefix << "if param." << goParamName
               << " != nil {" << std::endl;

     // Print function call to set the given parameter into the io.
     std::cout << prefix << prefix << "gonumToArmaMatWithInfo"
               << "(\"" << d.name << "\", param." << goParamName
               << ")" << std::endl;

     // Print function call to set the given parameter as passed.
     std::cout << prefix << prefix << "setPassed(\"" << d.name << "\")"
               << std::endl;
     std::cout << prefix << "}" << std::endl; // Closing brace.
   }
   else
   {
     goParamName = util::CamelCase(goParamName, true);
     // Print function call to set the given parameter into the io.
     std::cout << prefix << "gonumToArmaMatWithInfo"
               << "(\"" << d.name << "\", " << goParamName
               << ")" << std::endl;

     // Print function call to set the given parameter as passed.
     std::cout << prefix << "setPassed(\"" << d.name << "\")" << std::endl;
   }
   std::cout << std::endl; // Extra line is to clear up the code a bit.
 }

 template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
     const typename boost::disable_if>::type* = 0,
     const typename boost::enable_if<data::HasSerialize>::type* = 0)
 {
   // First, get the correct classparamName if needed.
   std::string goStrippedType, strippedType, printedType, defaultsType;
   StripType(d.cppType, goStrippedType, strippedType, printedType, defaultsType);

   const std::string prefix(indent, ' ');

   // Capitalize the first letter of parameter name so it is
   // of exported type in Go.
   std::string paramName = d.name;
   std::string goParamName = paramName;
   if (!paramName.empty())
   {
     goParamName = util::CamelCase(goParamName, false);
   }

   std::cout << prefix << "// Detect if the parameter was passed; set if so."
       << std::endl;
   if (!d.required)
   {
     std::cout << prefix << "if param." << goParamName << " != nil {"
               << std::endl;
     // Print function call to set the given parameter into the io.
     std::cout << prefix << prefix << "set" << strippedType << "(\""
               << d.name << "\", param." << goParamName << ")" << std::endl;

     // Print function call to set the given parameter as passed.
     std::cout << prefix << prefix << "setPassed(\"" << d.name << "\")"
               << std::endl;
     std::cout << prefix << "}" << std::endl; // Closing brace.
   }
   else
   {
     goParamName = util::CamelCase(goParamName, true);
     // Print function call to set the given parameter into the io.
     std::cout << prefix << "set" << strippedType << "(\"" << d.name
               << "\", " << goParamName << ")" << std::endl;

     // Print function call to set the given parameter as passed.
     std::cout << prefix << "setPassed(\"" << d.name << "\")" << std::endl;
   }
   std::cout << std::endl; // Extra line is to clear up the code a bit.
 }

 template<typename T>
 void PrintInputProcessing(util::ParamData& d,
                           const void* input,
                           void* /* output */)
 {
   PrintInputProcessing::type>(d,
       *((size_t*) input));
 }

 } // namespace go
 } // namespace bindings
 } // namespace mlpack

 #endif
mlpack::util::ParamData::value
boost::any value
The actual value that is held.
Definition: param_data.hpp:82

mlpack::data::HasSerialize
Definition: has_serialize.hpp:45

mlpack::bindings::go::StripType
void StripType(const std::string &inputType, std::string &goStrippedType, std::string &strippedType, std::string &printedType, std::string &defaultsType)
Given an input type like, e.g., "LogisticRegression<>", return four types that can be used in Go code...
Definition: strip_type.hpp:30

mlpack
Linear algebra utility functions, generally performed on matrices or vectors.
Definition: add_to_cli11.hpp:21

prereqs.hpp
The core includes that mlpack expects; standard C++ includes and Armadillo.

strip_type.hpp

go
go
Definition: CMakeLists.txt:6

mlpack::util::ParamData
This structure holds all of the information about a single parameter, including its value (which is s...
Definition: param_data.hpp:52

mlpack::util::CamelCase
std::string CamelCase(std::string s, bool lower)
Given an snake_case like, e.g., "logistic_regression", return CamelCase(e.g.
Definition: camel_case.hpp:26

mlpack::util::ParamData::name
std::string name
Name of this parameter.
Definition: param_data.hpp:56

mlpack::util::ParamData::required
bool required
True if this option is required.
Definition: param_data.hpp:71

get_go_type.hpp

get_type.hpp

mlpack::bindings::go::PrintInputProcessing
void PrintInputProcessing(util::ParamData &d, const size_t indent, 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)
Print input processing for a standard option type.
Definition: print_input_processing.hpp:29

mlpack::util::ParamData::cppType
std::string cppType
The true name of the type, as it would be written in C++.
Definition: param_data.hpp:84

if
if(NOT BUILD_GO_SHLIB) macro(add_go_binding name) endmacro() return() endif() endmacro() macro(post_go_setup) if(BUILD_GO_BINDINGS) file(APPEND "$
Definition: CMakeLists.txt:3

camel_case.hpp