mlpack 3.4.2
py_option.hpp
Go to the documentation of this file.
1
12#ifndef MLPACK_BINDINGS_PYTHON_PY_OPTION_HPP
13#define MLPACK_BINDINGS_PYTHON_PY_OPTION_HPP
14
16#include "default_param.hpp"
17#include "get_param.hpp"
19#include "print_class_defn.hpp"
20#include "print_defn.hpp"
21#include "print_doc.hpp"
24#include "import_decl.hpp"
25
26namespace mlpack {
27namespace bindings {
28namespace python {
29
30// Defined in mlpack_main.hpp.
31extern std::string programName;
32
36template<typename T>
38{
39 public:
45 PyOption(const T defaultValue,
46 const std::string& identifier,
47 const std::string& description,
48 const std::string& alias,
49 const std::string& cppName,
50 const bool required = false,
51 const bool input = true,
52 const bool noTranspose = false,
53 const std::string& /*testName*/ = "")
54 {
55 // Create the ParamData object to give to IO.
56 util::ParamData data;
57
58 data.desc = description;
59 data.name = identifier;
60 data.tname = TYPENAME(T);
61 data.alias = alias[0];
62 data.wasPassed = false;
63 data.noTranspose = noTranspose;
64 data.required = required;
65 data.input = input;
66 data.loaded = false;
67 // Only "verbose" and "copy_all_inputs" will be persistent.
68 if (identifier == "verbose" || identifier == "copy_all_inputs")
69 data.persistent = true;
70 else
71 data.persistent = false;
72 data.cppType = cppName;
73
74 // Every parameter we'll get from Python will have the correct type.
75 data.value = boost::any(defaultValue);
76
77 // Restore the parameters for this program.
78 if (identifier != "verbose" && identifier != "copy_all_inputs")
80
81 // Set the function pointers that we'll need. All of these function
82 // pointers will be used by both the program that generates the pyx, and
83 // also the binding itself. (The binding itself will only use GetParam,
84 // GetPrintableParam, and GetRawParam.)
85 IO::GetSingleton().functionMap[data.tname]["GetParam"] = &GetParam<T>;
86 IO::GetSingleton().functionMap[data.tname]["GetPrintableParam"] =
87 &GetPrintableParam<T>;
88
89 IO::GetSingleton().functionMap[data.tname]["DefaultParam"] =
90 &DefaultParam<T>;
91
92 // These are used by the pyx generator.
93 IO::GetSingleton().functionMap[data.tname]["PrintClassDefn"] =
94 &PrintClassDefn<T>;
95 IO::GetSingleton().functionMap[data.tname]["PrintDefn"] = &PrintDefn<T>;
96 IO::GetSingleton().functionMap[data.tname]["PrintDoc"] = &PrintDoc<T>;
97 IO::GetSingleton().functionMap[data.tname]["PrintOutputProcessing"] =
98 &PrintOutputProcessing<T>;
99 IO::GetSingleton().functionMap[data.tname]["PrintInputProcessing"] =
100 &PrintInputProcessing<T>;
101 IO::GetSingleton().functionMap[data.tname]["ImportDecl"] = &ImportDecl<T>;
102
103 // Add the ParamData object, then store. This is necessary because we may
104 // import more than one .so that uses IO, so we have to keep the options
105 // separate. programName is a global variable from mlpack_main.hpp.
106 IO::Add(std::move(data));
107 if (identifier != "verbose" && identifier != "copy_all_inputs")
110 }
111};
112
113} // namespace python
114} // namespace bindings
115} // namespace mlpack
116
117#endif
FunctionMapType functionMap
Definition: io.hpp:299
static IO & GetSingleton()
Retrieve the singleton.
static void ClearSettings()
Clear all of the settings, removing all parameters and function mappings.
static void RestoreSettings(const std::string &name, const bool fatal=true)
Restore all of the parameters and function mappings of the given name, if they exist.
static void StoreSettings(const std::string &name)
Take all parameters and function mappings and store them, under the given name.
static void Add(util::ParamData &&d)
Adds a parameter to the hierarchy; use the PARAM_*() macros instead of this (i.e.
The Python option class.
Definition: py_option.hpp:38
PyOption(const T defaultValue, const std::string &identifier, const std::string &description, const std::string &alias, const std::string &cppName, const bool required=false, const bool input=true, const bool noTranspose=false, const std::string &="")
Construct a PyOption object.
Definition: py_option.hpp:45
python
Definition: CMakeLists.txt:6
Linear algebra utility functions, generally performed on matrices or vectors.
Definition: cv.hpp:1
#define TYPENAME(x)
The TYPENAME macro is used internally to convert a type into a string.
Definition: param_data.hpp:22
This structure holds all of the information about a single parameter, including its value (which is s...
Definition: param_data.hpp:53
bool noTranspose
True if this is a matrix that should not be transposed.
Definition: param_data.hpp:69
char alias
Alias for this parameter.
Definition: param_data.hpp:63
std::string desc
Description of this parameter, if any.
Definition: param_data.hpp:58
bool wasPassed
True if the option was passed to the program.
Definition: param_data.hpp:66
boost::any value
The actual value that is held.
Definition: param_data.hpp:82
std::string tname
Type information of this parameter.
Definition: param_data.hpp:61
bool required
True if this option is required.
Definition: param_data.hpp:71
bool input
True if this option is an input option (otherwise, it is output).
Definition: param_data.hpp:73
bool loaded
If this is an input parameter that needs extra loading, this indicates whether or not it has been loa...
Definition: param_data.hpp:76
std::string name
Name of this parameter.
Definition: param_data.hpp:56
std::string cppType
The true name of the type, as it would be written in C++.
Definition: param_data.hpp:84
bool persistent
If this should be preserved across different settings (i.e.
Definition: param_data.hpp:79