FMT 0.9.8
Forest management tools for forest planning
Loading...
Searching...
No Matches
RexportCore.hpp
Go to the documentation of this file.
1/*
2Copyright (c) 2019 Gouvernement du Québec
3
4SPDX-License-Identifier: LiLiQ-R-1.1
5License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt
6*/
7
8#ifndef REXPORTCORE_H_INCLUDED
9#define REXPORTCORE_H_INCLUDED
10
11#include "FMTGCBMtransition.hpp"
12#include "FMTobject.hpp"
13#include "FMTmask.hpp"
14#include "FMTtheme.hpp"
15#include "FMTbounds.hpp"
16#include "FMTdevelopment.hpp"
17#include "FMTactualdevelopment.hpp"
18#include "FMTfuturdevelopment.hpp"
19#include "FMTaction.hpp"
20#include "FMTtransition.hpp"
21#include "FMToutput.hpp"
22#include "FMTconstraint.hpp"
23#include "FMTschedule.hpp"
24#include "FMTyields.hpp"
25#include "FMTconstants.hpp"
26#include "Rdefinitions.hpp"
27#include "FMTyieldhandler.hpp"
28#include "FMTtimeyieldhandler.hpp"
29#include "FMTageyieldhandler.hpp"
30#include "FMTdevelopmentpath.hpp"
31#include "FMTdata.hpp"
32#include "FMTmaskfilter.hpp"
33#include "FMTtransitionmask.hpp"
34
35#include <vector>
36#include <Rcpp.h>
37
38RCPP_EXPOSED_WRAP(Core::FMTobject);
39RCPP_EXPOSED_AS(Core::FMTobject);
40RCPP_EXPOSED_WRAP(Core::FMTmask);
41RCPP_EXPOSED_AS(Core::FMTmask);
42RCPP_DEFINEVECTOR(Core::FMTmask);//For vector
43RCPP_EXPOSED_WRAP(Core::FMTdevelopment);
44RCPP_EXPOSED_AS(Core::FMTdevelopment);
45RCPP_EXPOSED_WRAP(Core::FMTdevelopmentpath);
46RCPP_EXPOSED_AS(Core::FMTdevelopmentpath);
47RCPP_DEFINEVECTOR(Core::FMTdevelopmentpath);//For vector
48RCPP_DEFINEVECTOR(Core::FMTdevelopment);//For vector
49RCPP_EXPOSED_WRAP(Core::FMTspec);
50RCPP_EXPOSED_AS(Core::FMTspec);
51RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTspec);//pair for FMTlist
52RCPP_DEFINEVECTOR(Core::FMTspec);//For vector
53RCPP_EXPOSED_WRAP(Core::FMTperbounds);
54RCPP_EXPOSED_AS(Core::FMTperbounds);
55RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTperbounds);//pair for FMTlist
56RCPP_DEFINEVECTOR(Core::FMTperbounds);//For vector
57RCPP_EXPOSED_WRAP(Core::FMTagebounds);
58RCPP_EXPOSED_AS(Core::FMTagebounds);
59RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTagebounds);//pair for FMTlist
60RCPP_DEFINEVECTOR(Core::FMTagebounds);//For vector
61RCPP_EXPOSED_WRAP(Core::FMTyldbounds);
62RCPP_EXPOSED_AS(Core::FMTyldbounds);
63RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTyldbounds);//pair for FMTlist
64RCPP_DEFINEVECTOR(Core::FMTyldbounds);//For vector
65RCPP_EXPOSED_WRAP(Core::FMTlockbounds);
66RCPP_EXPOSED_AS(Core::FMTlockbounds);
67RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTlockbounds);//pair for FMTlist
68RCPP_DEFINEVECTOR(Core::FMTlockbounds);//For vector
69RCPP_EXPOSED_WRAP(Core::FMToutputsource);
70RCPP_EXPOSED_AS(Core::FMToutputsource);
71RCPP_DEFINEPAIR(Core::FMTmask, Core::FMToutputsource);//pair for FMTlist
72RCPP_DEFINEVECTOR(Core::FMToutputsource);//For vector
73RCPP_EXPOSED_WRAP(Core::FMToperator);
74RCPP_EXPOSED_AS(Core::FMToperator);
75RCPP_DEFINEPAIR(Core::FMTmask, Core::FMToperator);//pair for FMTlist
76RCPP_DEFINEVECTOR(Core::FMToperator);//For vector
77RCPP_EXPOSED_WRAP(Core::FMTtransitionmask);
78RCPP_EXPOSED_AS(Core::FMTtransitionmask);
79RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTtransitionmask);//pair for FMTlist
80RCPP_DEFINEVECTOR(Core::FMTtransitionmask);//For vector
81
82
83
84RCPP_EXPOSED_WRAP(Core::FMTmaskfilter);
85RCPP_EXPOSED_AS(Core::FMTmaskfilter);
86RCPP_DEFINEVECTOR(Core::FMTmaskfilter);//For vector
87RCPP_EXPOSED_WRAP(Core::FMTactualdevelopment);
88RCPP_EXPOSED_AS(Core::FMTactualdevelopment);
89RCPP_DEFINEVECTOR(Core::FMTactualdevelopment);//For vector
90RCPP_EXPOSED_WRAP(Core::FMTfuturdevelopment);
91RCPP_EXPOSED_AS(Core::FMTfuturdevelopment);
92RCPP_DEFINEVECTOR(Core::FMTfuturdevelopment);//For vector
93RCPP_EXPOSED_WRAP(Core::FMTaction);
94RCPP_EXPOSED_AS(Core::FMTaction);
95RCPP_DEFINEVECTOR(Core::FMTaction);//For vector
96RCPP_EXPOSED_WRAP(Core::FMTlifespans);
97RCPP_EXPOSED_AS(Core::FMTlifespans);
98RCPP_DEFINEPAIR(Core::FMTmask, int);//pair for FMTlist
99RCPP_EXPOSED_ENUM_NODECL(Core::FMTyldtype);
100RCPP_EXPOSED_WRAP(Core::FMTyieldhandler);
101RCPP_EXPOSED_AS(Core::FMTyieldhandler);
102RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTyieldhandler);//pair for FMTlist
103RCPP_DEFINEVECTOR(Core::FMTyieldhandler);//For vector
104RCPP_EXPOSED_WRAP(Core::FMTtimeyieldhandler);
105RCPP_EXPOSED_AS(Core::FMTtimeyieldhandler);
106RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTtimeyieldhandler);//pair for FMTlist
107RCPP_DEFINEVECTOR(Core::FMTtimeyieldhandler);//For vector
108RCPP_EXPOSED_WRAP(Core::FMTageyieldhandler);
109RCPP_EXPOSED_AS(Core::FMTageyieldhandler);
110RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTageyieldhandler);//pair for FMTlist
111RCPP_DEFINEVECTOR(Core::FMTageyieldhandler);//For vector
112RCPP_EXPOSED_WRAP(Core::FMTyields);
113RCPP_EXPOSED_AS(Core::FMTyields);
114RCPP_EXPOSED_WRAP(Core::FMTfork);
115RCPP_EXPOSED_AS(Core::FMTfork);
116RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTfork);//pair for FMTlist
117RCPP_DEFINEVECTOR(Core::FMTfork);//For vector
118RCPP_EXPOSED_WRAP(Core::FMTtransition);
119RCPP_EXPOSED_AS(Core::FMTtransition);
120RCPP_DEFINEVECTOR(Core::FMTtransition);//For vector
121RCPP_EXPOSED_WRAP(Core::FMToutputnode);
122RCPP_EXPOSED_AS(Core::FMToutputnode);
123RCPP_DEFINEVECTOR(Core::FMToutputnode);//For vector
124RCPP_EXPOSED_WRAP(Core::FMToutput);
125RCPP_EXPOSED_AS(Core::FMToutput);
126RCPP_DEFINEVECTOR(Core::FMToutput);//For vector
127RCPP_EXPOSED_WRAP(Core::FMTtheme);
128RCPP_EXPOSED_AS(Core::FMTtheme);
129RCPP_DEFINEVECTOR(Core::FMTtheme);//For vector
130RCPP_EXPOSED_WRAP(Core::FMTconstants);
131RCPP_EXPOSED_AS(Core::FMTconstants);
132RCPP_EXPOSED_WRAP(Core::FMTschedule);
133RCPP_EXPOSED_AS(Core::FMTschedule);
134RCPP_DEFINEVECTOR(Core::FMTschedule);//For vector
135RCPP_DEFINELIST(std::vector<Core::FMTschedule>)//For vector of vector
136RCPP_EXPOSED_WRAP(Core::FMTGCBMtransition);
137RCPP_EXPOSED_AS(Core::FMTGCBMtransition);
138RCPP_DEFINEVECTOR(Core::FMTGCBMtransition);//For vector
139RCPP_EXPOSED_WRAP(Core::FMTconstraint);
140RCPP_EXPOSED_AS(Core::FMTconstraint);
141RCPP_DEFINEVECTOR(Core::FMTconstraint);//For vector
142RCPP_DEFINEMAP(Core::FMTdevelopment, std::vector<double>);//For dev of doubles
143RCPP_DEFINEMAP(std::string, std::vector<double>);//For string of double map
144RCPP_DEFINEMAP(std::string, std::vector<Core::FMTdevelopment>);//For string of vector of developements
145RCPP_DEFINEMAP(Core::FMTaction , std::map<Core::FMTdevelopment RCPP_COMMA std::vector<double>>);//For action of ...
146RCPP_DEFINEMAP(std::string , std::map<std::string RCPP_COMMA std::vector<double>>);//For string of ...
147RCPP_DEFINEMAP(std::string, std::string);//map of string definition
148RCPP_EXPOSED_ENUM_NODECL(Core::FMTconstrainttype);
149RCPP_EXPOSED_ENUM_NODECL(Core::FMTotar);
150//RCPP_EXPOSED_ENUM_NODECL(Core::FMTsection);
151
152namespace R
153{
154
155void exportCore()
156 {
157 define_FMTlist<Core::FMTspec>("FMTspeclist");
158 define_FMTlist<int>("FMTintlist");
159 //define_FMTlist<Core::FMTyieldhandler>("FMTyieldhandlerlist");
160 define_FMTlist<Core::FMTfork>("FMTforklist");
161
162 Rcpp::class_<Core::FMTobject>("FMTobject", "@DocString(FMTobject)")
163 .constructor("@DocString(FMTobject())")
164 .method("setdefaultexceptionhandler", &Core::FMTobject::setdefaultexceptionhandler,
165 "@DocString(FMTobject::setdefaultexceptionhandler)")
166 .method("setquietexceptionhandler", &Core::FMTobject::setquietexceptionhandler,
167 "@DocString(FMTobject::setquietexceptionhandler)")
168 .method("setdebugexceptionhandler", &Core::FMTobject::setdebugexceptionhandler,
169 "@DocString(FMTobject::setdebugexceptionhandler)")
170 .method("setfreeexceptionhandler", &Core::FMTobject::setfreeexceptionhandler,
171 "@DocString(FMTobject::setfreeexceptionhandler)")
172 .method("disablenestedexceptions", &Core::FMTobject::disablenestedexceptions,
173 "@DocString(FMTobject::disablenestedexceptions)")
174 .method("enablenestedexceptions", &Core::FMTobject::enablenestedexceptions,
175 "@DocString(FMTobject::enablenestedexceptions)")
176 .method("setquietlogger", &Core::FMTobject::setquietlogger,
177 "@DocString(FMTobject::setquietlogger")
178 .method("settasklogger", &Core::FMTobject::settasklogger,
179 "@DocString(FMTobject::settasklogger")
180 .method("setdefaultlogger", &Core::FMTobject::setdefaultlogger,
181 "@DocString(FMTobject::setdefaultlogger")
182 .method("setdebuglogger", &Core::FMTobject::setdebuglogger,
183 "@DocString(FMTobject::setdebuglogger")
184 .method("redirectlogtofile", &Core::FMTobject::redirectlogtofile,
185 "@DocString(FMTobject::redirectlogtofile)")
186 .method("seterrorstowarnings", &Core::FMTobject::seterrorstowarnings,
187 "@DocString(FMTobject::seterrorstowarnings)");
188
189 Rcpp::class_<Core::FMTmask>("FMTmask", "@DocString(FMTmask)")
190 .constructor("@DocString(FMTmask())")
191 .constructor<std::vector<std::string>,std::vector<Core::FMTtheme>>(
192 "@DocString(FMTmask(const std::vector<std::string>&,const std::vector<Core::FMTtheme>&))")
193 .constructor<std::string, std::vector<Core::FMTtheme>>(
194 "@DocString(FMTmask(const std::string&,const std::vector<Core::FMTtheme>&))")
195 .method("len", &Core::FMTmask::operator bool,
196 "@DocString(FMTmask::operator bool)")
197 .method("str",&Core::FMTmask::operator std::string,
198 "@DocString(FMTmask::operator std::string)")
199 .method("eq", &Core::FMTmask::operator ==,
200 "@DocString(FMTmask::operator==)")
201 .method("ne", &Core::FMTmask::operator !=,
202 "@DocString(FMTmask::operator!=)")
203 .method("lt", &Core::FMTmask::operator <,
204 "@DocString(FMTmask::operator<)");
205
206 Rcpp::class_<Core::FMTmaskfilter>("FMTmaskfilter", "@DocString(FMTmaskfilter)")
207 .constructor("@DocString(FMTmaskfilter())");
208
209
210
211 Rcpp::class_<Core::FMTmaskfilter>("FMTmaskfilter", "@DocString(FMTmaskfilter)")
212 .constructor("@DocString(FMTmaskfilter())");
213
214
215 Rcpp::class_<Core::FMTdevelopment>("FMTdevelopment", "@DocString(FMTdevelopment)")
216 .constructor("@DocString(FMTdevelopment())")
217 .method("getage", &Core::FMTdevelopment::getage,
218 "@DocString(FMTdevelopment::getage)")
219 .method("getlock", &Core::FMTdevelopment::getlock,
220 "@DocString(FMTdevelopment::getlock)")
221 .method("getperiod", &Core::FMTdevelopment::getperiod,
222 "@DocString(FMTdevelopment::getperiod)")
223 .method("getmask", &Core::FMTdevelopment::getmaskcopy,
224 "@DocString(FMTdevelopment::getmask)")
225 .method("setage", &Core::FMTdevelopment::setage,
226 "@DocString(FMTdevelopment::setage)")
227 .method("setlock", &Core::FMTdevelopment::setlock,
228 "@DocString(FMTdevelopment::setlock)")
229 .method("setperiod", &Core::FMTdevelopment::setperiod,
230 "@DocString(FMTdevelopment::setperiod)")
231 .method("setmask", &Core::FMTdevelopment::setmask,
232 "@DocString(FMTdevelopment::setmask)")
233 .method("eq", &Core::FMTdevelopment::operator ==,
234 "@DocString(FMTdevelopment::operator==)")
235 .method("ne", &Core::FMTdevelopment::operator !=,
236 "@DocString(FMTdevelopment::operator!=)")
237 .method("lt",&Core::FMTdevelopment::operator <,
238 "@DocString(FMTdevelopment::operator<)")
239 .method("grow",&Core::FMTdevelopment::grow,
240 "@DocString(FMTdevelopment::grow)")
241 //.method("operable",&Core::FMTdevelopment::operable,
242 // "@DocString(FMTdevelopment::operable)")
243 //.method("operate",&Core::FMTdevelopment::operate,
244 // "@DocString(FMTdevelopment::operate)")
245 .method("str", &Core::FMTdevelopment::operator std::string,
246 "@DocString(FMTdevelopment::operate std::string)");
247
248
249 Rcpp::class_<Core::FMTagebounds>("FMTagebounds", "@DocString(FMTagebounds)")
250 .constructor("@DocString(FMTagebounds())")
251 .constructor<Core::FMTsection,int,int>("@DocString(FMTagebounds(FMTsection,const int&,const int&))");
252
253 Rcpp::class_<Core::FMTperbounds>("FMTperbounds", "@DocString(FMTperbounds)")
254 .constructor("@DocString(FMTperbounds())")
255 .constructor<Core::FMTsection, int, int>("@DocString(FMTperbounds(FMTsection,const int&,const int&))");
256
257 Rcpp::class_<Core::FMTyldbounds>("FMTyldbounds", "@DocString(FMTyldbounds)")
258 .constructor("@DocString(FMTyldbounds())")
259 .constructor<Core::FMTsection,std::string,double,double>("@DocString(FMTperiodbounds(FMTsection,const std::string&,const double&,const double&))");
260
261 Rcpp::class_<Core::FMTlockbounds>("FMTlockbounds", "@DocString(FMTlockbounds)")
262 .constructor("@DocString(FMTlockbounds())")
263 .constructor<Core::FMTsection, int, int>("@DocString(FMTlockbounds(FMTsection,const int&,const int&))");
264
265
266
267
268 Rcpp::class_<Core::FMTspec>("FMTspec", "@DocString(FMTspec)")
269 .constructor("@DocString(FMTspec())")
270 .method("setbounds",&Core::FMTspec::setbounds,"@DocString(Core::FMTspec::setbounds())")
271 .method("addbounds",
272 static_cast<bool(Core::FMTspec::*)(const Core::FMTagebounds&)>(&Core::FMTspec::addbounds),
273 "@DocString(Core::FMTspec::addbounds(const FMTagebounds&))")
274 .method("addbounds",
275 static_cast<bool(Core::FMTspec::*)(const Core::FMTyldbounds&)>(&Core::FMTspec::addbounds),
276 "@DocString(Core::FMTspec::addbounds(const FMTyldbounds&))")
277 .method("addbounds",
278 static_cast<bool(Core::FMTspec::*)(const Core::FMTlockbounds&)>(&Core::FMTspec::addbounds),
279 "@DocString(Core::FMTspec::addbounds(const FMTlockbounds&))");
280
281
282 Rcpp::class_<Core::FMTactualdevelopment>("FMTactualdevelopment", "@DocString(FMTactualdevelopment)")
283 .derives<Core::FMTdevelopment>("FMTdevelopment")
284 .constructor("@DocString(FMTactualdevelopment())")
285 .constructor<Core::FMTmask,int,int,double>("@DocString(FMTactualdevelopment(const FMTmask&,const int&,const int&,const int&,const double&))")
286 .method("getarea", &Core::FMTactualdevelopment::getarea,
287 "@DocString(FMTactualdevelopment::getarea)")
288 .method("setarea", &Core::FMTactualdevelopment::setarea,
289 "@DocString(FMTactualdevelopment::setarea)")
290 .method("eq", &Core::FMTactualdevelopment::operator ==,
291 "@DocString(FMTactualdevelopment::operator==)")
292 .method("ne", &Core::FMTactualdevelopment::operator !=,
293 "@DocString(FMTactualdevelopment::operator!=)")
294 .method("lt", &Core::FMTactualdevelopment::operator <,
295 "@DocString(FMTactualdevelopment::operator<)");
296
297 Rcpp::class_<Core::FMTfuturdevelopment>("FMTfuturdevelopment", "@DocString(FMTfuturdevelopment)")
298 .derives<Core::FMTdevelopment>("FMTdevelopment")
299 .constructor("@DocString(FMTfuturdevelopment())");
300
301
302 Rcpp::class_<Core::FMTaction>("FMTaction","@DocString(FMTaction)")
303 .constructor("@DocString(FMTaction())")
304 .constructor<std::string,bool,bool>("@DocString(FMTaction(const std::string&,const bool&,const bool&))")
305 .derives<Core::FMTlist<Core::FMTspec>>("FMTspeclist")
306 .method("__eq__",&Core::FMTaction::operator ==,
307 "@DocString(FMTaction::operator==)")
308 .method("__ne__",&Core::FMTaction::operator !=,
309 "@DocString(FMTaction::operator!=)")
310 .method("__lt__",&Core::FMTaction::operator <,
311 "@DocString(FMTaction::operator<)")
312 .method("__str__", &Core::FMTaction::operator std::string,
313 "@DocString(FMTaction::operator std::string)")
314 .method("getname",&Core::FMTaction::getname,
315 "@DocString(FMTaction::getname)")
316 .method("dorespectlock",&Core::FMTaction::dorespectlock,
317 "@DocString(FMTaction::dorespectlock)")
318 .method("isresetage",&Core::FMTaction::isresetage,
319 "@DocString(FMTaction::isresetage)");
320
321
322
323 Rcpp::class_<Core::FMTlifespans>("FMTlifespans", "@DocString(FMTlifespans)")
324 .derives<Core::FMTlist<int>>("FMTintlist")
325 .constructor("@DocString(FMTlifespans())");
326
327
328
329 Rcpp::class_<Core::FMTtransitionmask>("FMTtransitionmask", "@DocString(FMTtransitionmask)")
330 .constructor<std::string,std::vector<Core::FMTtheme>,double>("@DocString(FMTtransitionmask(const std::string&,const std::vector<FMTtheme>&,const double&))")
331 .constructor("@DocString(FMTtransitionmask())");
332
333 Rcpp::class_<Core::FMTfork>("FMTfork", "@DocString(FMTfork)")
334 .derives<Core::FMTlist<Core::FMTspec>>("FMTspeclist")
335 .method("add", &Core::FMTfork::add,
336 "@DocString(FMTfork::add)")
337 .constructor("@DocString(FMTfork())");
338
339 Rcpp::class_<Core::FMTyieldhandler>("FMTyieldhandler", "@DocString(FMTyieldhandler)")
340 .constructor("@DocString(FMTyieldhandler())")
341 .method("push_data",
342 static_cast<bool (Core::FMTyieldhandler::*)(const std::string&,const double&)>(&Core::FMTyieldhandler::push_data),
343 "@DocString(FMTyieldhandler::push_data(const std::string&,const double&))")
344 .method("push_base", &Core::FMTyieldhandler::push_base,
345 "@DocString(FMTyieldhandler::push_base)");
346
347 Rcpp::class_<Core::FMTageyieldhandler>("FMTageyieldhandler", "@DocString(FMTageyieldhandler)")
348 .derives<Core::FMTyieldhandler>("FMTyieldhandler")
349 .constructor("@DocString(FMTageyieldhandler())")
350 .constructor<Core::FMTmask>("@DocString(FMTageyieldhandler(const FMTmask&))")
351 .method("str", &Core::FMTageyieldhandler::operator std::string,
352 "@DocString(FMTageyieldhandler::operator std::string)");
353
354 Rcpp::class_<Core::FMTtimeyieldhandler>("FMTtimeyieldhandler", "@DocString(FMTtimeyieldhandler)")
355 .derives<Core::FMTyieldhandler>("FMTyieldhandler")
356 .constructor("@DocString(FMTtimeyieldhandler())")
357 .constructor<Core::FMTmask>("@DocString(FMTtimeyieldhandler(const FMTmask&))")
358 .method("str", &Core::FMTtimeyieldhandler::operator std::string,
359 "@DocString(FMTtimeyieldhandler::operator std::string)");
360
361
362
363
364 Rcpp::class_<Core::FMTyields>("FMTyields", "@DocString(FMTyields)")
365 //.derives<Core::FMTlist<Core::FMTyieldhandler>>("FMTyieldhandlerlist")
366 .constructor("@DocString(FMTyields())")
367 .method("getallyields", &Core::FMTyields::getallyields,
368 "@DocString(FMTyields::getallyields)")
369 .method("getfromfactor", &Core::FMTyields::getfromfactor,
370 "@DocString(FMTyields::getfromfactor)")
371 .method("update", &Core::FMTyields::update,
372 "@DocString(FMTyields::update)")
373 .method("push_back",Core::FMTyields::push_backagehandler,
374 "@DocString(Core::FMTyields::push_backagehandler")
375 .method("push_back", Core::FMTyields::push_backtimehandler,
376 "@DocString(Core::FMTyields::push_backtimehandler");
377
378
379
380
381 Rcpp::class_<Core::FMTtransition>("FMTtransition", "@DocString(FMTtransition)")
382 .derives<Core::FMTlist<Core::FMTfork>>("FMTforklist")
383 .constructor("@DocString(FMTtransition())")
384 .constructor<std::string>("@DocString(FMTtransition(const std::string&))")
385 .method("single",&Core::FMTtransition::single,
386 "@DocString(FMTtransition::single)")
387 .method("main_target", &Core::FMTtransition::main_target,
388 "@DocString(FMTtransition::main_target)")
389 .method("age_after", &Core::FMTtransition::age_after,
390 "@DocString(FMTtransition::age_after)")
391 .method("attribute_targets", &Core::FMTtransition::attribute_targets,
392 "@DocString(FMTtransition::attribute_targets)")
393 .method("str", &Core::FMTtransition::operator std::string,
394 "@DocString(FMTtransition::operator std::string)")
395 .method("eq",&Core::FMTtransition::operator ==,
396 "@DocString(FMTtransition::operator==)")
397 .method("ne",&Core::FMTtransition::operator !=,
398 "@DocString(FMTtransition::operator!=)")
399 .method("lt",&Core::FMTtransition::operator <,
400 "@DocString(FMTtransition::operator<)")
401 .method("getname",&Core::FMTtransition::getname,
402 "@DocString(FMTtransition::getname)");
403
404 Rcpp::class_<Core::FMToutputsource>("FMToutputsource", "@DocString(FMToutputsource)")
405 .constructor<Core::FMTspec, Core::FMTmask,
406 Core::FMTotar, std::string,
407 std::string, int, int>("@DocString(FMToutputsource())")
408 .constructor("@DocString(FMToutputsource())");
409
410 Rcpp::class_<Core::FMToperator>("FMToperator", "@DocString(FMToperator)")
411 .constructor("@DocString(FMToperator())");
412
413 Rcpp::class_<Core::FMToutputnode>("FMToutputnode", "@DocString(FMToutputnode)")
414 .constructor("@DocString(FMToutputnode())")
415 .method("str", &Core::FMToutputnode::operator std::string,
416 "@DocString(FMToutputnode::operator std::string)");
417
418
419 Rcpp::class_<Core::FMToutput>("FMToutput", "@DocString(FMToutput)")
420 .constructor("@DocString(FMToutput())")
421 .constructor<std::string,std::string,std::string,
422 std::vector<Core::FMToutputsource>,
423 std::vector<Core::FMToperator>>("@DocString(FMToutput(const std::string&,const std::string&,const int&,std::vector<FMToutputsource>&,std::vector<FMToperator>&))")
424 .method("getname",&Core::FMToutput::getname,
425 "@DocString(FMToutput::getname)")
426 .method("getdescription",&Core::FMToutput::getdescription,
427 "@DocString(FMToutput::getdescription)")
428 .method("empty", &Core::FMToutput::empty,
429 "@DocString(FMToutput::empty)")
430 .method("containslevel",&Core::FMToutput::containslevel,
431 "@DocString(FMToutput::containslevel)")
432 .method("islevel", &Core::FMToutput::islevel,
433 "@DocString(FMToutput::islevel)")
434 .method("isonlylevel", &Core::FMToutput::isonlylevel,
435 "@DocString(FMToutput::isonlylevel)")
436 //.method("getnodes",&Core::FMToutput::getnodes,
437 // "@DocString(FMToutput::getnodes)")
438 .method("str", &Core::FMToutput::operator std::string,
439 "@DocString(FMToutput::operator std::string)")
440 .method("eq",&Core::FMToutput::operator ==,
441 "@DocString(FMToutput::operator==)")
442 .method("ne",&Core::FMToutput::operator !=,
443 "@DocString(FMToutput::operator!=)");
444
445
446 Rcpp::class_<Core::FMTtheme>("FMTtheme", "@DocString(FMTtheme)")
447 .constructor("@DocString(FMTtheme())")
448 .constructor<std::vector<std::string>,
449 std::vector<std::string>,
450 std::vector<std::string>,
451 std::vector<std::vector<std::string>>,
452 size_t,size_t,std::string>(
453 "@DocString(const std::vector<std::string>&,const std::vector<std::string>&,const std::vector<std::vector<std::string>>,const std::vector<std::map<std::string, double>>&,const size_t&, const size_t&, const std::string&)")
454 .method("str", &Core::FMTtheme::operator std::string,
455 "@DocString(FMTtheme::operator std::string)")
456 .method("eq", &Core::FMTtheme::operator ==,
457 "@DocString(FMTtheme::operator==)")
458 .method("getattributes", &Core::FMTtheme::getattributes,
459 "@DocString(FMTtheme::getattributes)")
460 .method("getname", &Core::FMTtheme::getname,
461 "@DocString(FMTtheme::getname)")
462 .method("getaggregatesasdataframe", &Core::FMTtheme::getaggregatesasdataframe,
463 "@DocString(FMTtheme::getaggregatesasdataframee)")
464 .method("getattributesasdataframe", &Core::FMTtheme::getattributesasdataframe,
465 "@DocString(FMTtheme::getattributesasdataframe)");
466
467
468 Rcpp::class_<Core::FMTconstants>("FMTconstants", "@DocString(FMTconstants)")
469 .constructor("@DocString(FMTconstants())");
470
471 Rcpp::class_<Core::FMTschedule>("FMTschedule", "@DocString(FMTschedule)")
472 .constructor("@DocString(FMTschedule())")
473 .constructor<int, std::map<Core::FMTaction, std::map<Core::FMTdevelopment, std::vector<double>>>>(
474 "@DocString(FMTschedule(int,std::map<Core::FMTaction,std::map<Core::FMTdevelopment,std::vector<double>>>))")
475 .method("str", &Core::FMTschedule::operator std::string,
476 "@DocString(FMTschedule::operator std::string)")
477 .method("add", &Core::FMTschedule::operator +,
478 "@DocString(FMTschedule::operator+)")
479 .method("actionarea", &Core::FMTschedule::actionarea,
480 "@DocString(FMTschedule::actionarea)")
481 .method("getperiod", &Core::FMTschedule::getperiod,
482 "@DocString(FMTschedule::getperiod)")
483 .method("setperiod", &Core::FMTschedule::setperiod,
484 "@DocString(FMTschedule::setperiod)")
485 .method("eq", &Core::FMTschedule::operator ==,
486 "@DocString(FMTschedule::operator==)")
487 .method("ne", &Core::FMTschedule::operator !=,
488 "@DocString(FMTschedule::operator!=)")
489 .method("empty",&Core::FMTschedule::empty,
490 "@DocString(FMTschedule::empty)");
491
492 Rcpp::class_<Core::FMTGCBMtransition>("FMTGCBMtransition", "@DocString(FMTGCBMtransition)")
493 .constructor("@DocString(FMTGCBMtransition())")
494 .field("name", &Core::FMTGCBMtransition::name,
495 "@DocString(FMTGCBMtransition::name)")
496 .field("ageafter", &Core::FMTGCBMtransition::ageafter,
497 "@DocString(FMTGCBMtransition::ageafter)")
498 .field("themes",&Core::FMTGCBMtransition::themes,
499 "@DocString(FMTGCBMtransition::themes)");
500
501 Rcpp::class_<Core::FMTconstraint>("FMTconstraint", "@DocString(FMTconstraint)")
502 .derives<Core::FMToutput>("FMToutput")
503 .constructor("@DocString(FMTconstraint())")
504 .constructor<Core::FMTconstrainttype,Core::FMToutput>("@DocString(FMTconstraint(FMTconstrainttype,const FMToutput&))")
505 .method("setlength", &Core::FMTconstraint::setlength,
506 "@DocString(FMTconstraint::setlength)")
507 .method("realconstraintstring", &Core::FMTconstraint::operator std::string,
508 "@DocString(FMTconstraint::operator std::string)")
509 .method("eq", &Core::FMTconstraint::operator ==,
510 "@DocString(FMTconstraint::operator==)");
511
512 }
513}
514
515#endif // PYEXPORTCORE_H_INCLUDED
RCPP_COMMA
#define RCPP_COMMA
Definition: Rdeclarations.hpp:91
RCPP_EXPOSED_AS
RCPP_EXPOSED_AS(Core::FMTobject)
RCPP_EXPOSED_ENUM_NODECL
RCPP_EXPOSED_ENUM_NODECL(Core::FMTyldtype)
RCPP_DEFINEPAIR
RCPP_DEFINEPAIR(Core::FMTmask, Core::FMTspec)
RCPP_DEFINEVECTOR
RCPP_DEFINEVECTOR(Core::FMTmask)
RCPP_EXPOSED_WRAP
RCPP_EXPOSED_WRAP(Core::FMTobject)
RCPP_DEFINEMAP
RCPP_DEFINEMAP(Core::FMTdevelopment, std::vector< double >)
Core::FMTGCBMtransition::themes
std::map< std::string, std::string > themes
Map where's the key is the theme name and the element is the new attribute set after the transition.
Definition: FMTGCBMtransition.hpp:47
Core::FMTGCBMtransition::ageafter
int ageafter
Describe the age set on the strata after the disturbance.
Definition: FMTGCBMtransition.hpp:44
Core::FMTGCBMtransition::name
std::string name
The name of the GCBM transition.
Definition: FMTGCBMtransition.hpp:50
Core::FMTaction
Definition: FMTaction.hpp:42
Core::FMTaction::dorespectlock
bool dorespectlock() const
Definition: FMTaction.hpp:160
Core::FMTaction::isresetage
bool isresetage() const
Definition: FMTaction.hpp:169
Core::FMTaction::getname
std::string getname() const
Definition: FMTaction.hpp:151
Core::FMTactualdevelopment
Definition: FMTactualdevelopment.hpp:25
Core::FMTactualdevelopment::getarea
double getarea() const override
Core::FMTactualdevelopment::setarea
void setarea(const double &newarea)
Core::FMTagebounds
Definition: FMTbounds.hpp:272
Core::FMTageyieldhandler
Definition: FMTageyieldhandler.hpp:20
Core::FMTconstants
Definition: FMTconstants.hpp:29
Core::FMTconstraint::setlength
void setlength(int firstperiod=1, int lastperiod=std::numeric_limits< int >::max())
Core::FMTdevelopment
Definition: FMTdevelopment.hpp:44
Core::FMTdevelopment::setage
void setage(const int &lage)
Core::FMTdevelopment::getlock
int getlock() const
Definition: FMTdevelopment.hpp:90
Core::FMTdevelopment::getmaskcopy
Core::FMTmask getmaskcopy() const
Definition: FMTdevelopment.hpp:114
Core::FMTdevelopment::setlock
void setlock(const int &llock)
Core::FMTdevelopment::setperiod
void setperiod(const int &lperiod)
Core::FMTdevelopment::setmask
void setmask(const Core::FMTmask &lmask)
Core::FMTdevelopment::getage
int getage() const
Definition: FMTdevelopment.hpp:82
Core::FMTdevelopment::getperiod
int getperiod() const
Definition: FMTdevelopment.hpp:98
Core::FMTdevelopment::grow
FMTfuturdevelopment grow() const
Core::FMTdevelopmentpath
Definition: FMTdevelopmentpath.hpp:19
Core::FMTfork
Definition: FMTfork.hpp:34
Core::FMTfork::add
void add(const FMTtransitionmask &transition)
Core::FMTfuturdevelopment
Definition: FMTfuturdevelopment.hpp:24
Core::FMTlifespans
Definition: FMTlifespans.hpp:24
Core::FMTlist
Definition: FMTlist.hpp:46
Core::FMTlockbounds
Definition: FMTbounds.hpp:314
Core::FMTmask
Definition: FMTmask.hpp:96
Core::FMTmaskfilter
Definition: FMTmaskfilter.hpp:27
Core::FMTobject
Definition: FMTobject.hpp:50
Core::FMTobject::setquietlogger
virtual void setquietlogger()
Core::FMTobject::seterrorstowarnings
void seterrorstowarnings(const std::vector< Exception::FMTexc > &errors)
Core::FMTobject::enablenestedexceptions
void enablenestedexceptions()
Core::FMTobject::redirectlogtofile
void redirectlogtofile(const std::string &location)
Core::FMTobject::disablenestedexceptions
void disablenestedexceptions()
Core::FMTobject::setdebugexceptionhandler
void setdebugexceptionhandler()
Core::FMTobject::setquietexceptionhandler
void setquietexceptionhandler()
Core::FMTobject::setdefaultlogger
virtual void setdefaultlogger()
Core::FMTobject::setdefaultexceptionhandler
void setdefaultexceptionhandler()
Core::FMTobject::setfreeexceptionhandler
void setfreeexceptionhandler()
Core::FMTobject::settasklogger
virtual void settasklogger()
Core::FMTobject::setdebuglogger
virtual void setdebuglogger()
Core::FMToperator
Definition: FMToperator.hpp:36
Core::FMToutput
Definition: FMToutput.hpp:39
Core::FMToutput::empty
bool empty() const
Core::FMToutput::containslevel
bool containslevel() const
Core::FMToutput::islevel
bool islevel() const
Core::FMToutput::getname
std::string getname() const
Definition: FMToutput.hpp:116
Core::FMToutput::isonlylevel
bool isonlylevel() const
Core::FMToutput::getdescription
std::string getdescription() const
Definition: FMToutput.hpp:124
Core::FMToutputnode
Definition: FMToutputnode.hpp:20
Core::FMToutputsource
Definition: FMToutputsource.hpp:40
Core::FMTperbounds
Definition: FMTbounds.hpp:293
Core::FMTschedule
Definition: FMTschedule.hpp:31
Core::FMTschedule::empty
bool empty() const
Core::FMTschedule::setperiod
void setperiod(const int &newperiod)
Core::FMTschedule::actionarea
double actionarea(const FMTaction &action) const
Core::FMTschedule::getperiod
int getperiod() const
Definition: FMTschedule.hpp:134
Core::FMTspec
Definition: FMTbounds.hpp:342
Core::FMTspec::addbounds
bool addbounds(const FMTagebounds &bound)
Core::FMTspec::setbounds
bool setbounds(const FMTperbounds &bound)
Core::FMTtheme
Definition: FMTtheme.hpp:47
Core::FMTtheme::getname
std::string getname() const
Definition: FMTtheme.hpp:267
Core::FMTtheme::getattributes
std::vector< std::string > getattributes(const std::string &value, bool aggregate_source=false) const
Core::FMTtimeyieldhandler
Definition: FMTtimeyieldhandler.hpp:21
Core::FMTtransition
Definition: FMTtransition.hpp:37
Core::FMTtransition::attribute_targets
std::map< std::string, std::vector< FMTdevelopment > > attribute_targets(const std::vector< FMTdevelopment > &devs, const FMTyields &ylds, const std::vector< FMTtheme > &themes) const
Core::FMTtransition::getname
std::string getname() const
Definition: FMTtransition.hpp:87
Core::FMTtransition::main_target
FMTmask main_target(const std::vector< FMTdevelopment > &devs, const FMTyields &ylds) const
Core::FMTtransition::single
FMTtransition single() const
Core::FMTtransition::age_after
unsigned int age_after(const std::vector< FMTdevelopment > &devs, const FMTaction &action, const FMTyields &ylds, const std::vector< FMTtheme > &themes) const
Core::FMTtransitionmask
Definition: FMTtransitionmask.hpp:29
Core::FMTyieldhandler
Definition: FMTyieldhandler.hpp:31
Core::FMTyieldhandler::push_base
bool push_base(const int &base)
Core::FMTyieldhandler::push_data
virtual bool push_data(const std::string &yld, const double &value)
Core::FMTyields
Definition: FMTyields.hpp:40
Core::FMTyields::getallyields
std::map< std::string, std::map< std::string, std::vector< double > > > getallyields(const FMTtheme &target, FMTyldtype type) const
Core::FMTyields::update
void update() override
Core::FMTyields::push_backtimehandler
void push_backtimehandler(const FMTmask &mask, const FMTtimeyieldhandler &value)
Core::FMTyields::push_backagehandler
void push_backagehandler(const FMTmask &mask, const FMTageyieldhandler &value)
Core::FMTyields::getfromfactor
FMTyields getfromfactor(const double &factor, std::vector< std::string >yieldnames=std::vector< std::string >()) const
Core::FMTyldbounds
Definition: FMTbounds.hpp:249
Core
The Core namespace provides classes for simulating stands/strata growth/harvest through time.
Definition: FMTaction.hpp:31
Core::FMTsection
FMTsection
Definition: FMTutility.hpp:23
Core::FMTconstrainttype
FMTconstrainttype
Definition: FMTconstraint.hpp:32
Core::FMTyldtype
FMTyldtype
Definition: FMTutility.hpp:45
Core::FMTotar
FMTotar
Definition: FMTutility.hpp:74
R
Definition: RexportCore.hpp:153
Generated by doxygen 1.9.6