tomasz.sowa
/
ezc
1
0
Fork 0
Code Issues 4 Pull Requests Releases Activity

instead of morm::Wrapper let the Var<> has a child's map

This commit is contained in:
Tomasz Sowa 2021-10-27 14:23:48 +02:00
parent a61fd2dcd0
commit 6d79cdb2fc
2 changed files with 325 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

229
src/generator.h
View File

@ -147,7 +147,7 @@ private:
Var<StreamType> * variable; Var<StreamType> * variable;
#ifdef EZC_HAS_MORM_LIBRARY #ifdef EZC_HAS_MORM_LIBRARY
morm::Wrapper * wrapper; Var<StreamType> * wrapper;
size_t field_index; size_t field_index;
#endif #endif
@ -302,10 +302,10 @@ private:
Var<StreamType> & result, Var<StreamType> & result,
std::vector<Var<StreamType>> & parameters); std::vector<Var<StreamType>> & parameters);
void PrintDate(pt::Date * date, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters); void PrintDate(pt::Date & date, std::vector<Var<StreamType>> & parameters, Var<StreamType> & result);
bool PrintDatePart(pt::Date * date, const std::wstring & field, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters); //bool PrintDatePart(pt::Date & date, const std::wstring & field, std::vector<Var<StreamType>> & parameters, Var<StreamType> & result);
bool CallDate(FindHelper & find_helper, std::vector<std::wstring> & fields, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters); //bool CallDate(pt::Date & date, const std::wstring & name, std::vector<std::wstring> & fields, size_t & field_index, std::vector<Var<StreamType>> & parameters, Var<StreamType> & result);
void PrintLastSpaceField(pt::Space * space, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters); void PrintLastSpaceField(pt::Space * space, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters);
void CallSpaceObjectForLastField(Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, pt::Space * space); void CallSpaceObjectForLastField(Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, pt::Space * space);
@ -320,10 +320,11 @@ private:
bool CallSpace(morm::SpaceWrapper * space_wrapper, const std::wstring & name, size_t & field_index, std::vector<std::wstring> & fields, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters); bool CallSpace(morm::SpaceWrapper * space_wrapper, const std::wstring & name, size_t & field_index, std::vector<std::wstring> & fields, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters);
#ifdef EZC_HAS_MORM_LIBRARY #ifdef EZC_HAS_MORM_LIBRARY
bool CallModelField(morm::Model & model, const std::wstring & field, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, const StreamType & in_stream); bool CallModelField(morm::Model & model, const std::wstring & field, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters);
bool CallModel(morm::Model & model, FindHelper & find_helper, std::vector<std::wstring> & fields, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, const StreamType & in_stream); // bool CallModel(morm::Model & model, const std::wstring & name, std::vector<std::wstring> & fields, size_t field_index,
void FindLastModelWrapper(FindHelper & find_helper, std::vector<std::wstring> & fields); // std::vector<Var<StreamType>> & parameters, Var<StreamType> & result);
bool CallWrapper(FindHelper & find_helper, std::vector<std::wstring> & fields, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, const StreamType & in_stream); // void FindLastModelWrapper(FindHelper & find_helper, std::vector<std::wstring> & fields);
// bool CallWrapper(FindHelper & find_helper, std::vector<std::wstring> & fields, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, const StreamType & in_stream);
bool XXXRenameMe(Var<StreamType> & variable, std::vector<std::wstring> & fields, size_t & field_index, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, const StreamType & in_stream); bool XXXRenameMe(Var<StreamType> & variable, std::vector<std::wstring> & fields, size_t & field_index, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, const StreamType & in_stream);
@ -1120,7 +1121,7 @@ void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::DumpModel
template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream> template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate( void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate(
pt::Date * date, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters) pt::Date & date, std::vector<Var<StreamType>> & parameters, Var<StreamType> & result)
{ {
bool is_roman = HasParam(parameters, L"roman"); bool is_roman = HasParam(parameters, L"roman");
bool is_no_sec = HasParam(parameters, L"no_sec"); bool is_no_sec = HasParam(parameters, L"no_sec");
@ -1130,7 +1131,7 @@ void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate
if( only_date ) if( only_date )
{ {
result.type = Var<StreamType>::TYPE_STREAM; result.type = Var<StreamType>::TYPE_STREAM;
date->SerializeYearMonthDay(result.stream, is_roman); date.SerializeYearMonthDay(result.stream, is_roman);
} }
else else
if( only_time ) if( only_time )
@ -1138,21 +1139,26 @@ void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate
result.type = Var<StreamType>::TYPE_STREAM; result.type = Var<StreamType>::TYPE_STREAM;
if( is_no_sec ) if( is_no_sec )
date->SerializeHourMin(result.stream); date.SerializeHourMin(result.stream);
else else
date->SerializeHourMinSec(result.stream); date.SerializeHourMinSec(result.stream);
} }
else else
{ {
result.type = Var<StreamType>::TYPE_STREAM; result.type = Var<StreamType>::TYPE_STREAM;
date->Serialize(result.stream, is_roman, !is_no_sec); date.Serialize(result.stream, is_roman, !is_no_sec);
} }
} }
/*
* these can be made as a simple function (e.g. from winix)
* as a first argument let they take pt::Date
*/
/*
template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream> template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDatePart( bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDatePart(
pt::Date * date, const std::wstring & field, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters) pt::Date & date, const std::wstring & field, std::vector<Var<StreamType>> & parameters, Var<StreamType> & result)
{ {
bool is_test = IsTestingFunctionExistence(); bool is_test = IsTestingFunctionExistence();
@ -1161,7 +1167,7 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate
if( !is_test ) if( !is_test )
{ {
result.type = Var<StreamType>::TYPE_STREAM; result.type = Var<StreamType>::TYPE_STREAM;
result.stream << date->year; result.stream << date.year;
} }
} }
else else
@ -1173,9 +1179,9 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate
result.type = Var<StreamType>::TYPE_STREAM; result.type = Var<StreamType>::TYPE_STREAM;
if( is_roman ) if( is_roman )
pt::Date::SerializeMonthAsRoman(result.stream, date->month); pt::Date::SerializeMonthAsRoman(result.stream, date.month);
else else
result.stream << date->month; result.stream << date.month;
} }
} }
else else
@ -1184,7 +1190,7 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate
if( !is_test ) if( !is_test )
{ {
result.type = Var<StreamType>::TYPE_STREAM; result.type = Var<StreamType>::TYPE_STREAM;
result.stream << date->day; result.stream << date.day;
} }
} }
else else
@ -1193,7 +1199,7 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate
if( !is_test ) if( !is_test )
{ {
result.type = Var<StreamType>::TYPE_STREAM; result.type = Var<StreamType>::TYPE_STREAM;
result.stream << date->hour; result.stream << date.hour;
} }
} }
else else
@ -1202,7 +1208,7 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate
if( !is_test ) if( !is_test )
{ {
result.type = Var<StreamType>::TYPE_STREAM; result.type = Var<StreamType>::TYPE_STREAM;
result.stream << date->min; result.stream << date.min;
} }
} }
else else
@ -1211,7 +1217,7 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate
if( !is_test ) if( !is_test )
{ {
result.type = Var<StreamType>::TYPE_STREAM; result.type = Var<StreamType>::TYPE_STREAM;
result.stream << date->sec; result.stream << date.sec;
} }
} }
else else
@ -1221,45 +1227,41 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::PrintDate
return true; return true;
} }
*/
/*
template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream> template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallDate( bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallDate(
FindHelper & find_helper, std::vector<std::wstring> & fields, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters) pt::Date & date, const std::wstring & name, std::vector<std::wstring> & fields, size_t field_index, std::vector<Var<StreamType>> & parameters, Var<StreamType> & result)
{ {
bool found = true; bool found = true;
bool all_fields_known = (find_helper.field_index == fields.size()); bool all_fields_known = (field_index == fields.size());
bool last_field_not_known = (find_helper.field_index + 1 == fields.size());
if( all_fields_known ) if( all_fields_known )
{ {
PrintDate(find_helper.wrapper->date, result, parameters); PrintDate(date, parameters, result);
}
else
if( last_field_not_known )
{
if( !PrintDatePart(find_helper.wrapper->date, fields[find_helper.field_index], result, parameters) )
{
if( !IsTestingFunctionExistence() )
{
CreateMsg(L"cannot find ", *find_helper.fun_name, fields, L", unknown property ", fields[find_helper.field_index].c_str(), L" of date object");
}
found = false;
}
} }
else else
{ {
if( !IsTestingFunctionExistence() ) found = PrintDatePart(date, fields[field_index], result, parameters);
{
CreateMsg(L"cannot find ", *find_helper.fun_name, fields, L", ", fields[find_helper.field_index].c_str(), L" is not a model nor a model container nor a space");
}
found = false; // if( found )
// field_index += 1;
// {
// if( !IsTestingFunctionExistence() )
// {
// CreateMsg(L"cannot find ", *find_helper.fun_name, fields, L", unknown property ", fields[find_helper.field_index].c_str(), L" of date object");
// }
//
// found = false;
// }
} }
return found; return found;
} }
*/
@ -1488,7 +1490,7 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallSpace
template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream> template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallModelField( bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallModelField(
morm::Model & model, const std::wstring & field, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, const StreamType & in_stream) morm::Model & model, const std::wstring & field, Var<StreamType> & result, std::vector<Var<StreamType>> & parameters)
{ {
/* /*
* if 'field' is a POD type then 'str' will be used in get_raw_value() * if 'field' is a POD type then 'str' will be used in get_raw_value()
@ -1496,27 +1498,28 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallModel
* if 'field' is a getter method which takes Env<> then out_stream will be used and 'str' will be empty * if 'field' is a getter method which takes Env<> then out_stream will be used and 'str' will be empty
* *
*/ */
pt::WTextStream str; //pt::WTextStream str;
bool found = false; bool found = false;
StreamType fake_stream;
Env<StreamType> info(result, parameters, in_stream, stack_tab[stack_index-1], *stack_tab[stack_index-1].item); Env<StreamType> info(result, parameters, fake_stream, stack_tab[stack_index-1], *stack_tab[stack_index-1].item);
found = model.get_raw_value(nullptr, field.c_str(), nullptr, info, str, false); found = model.get_raw_value(nullptr, field.c_str(), nullptr, info);
if( found && !str.empty()) // if( found && !str.empty())
{ // {
bool no_escape = HasParam(parameters, L"raw", L"noescape"); // bool no_escape = HasParam(parameters, L"raw", L"noescape");
CopyStream(str, result.stream, !no_escape); // CopyStream(str, result.stream, !no_escape);
result.type = Var<StreamType>::TYPE_STREAM; // result.type = Var<StreamType>::TYPE_STREAM;
} // }
return found; return found;
} }
/*
template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream> template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallModel( bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallModel(
morm::Model & model, FindHelper & find_helper, std::vector<std::wstring> & fields, morm::Model & model, const std::wstring & name, std::vector<std::wstring> & fields, size_t field_index,
Var<StreamType> & result, std::vector<Var<StreamType>> & parameters, const StreamType & in_stream) std::vector<Var<StreamType>> & parameters, Var<StreamType> & result)
{ {
bool found = true; bool found = true;
@ -1554,53 +1557,71 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallModel
return found; return found;
} }
*/
/*
template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream> template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::FindLastModelWrapper( void Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::FindLastModelWrapper(
FindHelper & find_helper, std::vector<std::wstring> & fields) Var<StreamType> & var_parent, std::vector<std::wstring> & fields, size_t & field_index)
{ {
for(find_helper.field_index = 0 ; find_helper.field_index < fields.size() && find_helper.wrapper->has_model_object() ; ++find_helper.field_index) Var<StreamType> * var = &var_parent;
{
std::wstring & field = fields[find_helper.field_index];
morm::Wrapper * child_wrapper = find_helper.wrapper->find_child(field);
if( !child_wrapper ) for( ; field_index < fields.size() && var->has_model_object() ; ++field_index)
{
std::wstring & field = fields[field_index];
Var<StreamType> * child_var = var->find_child(field);
if( !child_var )
{ {
morm::Model * model = nullptr; morm::Model * model = nullptr;
if( find_helper.wrapper->model ) if( var->model )
{ {
model = find_helper.wrapper->model; model = var->model;
} }
else else
if( find_helper.wrapper->model_container_wrapper ) if( var->model_container_wrapper )
{ {
model = find_helper.wrapper->model_container_wrapper->get_model(); model = var->model_container_wrapper->get_model();
// this can return null for lists/vectors in a case when the iterator is not pointing to a valid item // this can return null for lists/vectors in a case when the iterator is not pointing to a valid item
} }
if( model ) if( model )
{ {
// IMPROVE ME there'll be only one method to call a model
morm::Wrapper new_wrapper = model->get_wrapper(nullptr, field.c_str()); morm::Wrapper new_wrapper = model->get_wrapper(nullptr, field.c_str());
if( new_wrapper.has_object() ) if( new_wrapper.has_object() )
{ {
child_wrapper = find_helper.wrapper->add_child(field, new_wrapper); Var<StreamType> child;
if( new_wrapper.model )
child.set(*new_wrapper.model);
if( new_wrapper.model_container_wrapper )
child.set(*new_wrapper.model_container_wrapper);
if( new_wrapper.date )
child.set(*new_wrapper.date);
if( new_wrapper.space_wrapper )
child.set(*new_wrapper.space_wrapper);
child_var = var->add_child(field, new_wrapper);
} }
//////////////////////////////////////////////////////////////////////
} }
} }
if( !child_wrapper ) if( !child_var )
break; break;
find_helper.wrapper = child_wrapper; var = child_var;
} }
} }
*/
/*
template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream> template<class StreamType, bool is_pikotools_stream, bool is_autoescape_stream>
bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallWrapper( bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallWrapper(
FindHelper & find_helper, std::vector<std::wstring> & fields, FindHelper & find_helper, std::vector<std::wstring> & fields,
@ -1669,6 +1690,7 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::CallWrapp
return found; return found;
} }
*/
#endif #endif
@ -1867,22 +1889,43 @@ Var<StreamType> * Generator<StreamType, is_pikotools_stream, is_autoescape_strea
do do
{ {
const std::wstring * pname = (field_index == 0)? &name : &fields[field_index - 1]; const std::wstring * pname = (field_index == 0)? &name : &fields[field_index - 1];
Var<StreamType> * var = FindInScope(*pname); Var<StreamType> * old_var = var;
var = nullptr;
if( field_index > 1 && old_var )
{
var = old_var->find_child(*pname);
}
if( !var )
{
var = FindInScope(*pname);
}
if( var ) if( var )
{ {
/*
* fix me
* this is incorrect, as the parameters would be passed to the first function
* if the first function is a model we do not pass parameters to it, but to a field of the model (our next field)
*
*/
if( was_evaluated ) if( was_evaluated )
{ {
Var<StreamType> improve_me; Var<StreamType> improve_me;
EvaluateVariable(*var, res, improve_me); EvaluateVariable(name, *var, fields, field_index, res, improve_me);
res[0] = improve_me; res[0] = improve_me;
} }
else else
{ {
if( EvaluateVariable(*var, parameters, res[0]) ) if( EvaluateVariable(name, *var, fields, field_index, parameters, res[0]) )
was_evaluated = true; was_evaluated = true;
} }
} }
else
{
// log something
}
field_index += 1; field_index += 1;
} }
@ -1898,6 +1941,7 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::EvaluateV
{ {
StreamType fake_stream; StreamType fake_stream;
bool status = false; bool status = false;
bool all_fields_known = (field_index == fields.size());
if( var.type == Var<StreamType>::TYPE_FUNCTION ) if( var.type == Var<StreamType>::TYPE_FUNCTION )
{ {
@ -1916,7 +1960,7 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::EvaluateV
{ {
if( var.model ) if( var.model )
{ {
//status = CallModel(*var.model, name, fields, field_index, parameters, result); status = CallModelField(*var.model, name, result, parameters);
} }
else else
{ {
@ -1924,6 +1968,31 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::EvaluateV
} }
} }
if( var.type == Var<StreamType>::TYPE_MODEL_CONTAINER_WRAPPER && var->model_container_wrapper )
{
morm::Model * model = var.model_container_wrapper->get_model();
if( model )
{
status = CallModelField(*model, name, result, parameters);
}
else
{
// can be printed even for [if-def...]
CreateMsg(L"model ", name, fields, L" is not initialized, have you forgotten to use [for ...] statement?");
status = false;
}
if( all_fields_known )
{
if( is_generating_for )
{
var.model_container_wrapper->increment_iterator();
var.clear_childs();
}
}
}
if( var.type == Var<StreamType>::TYPE_SPACE_WRAPPER ) if( var.type == Var<StreamType>::TYPE_SPACE_WRAPPER )
{ {
if( var.space_wrapper ) if( var.space_wrapper )
@ -1936,6 +2005,12 @@ bool Generator<StreamType, is_pikotools_stream, is_autoescape_stream>::EvaluateV
} }
} }
if( var.type == Var<StreamType>::TYPE_DATE && var.date )
{
if( all_fields_known )
PrintDate(*var.date, parameters, result);
}
return status; return status;
} }

