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

WIP: add a Val struct as an input/output when calling a function

Browse Source
This commit is contained in:
Tomasz Sowa
2024-12-13 15:47:54 +01:00
parent 6f75664400
commit 345e1870e3
6 changed files with 523 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.templates/.clangd
View File

@@ -1,2 +1,2 @@
CompileFlags:
Add: [-pthread, -std=c++20, -I%%%CURRENT_DIR%%%/src, -I%%%GLOBAL_WORKING_DIR%%%/pikotools/src, -I%%%GLOBAL_WORKING_DIR%%%/morm/src, -I/usr/include, -I/usr/local/include, -DEZC_HAS_MORM_LIBRARY]
Add: [-pthread, -std=c++20, -I%%%CURRENT_DIR%%%/src, -I%%%GLOBAL_WORKING_DIR%%%/pikotools/src, -I%%%GLOBAL_WORKING_DIR%%%/morm/src, -I/usr/include, -I/usr/local/include, -DEZC_HAS_MORM_LIBRARY, -DMORM_HAS_EZC_LIBRARY]

226
src/generator.h
View File

@@ -147,7 +147,7 @@ private:
Val & result,
pt::Stream & out_stream,
const pt::Stream & in_stream) :
item_fun(item_fun), fun_name(fun_name), fields(fields), baseval(baseval), currentval(&baseval),
item_fun(item_fun), fun_name(fun_name), fields(fields), baseval(&baseval), currentval(&baseval),
parameters(parameters), result(result), out_stream(out_stream), in_stream(in_stream)
{
#ifdef EZC_HAS_MORM_LIBRARY
@@ -157,10 +157,22 @@ private:
FindHelper(const FindHelper &) = delete;
// RENAMEME
void set_base_val(Val * val)
{
baseval = val;
currentval = val;
}
void set_base_val(Val & val)
{
set_base_val(&val);
}
Item::Function & item_fun;
const std::wstring & fun_name;
std::vector<std::wstring> & fields;
Val & baseval;
Val * baseval;
Val * currentval;
std::vector<Val> & parameters;
Val & result;
@@ -168,6 +180,20 @@ private:
const pt::Stream & in_stream;
// if:
// field_index == size() - all fields items are either models, models containers, space or a date
// field_index == size()-1 - only the last field is not known
// field_index < size()-1 - there are more not known fields
bool all_fields_known()
{
return (field_index == fields.size());
}
bool last_field_not_known()
{
return (field_index + 1 == fields.size());
}
//std::wstring * fun_name;
//BaseObj * base_obj;
@@ -328,7 +354,8 @@ private:
bool FindInModels(FindHelper & find_helper);
#endif
bool FindInFunctionsAndBlocks(FindHelper & find_helper);
bool FindInFunctions(FindHelper & find_helper);
bool FindInBlocks(FindHelper & find_helper);
bool FindInVariables(FindHelper & find_helper);
bool Find(FindHelper & find_helper);
@@ -338,6 +365,7 @@ private:
void CallFunction(FindHelper & find_helper);
bool CallBlock(FindHelper & find_helper);
bool CallPodType(FindHelper & find_helper);
void CallObject(BaseObj & base_obj, int method_index, Env & info);
@@ -360,7 +388,6 @@ private:
#ifdef EZC_HAS_MORM_LIBRARY
bool CallModelField(FindHelper & find_helper, morm::Model & model);
bool CallModel(FindHelper & find_helper, morm::Model & model);
Val WrapperToVal(morm::Wrapper & wrapper);
void FindLastModelWrapper(FindHelper & find_helper);
bool CallModel(FindHelper & find_helper);
bool CallModelContainerWrapper(FindHelper & find_helper);
@@ -380,7 +407,7 @@ private:
// pt::Stream & out_stream,
// const pt::Stream & in_stream);
void PrepareParameters(FindHelper & find_helper);
void EvaluateParameters(FindHelper & find_helper);
bool ReduceFields(FindHelper & find_helper);
bool CallValue(FindHelper & find_helper);
void CleanupParameters(std::vector<Val> & parameters);
@@ -1061,7 +1088,7 @@ bool Generator::CheckBlockArgument(FindHelper & find_helper)
if( size_t(find_helper.item_fun.arg) < block_stack.args.size() )
{
find_helper.baseval.set(block_stack.args[find_helper.item_fun.arg]);
find_helper.set_base_val(block_stack.args[find_helper.item_fun.arg]);
return true;
}
}
@@ -1112,34 +1139,12 @@ bool Generator::FindInModels(FindHelper & find_helper)
if( pmodels )
{
// morm::Wrapper probably will be removed....
morm::Wrapper * m = pmodels->Find(find_helper.fun_name);
Val * val = pmodels->Find(find_helper.fun_name);
if( m )
if( val )
{
if( m->model )
{
find_helper.baseval.set(*m->model);
found = true;
}
else
if( m->model_container_wrapper )
{
find_helper.baseval.set(*m->model_container_wrapper);
found = true;
}
else
if( m->date )
{
find_helper.baseval.set(*m->date);
found = true;
}
else
if( m->space_wrapper )
{
find_helper.baseval.set(*m->space_wrapper);
found = true;
}
find_helper.set_base_val(val);
found = true;
}
}
@@ -1150,47 +1155,40 @@ bool Generator::FindInModels(FindHelper & find_helper)
// IMPROVEME split me into two functions
bool Generator::FindInFunctionsAndBlocks(FindHelper & find_helper)
bool Generator::FindInFunctions(FindHelper & find_helper)
{
// Objects will be removed in the future
// if( pobjects )
// {
// typename Objects::Iterator i = pobjects->Find(name, find_helper.method_index);
// if( i != pobjects->End() )
// {
// find_helper.base_obj = *i;
// return true;
// }
// }
if( pfunctions )
{
typename Functions::Iterator i = pfunctions->Find(find_helper.fun_name);
if( i != pfunctions->End() )
{
find_helper.baseval.set(i->second);
find_helper.baseval->set(i->second);
return true;
}
}
return false;
}
bool Generator::FindInBlocks(FindHelper & find_helper)
{
if( pblocks )
{
Blocks::Iterator i = pblocks->Find(find_helper.fun_name);
if( i != pblocks->End() )
{
find_helper.baseval.set(i->second);
find_helper.baseval->set_pointer_to(&i->second);
return true;
}
}
return false;
return false;
}
bool Generator::FindInVariables(FindHelper & find_helper)
{
if( pvals )
@@ -1199,7 +1197,7 @@ bool Generator::FindInVariables(FindHelper & find_helper)
if( i != pvals->end() )
{
find_helper.baseval.set(i->second);
find_helper.set_base_val(i->second);
return true;
}
}
@@ -1237,7 +1235,10 @@ bool Generator::Find(FindHelper & find_helper)
// if( FindInCache(item_fun, find_helper) )
// return true;
if( FindInFunctionsAndBlocks(find_helper) )
if( FindInFunctions(find_helper) )
return true;
if( FindInBlocks(find_helper) )
return true;
if( FindInVariables(find_helper) )
@@ -1281,10 +1282,10 @@ void Generator::CallFunction(FindHelper & find_helper)
{
if( !IsTestingFunctionExistence() )
{
if( find_helper.baseval.type == Val::TYPE_FUNCTION && find_helper.baseval.pointer )
if( find_helper.baseval->type == Val::TYPE_FUNCTION && find_helper.baseval->pointer )
{
using UserFunction = void (*)(Env &);
UserFunction user_function = reinterpret_cast<UserFunction>(find_helper.baseval.pointer);
UserFunction user_function = reinterpret_cast<UserFunction>(find_helper.baseval->pointer);
Env env(find_helper.out_stream, find_helper.parameters, find_helper.result, find_helper.in_stream, stack_tab[stack_index-1], *stack_tab[stack_index-1].item);
CallFunction(user_function, env);
@@ -1479,9 +1480,9 @@ bool Generator::CallDate(FindHelper & find_helper)
bool last_field_not_known = (find_helper.field_index + 1 == find_helper.fields.size());
pt::Date * date = nullptr;
if( find_helper.baseval.type == Val::TYPE_DATE && find_helper.baseval.pointer )
if( find_helper.currentval->type == Val::TYPE_DATE && find_helper.currentval->pointer )
{
date = reinterpret_cast<pt::Date*>(find_helper.baseval.pointer);
date = reinterpret_cast<pt::Date*>(find_helper.currentval->pointer);
}
if( all_fields_known )
@@ -1648,7 +1649,7 @@ void Generator::PrintLastSpaceField(FindHelper & find_helper, pt::Space * space)
bool Generator::CallSpace(FindHelper & find_helper)
{
morm::SpaceWrapper * space_wrapper = reinterpret_cast<morm::SpaceWrapper*>(find_helper.baseval.pointer);
morm::SpaceWrapper * space_wrapper = reinterpret_cast<morm::SpaceWrapper*>(find_helper.currentval->pointer);
pt::Space * space = space_wrapper->get_space();
//last_res = false;
size_t field_index = find_helper.field_index;
@@ -1771,6 +1772,12 @@ bool Generator::CallModelField(FindHelper & find_helper, morm::Model & model)
found = model.get_raw_value(nullptr, field.c_str(), nullptr, env, find_helper.out_stream, false);
}
if( found )
{
// set type to TYPE_OUTPUT_STREAM?
// find_helper.result.type ==
}
return found;
}
@@ -1820,26 +1827,6 @@ bool Generator::CallModel(FindHelper & find_helper, morm::Model & model)
}
Val Generator::WrapperToVal(morm::Wrapper & wrapper)
{
Val child(output_stream);
if( wrapper.model )
child.set(*wrapper.model);
else
if( wrapper.model_container_wrapper )
child.set(*wrapper.model_container_wrapper);
else
if( wrapper.space_wrapper )
child.set(*wrapper.space_wrapper);
else
if( wrapper.date )
child.set(*wrapper.date);
return child;
}
void Generator::FindLastModelWrapper(FindHelper & find_helper)
{
for(find_helper.field_index = 0 ; find_helper.field_index < find_helper.fields.size() && find_helper.currentval->has_model_object() ; ++find_helper.field_index)
@@ -1868,16 +1855,11 @@ void Generator::FindLastModelWrapper(FindHelper & find_helper)
if( model )
{
// IMPROVEME improve the morm library
// return a Val instead of a Wrapper
morm::Wrapper new_wrapper = model->get_wrapper(nullptr, field.c_str());
Val val = model->get_ezc_val(nullptr, field.c_str());
if( new_wrapper.has_object() )
if( val.has_object() )
{
Val child = WrapperToVal(new_wrapper);
if( child.type != Val::TYPE_VOID )
child_wrapper = find_helper.currentval->add_child(field, child);
child_wrapper = find_helper.currentval->add_child(field, val);
}
}
}
@@ -1885,8 +1867,8 @@ void Generator::FindLastModelWrapper(FindHelper & find_helper)
if( !child_wrapper )
break;
//find_helper.wrapper = child_wrapper;
find_helper.currentval = child_wrapper;
find_helper.currentval->set_output_stream(find_helper.out_stream);
}
}
@@ -1904,14 +1886,6 @@ bool Generator::CallModelContainerWrapper(FindHelper & find_helper)
bool found = true;
//last_res = false;
// if:
// helper.field_index == fields.size() - all fields items are either models, models containers, space or a date
// helper.field_index == fields.size()-1 - only the last field is not known
// helper.field_index < fields.size()-1 - there are more not known fields
bool all_fields_known = (find_helper.field_index == find_helper.fields.size());
bool last_field_not_known = (find_helper.field_index + 1 == find_helper.fields.size());
morm::ModelContainerWrapper * model_container_wrapper = reinterpret_cast<morm::ModelContainerWrapper*>(find_helper.currentval->pointer);
morm::Model * model = model_container_wrapper->get_model();
@@ -1921,7 +1895,7 @@ bool Generator::CallModelContainerWrapper(FindHelper & find_helper)
}
else
{
if( last_field_not_known )
if( find_helper.last_field_not_known() )
{
// can be printed even for [if-def...]
CreateMsg(L"model ", find_helper.fun_name, find_helper.fields, L" is not initialized, have you forgotten to use [for ...] statement?");
@@ -1929,18 +1903,20 @@ bool Generator::CallModelContainerWrapper(FindHelper & find_helper)
}
}
if( all_fields_known )
if( find_helper.all_fields_known() )
{
if( is_generating_for )
{
model_container_wrapper->increment_iterator();
find_helper.currentval->clear_childs(); // or current?
find_helper.currentval->clear_childs();
find_helper.result.set(model_container_wrapper->is_iterator_correct());
//last_res = find_helper.wrapper->model_container_wrapper->is_iterator_correct();
}
else
{
// for [if-def...] last_res will be set later
//last_res = !find_helper.wrapper->model_container_wrapper->is_container_empty();
find_helper.result.set(model_container_wrapper->is_container_empty());
}
}
@@ -1989,7 +1965,7 @@ bool Generator::CallBlock(FindHelper & find_helper)
ClearStream(*output_stream);
block_stack_index += 1;
Item * item_block = reinterpret_cast<Item*>(find_helper.baseval.pointer);
Item * item_block = reinterpret_cast<Item*>(find_helper.currentval->pointer);
MakeText(*item_block);
//CopyStream(*output_stream, find_helper.out_stream);
@@ -2025,19 +2001,33 @@ bool Generator::CallBlock(FindHelper & find_helper)
// }
void Generator::PrepareParameters(FindHelper & find_helper)
bool Generator::CallPodType(FindHelper & find_helper)
{
if( !IsTestingFunctionExistence() )
{
find_helper.currentval->put_pod_type_to_stream();
}
return true;
}
void Generator::EvaluateParameters(FindHelper & find_helper)
{
find_helper.parameters.resize(find_helper.item_fun.parameters.size());
for(size_t i=0 ; i < find_helper.item_fun.parameters.size() ; ++i)
{
// IMPROVEME use a pooler of streams?
find_helper.parameters[i].set_output_stream(main_stream->new_empty());
pt::Stream * tmp_stream = main_stream->new_empty();
tmp_stream->escape_input(true);
find_helper.parameters[i].set_output_stream(tmp_stream);
Item::Function & fun_child = *find_helper.item_fun.parameters[i];
if( fun_child.is_function )
{
Call(fun_child, nullptr, find_helper.parameters[i], *find_helper.parameters[i].output_stream, *empty_stream);
Call(fun_child, nullptr, find_helper.parameters[i], *tmp_stream, *empty_stream);
//CopyStreamToString(*local_temp_stream, parameters[i].str);
//parameters[i].res = last_res;
@@ -2056,7 +2046,9 @@ void Generator::PrepareParameters(FindHelper & find_helper)
// give me a better name
bool Generator::ReduceFields(FindHelper & find_helper)
{
if( find_helper.baseval.has_model_object() )
bool reduced = true;
if( find_helper.baseval->has_model_object() )
{
#ifdef EZC_HAS_MORM_LIBRARY
FindLastModelWrapper(find_helper);
@@ -2074,23 +2066,23 @@ bool Generator::ReduceFields(FindHelper & find_helper)
bool Generator::CallValue(FindHelper & find_helper)
{
if( find_helper.baseval.pointer && find_helper.currentval->pointer )
if( find_helper.baseval->pointer && find_helper.currentval->pointer )
{
#ifdef EZC_HAS_MORM_LIBRARY
if( find_helper.baseval.type == Val::TYPE_MODEL )
if( find_helper.currentval->type == Val::TYPE_MODEL )
{
//return CallWrapper(find_helper);
return CallModel(find_helper);
}
else
if( find_helper.baseval.type == Val::TYPE_MODEL_CONTAINER_WRAPPER )
if( find_helper.currentval->type == Val::TYPE_MODEL_CONTAINER_WRAPPER )
return CallModelContainerWrapper(find_helper);
else
if( find_helper.baseval.type == Val::TYPE_DATE )
if( find_helper.currentval->type == Val::TYPE_DATE )
//return CallWrapper(find_helper);
return CallDate(find_helper);
else
if( find_helper.baseval.type == Val::TYPE_SPACE_WRAPPER )
if( find_helper.currentval->type == Val::TYPE_SPACE_WRAPPER )
return CallSpace(find_helper);
//return CallWrapper(find_helper);
else
@@ -2098,17 +2090,19 @@ bool Generator::CallValue(FindHelper & find_helper)
// if( find_helper.base_obj ) // OBJECTS WILL BE REMOVED
// CallObject(*find_helper.base_obj, find_helper.method_index, parameters, result, out_stream, in_stream);
//else
if( find_helper.baseval.type == Val::TYPE_FUNCTION )
if( find_helper.currentval->type == Val::TYPE_FUNCTION )
{
CallFunction(find_helper);
return true;
}
else
if( find_helper.baseval.type == Val::TYPE_ITEM_BLOCK )
if( find_helper.currentval->type == Val::TYPE_ITEM_BLOCK )
return CallBlock(find_helper);
// else
// if( find_helper.variable )
// return CallVariable(item_fun, *find_helper.variable, parameters, result, out_stream, in_stream);
if( find_helper.currentval->has_pod_type() )
return CallPodType(find_helper);
}
return false;
@@ -2139,7 +2133,7 @@ bool Generator::Call(Item::Function & item_fun,
pt::Stream & out_stream,
const pt::Stream & in_stream)
{
Val current;
Val current(&out_stream);
std::vector<Val> parameters;
if( !fun_name )
@@ -2151,14 +2145,12 @@ bool Generator::Call(Item::Function & item_fun,
// if( clear_out_stream )
// ClearStream(out_stream);
// if constexpr(is_autoescape_stream)
// out_stream.Escape(true);
//out_stream.escape_input(true);
if( !Find(find_helper) )
return false;
PrepareParameters(find_helper);
out_stream.escape_input(true);
EvaluateParameters(find_helper);
ReduceFields(find_helper);
bool status = false;
@@ -2681,7 +2673,7 @@ void Generator::MakeTextIf(Item & item)
return;
}
MakeTextIf_go(item, result.to_bool());
MakeTextIf_go(item, result.to_bool(false));
}
@@ -2754,7 +2746,7 @@ void Generator::MakeTextFor(Item & item)
return;
}
if( !result.to_bool() )
if( !result.to_bool(true) )
break;
if( !item.item_tab.empty() )

40
src/models.cpp
View File

@@ -5,7 +5,7 @@
*/
/*
* Copyright (c) 2021, Tomasz Sowa
* Copyright (c) 2021-2024, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -63,53 +63,53 @@ void Models::Clear()
void Models::Add(const std::wstring & name, morm::Model & model)
{
morm::Wrapper wrapper;
wrapper.model = &model;
models_map[name] = wrapper;
Val val;
val.set_pointer_to(&model);
models_map[name] = val;
}
void Models::Add(const std::wstring & name, morm::Model * model)
{
morm::Wrapper wrapper;
wrapper.model = model;
models_map[name] = wrapper;
Val val;
val.set_pointer_to(model);
models_map[name] = val;
}
void Models::Add(const std::wstring & name, pt::Space & space)
{
morm::Wrapper wrapper;
wrapper.space_wrapper = new morm::SpaceWrapper(&space);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::SpaceWrapper(&space));
models_map[name] = val;
}
void Models::Add(const std::wstring & name, pt::Space * space)
{
morm::Wrapper wrapper;
wrapper.space_wrapper = new morm::SpaceWrapper(space);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::SpaceWrapper(space));
models_map[name] = val;
}
void Models::Add(const std::wstring & name, pt::Date & date)
{
morm::Wrapper wrapper;
wrapper.date = &date;
models_map[name] = wrapper;
Val val;
val.set_pointer_to(&date);
models_map[name] = val;
}
void Models::Add(const std::wstring & name, pt::Date * date)
{
morm::Wrapper wrapper;
wrapper.date = date;
models_map[name] = wrapper;
Val val;
val.set_pointer_to(date);
models_map[name] = val;
}
morm::Wrapper * Models::Find(const std::wstring & name)
Val * Models::Find(const std::wstring & name)
{
auto iterator = models_map.find(name);

55
src/models.h
View File

@@ -37,8 +37,7 @@
#ifdef EZC_HAS_MORM_LIBRARY
#include "wrapper.h"
#include "env.h"
#include "val.h"
#include "space/space.h"
@@ -50,7 +49,7 @@ class Models
{
public:
typedef std::map<std::wstring, morm::Wrapper> ModelsMap;
typedef std::map<std::wstring, Val> ModelsMap;
Models();
~Models();
@@ -67,68 +66,68 @@ public:
template<typename VectorType>
void Add(const std::wstring & name, std::vector<VectorType> & container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperVector<VectorType>(&container);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::ModelWrapperVector<VectorType>(&container));
models_map[name] = val;
}
template<typename VectorType>
void Add(const std::wstring & name, std::vector<VectorType> * container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperVector<VectorType>(container);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::ModelWrapperVector<VectorType>(container));
models_map[name] = val;
}
template<typename VectorType>
void Add(const std::wstring & name, std::vector<VectorType*> & container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperVectorPointer<VectorType>(&container);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::ModelWrapperVectorPointer<VectorType>(&container));
models_map[name] = val;
}
template<typename VectorType>
void Add(const std::wstring & name, std::vector<VectorType*> * container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperVectorPointer<VectorType>(container);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::ModelWrapperVectorPointer<VectorType>(container));
models_map[name] = val;
}
template<typename ListType>
void Add(const std::wstring & name, std::list<ListType> & container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperList<ListType>(&container);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::ModelWrapperList<ListType>(&container));
models_map[name] = val;
}
template<typename ListType>
void Add(const std::wstring & name, std::list<ListType> * container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperList<ListType>(container);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::ModelWrapperList<ListType>(container));
models_map[name] = val;
}
template<typename ListType>
void Add(const std::wstring & name, std::list<ListType*> & container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperListPointer<ListType>(&container);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::ModelWrapperListPointer<ListType>(&container));
models_map[name] = val;
}
template<typename ListType>
void Add(const std::wstring & name, std::list<ListType*> * container)
{
morm::Wrapper wrapper;
wrapper.model_container_wrapper = new morm::ModelWrapperListPointer<ListType>(container);
models_map[name] = wrapper;
Val val;
val.set_pointer_to(new morm::ModelWrapperListPointer<ListType>(container));
models_map[name] = val;
}
morm::Wrapper * Find(const std::wstring & name);
Val * Find(const std::wstring & name);
ModelsMap & GetMap();
void Clear();

379
src/val.cpp
View File

@@ -231,12 +231,25 @@ bool Val::has_object()
bool Val::has_model_object()
{
return (type == Type::TYPE_MODEL || type == Type::TYPE_MODEL_CONTAINER_WRAPPER) && pointer;
//return model || model_container_wrapper;
}
bool Val::to_bool() const
bool Val::has_pod_type()
{
return (type == Type::TYPE_CHAR ||
type == Type::TYPE_SHORT ||
type == Type::TYPE_INT ||
type == Type::TYPE_LONG ||
type == Type::TYPE_LONG_LONG ||
type == Type::TYPE_UNSIGNED_CHAR ||
type == Type::TYPE_UNSIGNED_SHORT ||
type == Type::TYPE_UNSIGNED_INT ||
type == Type::TYPE_UNSIGNED_LONG ||
type == Type::TYPE_UNSIGNED_LONG_LONG);
}
bool Val::to_bool(bool is_loop_context) const
{
switch(type)
{
@@ -262,7 +275,7 @@ bool Val::to_bool() const
return to_bool_space();
case TYPE_MODEL_CONTAINER_WRAPPER:
return to_bool_model_container_wrapper();
return to_bool_model_container_wrapper(is_loop_context);
case TYPE_OUTPUT_STREAM:
return output_stream->size() != output_stream_original_size;
@@ -293,10 +306,18 @@ bool Val::to_bool_space_wrapper() const
}
bool Val::to_bool_model_container_wrapper() const
bool Val::to_bool_model_container_wrapper(bool is_loop_context) const
{
morm::ModelContainerWrapper * model_container_wrapper = reinterpret_cast<morm::ModelContainerWrapper*>(pointer);
return !model_container_wrapper->is_container_empty();
if( is_loop_context )
{
return model_container_wrapper->is_iterator_correct();
}
else
{
return !model_container_wrapper->is_container_empty();
}
}
@@ -428,15 +449,15 @@ void Val::set(long double val)
}
void Val::set(pt::Stream & str)
void Val::set_pointer_to(pt::Stream * str)
{
clear();
type = TYPE_STREAM;
this->pointer = &str;
this->pointer = str;
}
void Val::set(UserFunction user_function)
void Val::set_pointer_to(UserFunction user_function)
{
clear();
type = TYPE_FUNCTION;
@@ -444,84 +465,48 @@ void Val::set(UserFunction user_function)
}
void Val::set(pt::Date & date)
void Val::set_pointer_to(pt::Date * date)
{
clear();
type = TYPE_DATE;
this->pointer = &date;
this->pointer = date;
}
void Val::set(morm::Model & model)
void Val::set_pointer_to(morm::Model * model)
{
clear();
type = TYPE_MODEL;
this->pointer = &model;
this->pointer = model;
}
void Val::set(morm::ModelContainerWrapper & model_container_wrapper)
void Val::set_pointer_to(morm::ModelContainerWrapper * model_container_wrapper)
{
clear();
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->pointer = &model_container_wrapper;
model_container_wrapper.increment_reference_counter();
this->pointer = model_container_wrapper;
model_container_wrapper->increment_reference_counter();
}
template<typename ModelType>
void Val::set(std::vector<ModelType> & model_container)
{
clear();
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->pointer = new morm::ModelWrapperVector<ModelType>(&model_container);
}
template<typename ModelType>
void Val::set(std::list<ModelType> & model_container)
{
clear();
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->pointer = new morm::ModelWrapperList<ModelType>(&model_container);
}
template<typename ModelType>
void Val::set(std::vector<ModelType*> & model_container)
{
clear();
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->pointer = new morm::ModelWrapperVectorPointer<ModelType>(&model_container);
}
template<typename ModelType>
void Val::set(std::list<ModelType*> & model_container)
{
clear();
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->pointer = new morm::ModelWrapperListPointer<ModelType>(&model_container);
}
void Val::set(morm::SpaceWrapper & space_wrapper)
void Val::set_pointer_to(morm::SpaceWrapper * space_wrapper)
{
clear();
type = TYPE_SPACE_WRAPPER;
this->pointer = &space_wrapper;
space_wrapper.increment_reference_counter();
this->pointer = space_wrapper;
space_wrapper->increment_reference_counter();
}
void Val::set(pt::Space & space, bool create_wrapper)
void Val::set_pointer_to(pt::Space * space, bool create_wrapper)
{
clear();
if( create_wrapper )
{
type = TYPE_SPACE_WRAPPER;
this->pointer = new morm::SpaceWrapper(&space);
this->pointer = new morm::SpaceWrapper(space);
}
else
{
@@ -531,72 +516,195 @@ void Val::set(pt::Space & space, bool create_wrapper)
}
void Val::set(Val & val)
{
clear();
// void Val::set(Val & val)
// {
// clear();
type = val.type;
pointer = val.pointer;
// type = val.type;
// pointer = val.pointer;
increment_model_container_wrapper_ref();
increment_space_wrapper_ref();
// increment_model_container_wrapper_ref();
// increment_space_wrapper_ref();
// switch(val.type)
// {
// case TYPE_VOID:
// break;
// // switch(val.type)
// // {
// // case TYPE_VOID:
// // break;
// case TYPE_SPACE_LOCAL:
// space_local = val.space_local;
// break;
// // case TYPE_SPACE_LOCAL:
// // space_local = val.space_local;
// // break;
// case TYPE_STREAM:
// stream = val.stream;
// break;
// // case TYPE_STREAM:
// // stream = val.stream;
// // break;
// case TYPE_FUNCTION:
// user_function = val.user_function;
// break;
// // case TYPE_FUNCTION:
// // user_function = val.user_function;
// // break;
// case TYPE_DATE:
// date = val.date;
// break;
// // case TYPE_DATE:
// // date = val.date;
// // break;
// case TYPE_MODEL:
// model = val.model;
// break;
// // case TYPE_MODEL:
// // model = val.model;
// // break;
// case TYPE_SPACE_WRAPPER:
// space_wrapper = val.space_wrapper;
// break;
// // case TYPE_SPACE_WRAPPER:
// // space_wrapper = val.space_wrapper;
// // break;
// case TYPE_SPACE:
// space = val.space;
// break;
// // case TYPE_SPACE:
// // space = val.space;
// // break;
// case TYPE_MODEL_CONTAINER_WRAPPER:
// model_container_wrapper = val.model_container_wrapper;
// break;
// // case TYPE_MODEL_CONTAINER_WRAPPER:
// // model_container_wrapper = val.model_container_wrapper;
// // break;
// case TYPE_OUTPUT_STREAM:
// output_stream = val.output_stream;
// break;
// // case TYPE_OUTPUT_STREAM:
// // output_stream = val.output_stream;
// // break;
// case TYPE_ITEM_BLOCK:
// item_block = val.item_block;
// break;
// }
}
// // case TYPE_ITEM_BLOCK:
// // item_block = val.item_block;
// // break;
// // }
// }
void Val::set(Item & item_block)
void Val::set_pointer_to(Item * item_block)
{
clear();
type = TYPE_ITEM_BLOCK;
this->pointer = &item_block;
this->pointer = item_block;
}
void Val::set_pointer_to(bool * val)
{
// IMPLEMENT ME
}
void Val::set_pointer_to(char * val)
{
clear();
type = TYPE_CHAR;
pointer = val;
}
void Val::set_pointer_to(wchar_t * val)
{
clear();
type = TYPE_WCHAR;
pointer = val;
}
void Val::set_pointer_to(short * val)
{
clear();
type = TYPE_SHORT;
pointer = val;
}
void Val::set_pointer_to(int * val)
{
clear();
type = TYPE_INT;
pointer = val;
}
void Val::set_pointer_to(long * val)
{
clear();
type = TYPE_LONG;
pointer = val;
}
void Val::set_pointer_to(long long * val)
{
clear();
type = TYPE_LONG_LONG;
pointer = val;
}
void Val::set_pointer_to(unsigned char * val)
{
clear();
type = TYPE_UNSIGNED_CHAR;
pointer = val;
}
void Val::set_pointer_to(unsigned short * val)
{
clear();
type = TYPE_UNSIGNED_SHORT;
pointer = val;
}
void Val::set_pointer_to(unsigned int * val)
{
clear();
type = TYPE_UNSIGNED_INT;
pointer = val;
}
void Val::set_pointer_to(unsigned long * val)
{
clear();
type = TYPE_UNSIGNED_LONG;
pointer = val;
}
void Val::set_pointer_to(unsigned long long * val)
{
clear();
type = TYPE_UNSIGNED_LONG_LONG;
pointer = val;
}
void Val::set_pointer_to(float * val)
{
// IMPLEMENTME
}
void Val::set_pointer_to(double * val)
{
// IMPLEMENTME
}
void Val::set_pointer_to(long double * val)
{
// IMPLEMENTME
}
void Val::set_pointer_to(std::string * val)
{
// IMPLEMENTME
}
void Val::set_pointer_to(std::wstring * val)
{
// IMPLEMENTME
}
// bool Val::is_equal(const char * str) const
// {
@@ -1182,6 +1290,73 @@ Val & Val::operator=(bool res)
}
void Val::put_pod_type_to_stream()
{
if( pointer )
{
if( type == Type::TYPE_CHAR )
{
char * val = reinterpret_cast<char*>(pointer);
(*output_stream) << *val;
}
if( type == Type::TYPE_SHORT )
{
short * val = reinterpret_cast<short*>(pointer);
(*output_stream) << *val;
}
if( type == Type::TYPE_INT )
{
int * val = reinterpret_cast<int*>(pointer);
(*output_stream) << *val;
}
if( type == Type::TYPE_LONG )
{
long * val = reinterpret_cast<long*>(pointer);
(*output_stream) << *val;
}
if( type == Type::TYPE_LONG_LONG )
{
long long * val = reinterpret_cast<long long*>(pointer);
(*output_stream) << *val;
}
if( type == Type::TYPE_UNSIGNED_CHAR )
{
unsigned char * val = reinterpret_cast<unsigned char*>(pointer);
(*output_stream) << *val;
}
if( type == Type::TYPE_UNSIGNED_SHORT )
{
unsigned short * val = reinterpret_cast<unsigned short*>(pointer);
(*output_stream) << *val;
}
if( type == Type::TYPE_UNSIGNED_INT )
{
unsigned int * val = reinterpret_cast<unsigned int*>(pointer);
(*output_stream) << *val;
}
if( type == Type::TYPE_UNSIGNED_LONG )
{
unsigned long * val = reinterpret_cast<unsigned long*>(pointer);
(*output_stream) << *val;
}
if( type == Type::TYPE_UNSIGNED_LONG_LONG )
{
unsigned long long * val = reinterpret_cast<unsigned long long*>(pointer);
(*output_stream) << *val;
}
}
}
} // namespace Ezc

107
src/val.h
View File

@@ -79,6 +79,17 @@ public:
TYPE_SPACE,
TYPE_OUTPUT_STREAM,
TYPE_ITEM_BLOCK,
TYPE_CHAR,
TYPE_WCHAR, //
TYPE_SHORT,
TYPE_INT,
TYPE_LONG,
TYPE_LONG_LONG,
TYPE_UNSIGNED_CHAR,
TYPE_UNSIGNED_SHORT,
TYPE_UNSIGNED_INT,
TYPE_UNSIGNED_LONG,
TYPE_UNSIGNED_LONG_LONG,
};
@@ -97,12 +108,13 @@ public:
bool has_object();
bool has_model_object();
bool has_pod_type();
void clear();
void clear_childs();
bool to_bool() const;
bool to_bool(bool is_loop_context = false) const;
void set(const char * str);
@@ -124,33 +136,53 @@ public:
void set(double val);
void set(long double val);
void set(pt::Stream & str);
void set(UserFunction user_function);
void set(pt::Date & date);
void set(morm::Model & model);
void set(morm::ModelContainerWrapper & model_container_wrapper);
void set_pointer_to(pt::Stream * str);
void set_pointer_to(UserFunction user_function);
void set_pointer_to(pt::Date * date);
void set_pointer_to(morm::Model * model);
void set_pointer_to(morm::ModelContainerWrapper * model_container_wrapper);
template<typename ModelType>
void set(std::vector<ModelType> & model_container);
void set_pointer_to(std::vector<ModelType> * model_container);
template<typename ModelType>
void set(std::list<ModelType> & model_container);
void set_pointer_to(std::list<ModelType> * model_container);
template<typename ModelType>
void set(std::vector<ModelType*> & model_container);
void set_pointer_to(std::vector<ModelType*> * model_container);
template<typename ModelType>
void set(std::list<ModelType*> & model_container);
void set_pointer_to(std::list<ModelType*> * model_container);
void set(morm::SpaceWrapper & space_wrapper);
void set(pt::Space & space, bool create_wrapper = true);
void set_pointer_to(morm::SpaceWrapper * space_wrapper);
void set_pointer_to(pt::Space * space, bool create_wrapper = true);
//void set(Val & val);
void set_pointer_to(Item * item_block);
void set_pointer_to(bool * val);
void set_pointer_to(char * val);
void set_pointer_to(wchar_t * val);
void set_pointer_to(short * val);
void set_pointer_to(int * val);
void set_pointer_to(long * val);
void set_pointer_to(long long * val);
void set_pointer_to(unsigned char * val);
void set_pointer_to(unsigned short * val);
void set_pointer_to(unsigned int * val);
void set_pointer_to(unsigned long * val);
void set_pointer_to(unsigned long long * val);
void set_pointer_to(float * val);
void set_pointer_to(double * val);
void set_pointer_to(long double * val);
void set_pointer_to(std::string * val);
void set_pointer_to(std::wstring * val);
void set(Val & val);
void set(Item & item_block);
// bool is_equal(const char * str) const;
// bool is_equal(const wchar_t * str) const;
@@ -184,6 +216,7 @@ public:
Val & operator=(bool res);
void put_pod_type_to_stream();
Type type;
pt::Space space_local;
@@ -241,7 +274,7 @@ private:
bool to_bool_stream() const;
bool to_bool_space() const;
bool to_bool_space_wrapper() const;
bool to_bool_model_container_wrapper() const;
bool to_bool_model_container_wrapper(bool is_loop_context) const;
void serialize_stream_to(pt::Stream & str);
void serialize_date_to(pt::Stream & str);
@@ -269,9 +302,47 @@ private:
};
template<typename ModelType>
void Val::set_pointer_to(std::vector<ModelType> * model_container)
{
clear();
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->pointer = new morm::ModelWrapperVector<ModelType>(model_container);
}
template<typename ModelType>
void Val::set_pointer_to(std::list<ModelType> * model_container)
{
clear();
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->pointer = new morm::ModelWrapperList<ModelType>(model_container);
}
template<typename ModelType>
void Val::set_pointer_to(std::vector<ModelType*> * model_container)
{
clear();
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->pointer = new morm::ModelWrapperVectorPointer<ModelType>(model_container);
}
template<typename ModelType>
void Val::set_pointer_to(std::list<ModelType*> * model_container)
{
clear();
type = TYPE_MODEL_CONTAINER_WRAPPER;
this->pointer = new morm::ModelWrapperListPointer<ModelType>(model_container);
}
typedef std::map<std::wstring, Val> Vals;
} // namespace Ezc
#endif