Elements 6.1.2
A C++ base framework for the Euclid Software.
Loading...
Searching...
No Matches
ExtProgram.cpp
Go to the documentation of this file.
1
21#include <cstdint> // for int64_t
22#include <map> // for map
23#include <memory> // for unique_ptr
24#include <string> // for string
25#include <utility> // for move
26#include <vector> // for vector
27
29#include <boost/current_function.hpp> // for BOOST_CURRENT_FUNCTION
30#include <boost/program_options.hpp> // for program options from configuration file of command line arguments
31
32#include "ElementsKernel/Module.h" // for Module
33#include "ElementsKernel/ProgramHeaders.h" // for including all Program/related headers
34#include "ElementsKernel/Project.h" // for Project
35#include "ElementsKernel/ThisModule.h" // for getThisExecutableInfo
36
39
40using std::map;
41using std::string;
42using std::vector;
43
44using boost::program_options::bool_switch;
45using boost::program_options::value;
46
47using std::int64_t;
48
58
59public:
70
71 OptionsDescription config_options{"Example program options"};
72 auto add = config_options.add_options();
73
74 bool flag = false;
75
76 // Add the specific program options
77 add("int-option", value<int>()->default_value(int{111}), "An example int option");
78 add("int-option-with-default-and-default-in-conf", value<int>()->default_value(int{222}), "An example int option");
79 add("int-option-with-default-no-default-in-conf", value<int>()->default_value(int{444}), "An example int option");
80 add("int-option-no-default-not-defined-in-conf", value<int>(), "An example int option");
81 add("int-option-with-no-defaults-anywhere", value<int>(), "An example int option");
82 add("string-option", value<string>()->default_value(string{}), "An example string option");
83 add("boolean-option", value<bool>()->default_value(false), "An example boolean option");
84 add("flag,f", bool_switch(&flag), "An option to set to true");
85 add("string-option-no-default", value<string>(), "A string option without default value");
86 add("long-long-option", value<int64_t>()->default_value(int64_t{}), "An example long long option");
87 add("double-option", value<double>()->default_value(double{}), "An example double option");
88 add("int-vector-option", value<vector<int>>()->multitoken()->default_value(vector<int>{}, "Empty"),
89 "An example vector option");
90 add("threshold,t", value<double>()->default_value(double{0.5}), "An example double option");
91
92 return config_options;
93 }
94
107
109
110 auto log = Logging::getLogger("ExtProgram");
111 log.info("Entering mainMethod()");
112 log.info("#");
113 /*
114 * Check availability of mandatory program arguments (or options)
115 *
116 * Arguments values may come from
117 * 1) the default value provided in above defineSpecificProgramOptions()
118 * 2) the configuration file
119 * 3) the command line
120 *
121 * If an none of the three options provide any values for a mandatory
122 * argument, you should check if your option has any values following the
123 * below example. Note that this may happen for all options without default
124 * values.
125 */
126 if (args["string-option-no-default"].empty()) {
127 log.info() << "No value are available for string-option-no-default";
128 /*
129 * An exception may be thrown her if the above option is mandatory and there
130 * is no way to continue without value
131 */
132 }
133 /*
134 * Get and log one of the program arguments (or options)
135 *
136 * The string-option has a default empty string value, so that it can always be
137 * printed event as an empty string
138 */
139 string string_example{args["string-option"].as<string>()};
140 log.info() << "String option value: " << string_example;
141
142 log.info() << "The int-option value is " << args["int-option"].as<int>();
143 log.info() << "The threshold value is " << args["threshold"].as<double>();
144
145 // Some initialization
146 double input_variable = 3.4756;
147 int64_t source_id = 12345;
148 double ra = 45.637;
149
150 // Factory method example
151 ClassExample example_class_object = ClassExample::factoryMethod(source_id, ra);
152
153 /*
154 * All fundamental type variables can be copied forth and back without significant
155 * cost in (almost) all cases
156 */
157 double method_result = example_class_object.fundamentalTypeMethod(input_variable);
158 log.info() << "Some result: " << method_result;
159
160 double first = 1.0;
161 double division_result{};
162 try {
163 log.info("#");
164 log.info("# Calling a method throwing an exception ");
165 log.info("#");
166 double second = 0.0;
167 division_result = example_class_object.divideNumbers(first, second);
168 //
169 } catch (const Elements::Exception& e) {
170 log.info("#");
171 log.info() << e.what();
172 log.info("#");
173 log.info("# In this silly example we continue with a fake fix ");
174 log.info("#");
175 division_result = example_class_object.divideNumbers(first, 0.000001);
176 }
177 log.info() << "Second result is: " << division_result;
178
179 /*
180 * Illustration on how best to use smart pointer (regular pointer should not
181 * be used anymore). The move() indicate that the ownership of the pointer is given to the
182 * method called. The vector_unique_ptr cannot be used in this method anymore after the
183 * call.
184 */
185 std::unique_ptr<vector<double>> vector_unique_ptr{new vector<double>{1.0, 2.3, 4.5}};
186 example_class_object.passingUniquePointer(std::move(vector_unique_ptr));
187
188 /*
189 * Illustration on how best to pass any object. The passingObjectInGeneral() is taking
190 * a reference to this object.
191 */
192 vector<double> object_example{vector<double>{1.0, 2.3, 4.5}};
193 example_class_object.passingObjectInGeneral(object_example);
194
195 log.info() << "Function Example: " << Elements::Examples::functionExample(3);
196
197 log.info() << "This executable name: " << Elements::System::getThisExecutableInfo().name();
198
200
201 log.info() << Elements::Project();
202 log.info() << "Project Name: " << Elements::Project::name();
203 log.info() << "Project Version: " << Elements::Project::versionString();
204 log.info() << "Module Name: " << Elements::Module::name();
205 log.info() << "Module Version: " << Elements::Module::versionString();
206
207 log.info("#");
208 log.info("Exiting mainMethod()");
209 return ExitCode::OK;
210 }
211};
212
Defines tools to describe the current Elmeents module.
Defines tools to describe the current project.
header to get the module info statically
Elements base exception class.
Definition: Exception.h:47
static Logging getLogger(const std::string &name="")
Definition: Logging.cpp:63
Abstract class for all Elements programs.
Definition: Program.h:52
options_description OptionsDescription
Definition: Program.h:62
const std::string name() const
Definition: ModuleInfo.cpp:72
Simple example of an Elements program outside of the Elements namespace.
Definition: ExtProgram.cpp:57
OptionsDescription defineSpecificProgramOptions() override
Allows to define the (command line and configuration file) options specific to this program.
Definition: ExtProgram.cpp:69
ExitCode mainMethod(map< string, VariableValue > &args) override
The "main" method.
Definition: ExtProgram.cpp:106
ExitCode
Strongly typed exit numbers.
Definition: Exit.h:97
#define MAIN_FOR(ELEMENTS_PROGRAM_NAME)
Definition: Main.h:113
T move(T... args)
ELEMENTS_API void printProject()
ELEMENTS_API int functionExample(const int j)
ELEMENTS_API const ModuleInfo & getThisExecutableInfo()
Definition: ThisModule.cpp:33
static std::string name()
Definition: Module.h:42
static std::string versionString()
Definition: Module.h:45
static std::string versionString()
Definition: Project.h:46
static std::string name()
Definition: Project.h:42