178
src/var.h
View File

@ -42,6 +42,7 @@
#include "date/date.h" #include "date/date.h"
#include "modelcontainerwrapper.h" #include "modelcontainerwrapper.h"
#include "textstream/textstream.h" #include "textstream/textstream.h"
#include "morm.h"
@ -77,17 +78,28 @@ public:
TYPE_FUNCTION, TYPE_FUNCTION,
TYPE_DATE,
TYPE_MODEL, TYPE_MODEL,
TYPE_MODEL_CONTAINER_WRAPPER, TYPE_MODEL_CONTAINER_WRAPPER,
TYPE_SPACE_WRAPPER, // or just type_space TYPE_SPACE_WRAPPER, // or just type_space
}; };
Type type;
Var(); Var();
Var(const Var & var);
Var & operator=(const Var & var);
~Var();
// IMPROVEME add move cctor and operator=
Var * add_child(const std::wstring & child_name, const Var & var);
Var * find_child(const std::wstring & child_name);
bool has_object();
bool has_model_object();
void clear(); void clear();
void clear_childs();
bool to_bool() const; bool to_bool() const;
@ -120,9 +132,12 @@ public:
void set(UserFunction user_function); void set(UserFunction user_function);
void set(const pt::Date & date);
// this model is not copied, is it a correct interface? // this model is not copied, is it a correct interface?
void set(morm::Model & model); void set(morm::Model & model);
void set(morm::ModelContainerWrapper & model_container_wrapper);
@ -158,6 +173,8 @@ public:
Var & operator<<(const pt::Stream & str); Var & operator<<(const pt::Stream & str);
Type type;
UserFunction user_function; UserFunction user_function;
morm::Model * model; morm::Model * model;
morm::ModelContainerWrapper * model_container_wrapper; morm::ModelContainerWrapper * model_container_wrapper;
@ -169,6 +186,11 @@ public:
private: private:
std::map<std::wstring, Var> childs_map;
void initialize_empty();
void copy(const Var & var);
bool is_equal_bool(const char * str) const; bool is_equal_bool(const char * str) const;
bool is_equal_string(const char * str) const; bool is_equal_string(const char * str) const;
@ -199,25 +221,148 @@ private:
template<typename StreamType> template<typename StreamType>
Var<StreamType>::Var() Var<StreamType>::Var()
{
initialize_empty();
}
template<typename StreamType>
Var<StreamType>::Var(const Var & var)
{
initialize_empty();
copy(var);
}
template<typename StreamType>
Var<StreamType> & Var<StreamType>::operator=(const Var & var)
{
clear();
copy(var);
return *this;
}
template<typename StreamType>
void Var<StreamType>::copy(const Var & var)
{
type = var.type;
user_function = var.user_function;
model = var.model;
model_container_wrapper = var.model_container_wrapper;
date = var.date;
space_wrapper = var.space_wrapper;
space_local = var.space_local;
stream = var.stream;
if( model_container_wrapper )
{
model_container_wrapper->increment_reference_counter();
}
if( space_wrapper )
{
space_wrapper->increment_reference_counter();
}
// childs_map don't need to be copied
}
template<typename StreamType>
Var<StreamType>::~Var()
{ {
clear(); clear();
} }
template<typename StreamType> template<typename StreamType>
void Var<StreamType>::clear() void Var<StreamType>::initialize_empty()
{ {
//res = false;
//is_function = false;
type = TYPE_VOID; type = TYPE_VOID;
user_function = nullptr; user_function = nullptr;
model = nullptr; model = nullptr;
model_container_wrapper = nullptr; model_container_wrapper = nullptr;
date = nullptr; date = nullptr;
space_wrapper = nullptr; space_wrapper = nullptr;
}
template<typename StreamType>
void Var<StreamType>::clear()
{
if( model_container_wrapper )
{
model_container_wrapper->decrement_reference_counter();
if( model_container_wrapper->get_reference_counter() == 0 && model_container_wrapper->should_be_auto_removed() )
{
delete model_container_wrapper;
}
}
if( space_wrapper )
{
space_wrapper->decrement_reference_counter();
if( space_wrapper->get_reference_counter() == 0 && space_wrapper->should_be_auto_removed() )
{
delete space_wrapper;
}
}
initialize_empty();
space_local.clear(); space_local.clear();
stream.clear(); stream.clear();
clear_childs();
}
template<typename StreamType>
void Var<StreamType>::clear_childs()
{
childs_map.clear();
}
template<typename StreamType>
Var<StreamType> * Var<StreamType>::add_child(const std::wstring & child_name, const Var & var)
{
Var & v = childs_map[child_name];
v.clear();
v = var;
return &v;
}
template<typename StreamType>
Var<StreamType> * Var<StreamType>::find_child(const std::wstring & child_name)
{
auto i = childs_map.find(child_name);
if( i != childs_map.end() )
{
return &i->second;
}
return nullptr;
}
template<typename StreamType>
bool Var<StreamType>::has_object()
{
return type != TYPE_VOID;
}
template<typename StreamType>
bool Var<StreamType>::has_model_object()
{
return model || model_container_wrapper;
} }
@ -238,6 +383,7 @@ bool Var<StreamType>::to_bool() const
case TYPE_STREAM: case TYPE_STREAM:
case TYPE_FUNCTION: case TYPE_FUNCTION:
case TYPE_DATE:
case TYPE_MODEL: case TYPE_MODEL:
case TYPE_MODEL_CONTAINER_WRAPPER: case TYPE_MODEL_CONTAINER_WRAPPER:
case TYPE_SPACE_WRAPPER: case TYPE_SPACE_WRAPPER:
@ -413,6 +559,14 @@ void Var<StreamType>::set(UserFunction user_function)
} }
template<typename StreamType>
void Var<StreamType>::set(const pt::Date & date)
{
type = TYPE_DATE;
this->date = &date;
}
template<typename StreamType> template<typename StreamType>
void Var<StreamType>::set(morm::Model & model) void Var<StreamType>::set(morm::Model & model)
{ {
@ -421,6 +575,14 @@ void Var<StreamType>::set(morm::Model & model)
} }
template<typename StreamType>
void Var<StreamType>::set(morm::ModelContainerWrapper & model_container_wrapper)
{
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->model_container_wrapper = &model_container_wrapper;
}
template<typename StreamType> template<typename StreamType>
bool Var<StreamType>::is_equal(const char * str) const bool Var<StreamType>::is_equal(const char * str) const
@ -438,6 +600,7 @@ bool Var<StreamType>::is_equal(const char * str) const
case TYPE_DOUBLE: case TYPE_DOUBLE:
case TYPE_STREAM: case TYPE_STREAM:
case TYPE_FUNCTION: case TYPE_FUNCTION:
case TYPE_DATE:
case TYPE_MODEL: case TYPE_MODEL:
case TYPE_MODEL_CONTAINER_WRAPPER: case TYPE_MODEL_CONTAINER_WRAPPER:
case TYPE_SPACE_WRAPPER: case TYPE_SPACE_WRAPPER:
@ -465,6 +628,7 @@ bool Var<StreamType>::is_equal(const wchar_t * str) const
case TYPE_DOUBLE: case TYPE_DOUBLE:
case TYPE_STREAM: case TYPE_STREAM:
case TYPE_FUNCTION: case TYPE_FUNCTION:
case TYPE_DATE:
case TYPE_MODEL: case TYPE_MODEL:
case TYPE_MODEL_CONTAINER_WRAPPER: case TYPE_MODEL_CONTAINER_WRAPPER:
case TYPE_SPACE_WRAPPER: case TYPE_SPACE_WRAPPER:
@ -573,6 +737,10 @@ void Var<StreamType>::serialize_to(pt::WTextStream & str)
str = stream; str = stream;
break; break;
case TYPE_DATE:
date->SerializeISO(str);
break;
case TYPE_VOID: case TYPE_VOID:
case TYPE_FUNCTION: case TYPE_FUNCTION:
case TYPE_MODEL: case TYPE_MODEL: