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

.templates/.clangd

@@ -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]

src/generator.h

@@ -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....
+		Val * val = pmodels->Find(find_helper.fun_name);
-		morm::Wrapper * m = pmodels->Find(find_helper.fun_name);
 
-		if( m )
+		if( val )
 		{
-			if( m->model )
+			find_helper.set_base_val(val);
-			{
+			found = true;
-				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;
-			}
 		}
 	}
 
@@ -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
+				Val val = model->get_ezc_val(nullptr, field.c_str());
-				// return a Val instead of a Wrapper
-				morm::Wrapper new_wrapper = model->get_wrapper(nullptr, field.c_str());
 
-				if( new_wrapper.has_object() )
+				if( val.has_object() )
 				{
-					Val child = WrapperToVal(new_wrapper);
+					child_wrapper = find_helper.currentval->add_child(field, val);
-
-					if( child.type != Val::TYPE_VOID )
-						child_wrapper = find_helper.currentval->add_child(field, child);
 				}
 			}
 		}
@@ -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?
+		pt::Stream * tmp_stream = main_stream->new_empty();
-		find_helper.parameters[i].set_output_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() )

src/models.cpp

@@ -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;
+	Val val;
-	wrapper.model = &model;
+	val.set_pointer_to(&model);
-	models_map[name] = wrapper;
+	models_map[name] = val;
 }
 
 
 void Models::Add(const std::wstring & name, morm::Model * model)
 {
-	morm::Wrapper wrapper;
+	Val val;
-	wrapper.model = model;
+	val.set_pointer_to(model);
-	models_map[name] = wrapper;
+	models_map[name] = val;
 }
 
 
 void Models::Add(const std::wstring & name, pt::Space & space)
 {
-	morm::Wrapper wrapper;
+	Val val;
-	wrapper.space_wrapper = new morm::SpaceWrapper(&space);
+	val.set_pointer_to(new morm::SpaceWrapper(&space));
-	models_map[name] = wrapper;
+	models_map[name] = val;
 }
 
 
 void Models::Add(const std::wstring & name, pt::Space * space)
 {
-	morm::Wrapper wrapper;
+	Val val;
-	wrapper.space_wrapper = new morm::SpaceWrapper(space);
+	val.set_pointer_to(new morm::SpaceWrapper(space));
-	models_map[name] = wrapper;
+	models_map[name] = val;
 }
 
 
 void Models::Add(const std::wstring & name, pt::Date & date)
 {
-	morm::Wrapper wrapper;
+	Val val;
-	wrapper.date = &date;
+	val.set_pointer_to(&date);
-	models_map[name] = wrapper;
+	models_map[name] = val;
 }
 
 
 void Models::Add(const std::wstring & name, pt::Date * date)
 {
-	morm::Wrapper wrapper;
+	Val val;
-	wrapper.date = date;
+	val.set_pointer_to(date);
-	models_map[name] = wrapper;
+	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);
 

src/models.h

@@ -37,8 +37,7 @@
 
 #ifdef EZC_HAS_MORM_LIBRARY
 
-#include "wrapper.h"
+#include "val.h"
-#include "env.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;
+		Val val;
-		wrapper.model_container_wrapper = new morm::ModelWrapperVector<VectorType>(&container);
+		val.set_pointer_to(new morm::ModelWrapperVector<VectorType>(&container));
-		models_map[name] = wrapper;
+		models_map[name] = val;
 	}
 
 	template<typename VectorType>
 	void Add(const std::wstring & name, std::vector<VectorType> * container)
 	{
-		morm::Wrapper wrapper;
+		Val val;
-		wrapper.model_container_wrapper = new morm::ModelWrapperVector<VectorType>(container);
+		val.set_pointer_to(new morm::ModelWrapperVector<VectorType>(container));
-		models_map[name] = wrapper;
+		models_map[name] = val;
 	}
 
 	template<typename VectorType>
 	void Add(const std::wstring & name, std::vector<VectorType*> & container)
 	{
-		morm::Wrapper wrapper;
+		Val val;
-		wrapper.model_container_wrapper = new morm::ModelWrapperVectorPointer<VectorType>(&container);
+		val.set_pointer_to(new morm::ModelWrapperVectorPointer<VectorType>(&container));
-		models_map[name] = wrapper;
+		models_map[name] = val;
 	}
 
 	template<typename VectorType>
 	void Add(const std::wstring & name, std::vector<VectorType*> * container)
 	{
-		morm::Wrapper wrapper;
+		Val val;
-		wrapper.model_container_wrapper = new morm::ModelWrapperVectorPointer<VectorType>(container);
+		val.set_pointer_to(new morm::ModelWrapperVectorPointer<VectorType>(container));
-		models_map[name] = wrapper;
+		models_map[name] = val;
 	}
 
 	template<typename ListType>
 	void Add(const std::wstring & name, std::list<ListType> & container)
 	{
-		morm::Wrapper wrapper;
+		Val val;
-		wrapper.model_container_wrapper = new morm::ModelWrapperList<ListType>(&container);
+		val.set_pointer_to(new morm::ModelWrapperList<ListType>(&container));
-		models_map[name] = wrapper;
+		models_map[name] = val;
 	}
 
 	template<typename ListType>
 	void Add(const std::wstring & name, std::list<ListType> * container)
 	{
-		morm::Wrapper wrapper;
+		Val val;
-		wrapper.model_container_wrapper = new morm::ModelWrapperList<ListType>(container);
+		val.set_pointer_to(new morm::ModelWrapperList<ListType>(container));
-		models_map[name] = wrapper;
+		models_map[name] = val;
 	}
 
 	template<typename ListType>
 	void Add(const std::wstring & name, std::list<ListType*> & container)
 	{
-		morm::Wrapper wrapper;
+		Val val;
-		wrapper.model_container_wrapper = new morm::ModelWrapperListPointer<ListType>(&container);
+		val.set_pointer_to(new morm::ModelWrapperListPointer<ListType>(&container));
-		models_map[name] = wrapper;
+		models_map[name] = val;
 	}
 
 	template<typename ListType>
 	void Add(const std::wstring & name, std::list<ListType*> * container)
 	{
-		morm::Wrapper wrapper;
+		Val val;
-		wrapper.model_container_wrapper = new morm::ModelWrapperListPointer<ListType>(container);
+		val.set_pointer_to(new morm::ModelWrapperListPointer<ListType>(container));
-		models_map[name] = wrapper;
+		models_map[name] = val;
 	}
 
-	morm::Wrapper * Find(const std::wstring & name);
+	Val * Find(const std::wstring & name);
 	ModelsMap & GetMap();
 	void Clear();
 

src/val.cpp

@@ -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;
+	this->pointer = model_container_wrapper;
-	model_container_wrapper.increment_reference_counter();
+	model_container_wrapper->increment_reference_counter();
 }
 
 
-template<typename ModelType>
+void Val::set_pointer_to(morm::SpaceWrapper * space_wrapper)
-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)
 {
 	clear();
 	type = TYPE_SPACE_WRAPPER;
-	this->pointer = &space_wrapper;
+	this->pointer = space_wrapper;
-	space_wrapper.increment_reference_counter();
+	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)
+// void Val::set(Val & val)
-{
+// {
-	clear();
+// 	clear();
 
-	type = val.type;
+// 	type = val.type;
-	pointer = val.pointer;
+// 	pointer = val.pointer;
 
-	increment_model_container_wrapper_ref();
+// 	increment_model_container_wrapper_ref();
-	increment_space_wrapper_ref();
+// 	increment_space_wrapper_ref();
 
-	// switch(val.type)
+// 	// switch(val.type)
-	// {
+// 	// {
-	// case TYPE_VOID:
+// 	// case TYPE_VOID:
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_SPACE_LOCAL:
+// 	// case TYPE_SPACE_LOCAL:
-	// 	space_local = val.space_local;
+// 	// 	space_local = val.space_local;
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_STREAM:
+// 	// case TYPE_STREAM:
-	// 	stream = val.stream;
+// 	// 	stream = val.stream;
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_FUNCTION:
+// 	// case TYPE_FUNCTION:
-	// 	user_function = val.user_function;
+// 	// 	user_function = val.user_function;
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_DATE:
+// 	// case TYPE_DATE:
-	// 	date = val.date;
+// 	// 	date = val.date;
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_MODEL:
+// 	// case TYPE_MODEL:
-	// 	model = val.model;
+// 	// 	model = val.model;
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_SPACE_WRAPPER:
+// 	// case TYPE_SPACE_WRAPPER:
-	// 	space_wrapper = val.space_wrapper;
+// 	// 	space_wrapper = val.space_wrapper;
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_SPACE:
+// 	// case TYPE_SPACE:
-	// 	space = val.space;
+// 	// 	space = val.space;
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_MODEL_CONTAINER_WRAPPER:
+// 	// case TYPE_MODEL_CONTAINER_WRAPPER:
-	// 	model_container_wrapper = val.model_container_wrapper;
+// 	// 	model_container_wrapper = val.model_container_wrapper;
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_OUTPUT_STREAM:
+// 	// case TYPE_OUTPUT_STREAM:
-	// 	output_stream = val.output_stream;
+// 	// 	output_stream = val.output_stream;
-	// 	break;
+// 	// 	break;
 
-	// case TYPE_ITEM_BLOCK:
+// 	// case TYPE_ITEM_BLOCK:
-	// 	item_block = val.item_block;
+// 	// 	item_block = val.item_block;
-	// 	break;
+// 	// 	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
 

src/val.h

@@ -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_pointer_to(pt::Stream * str);
-
+	void set_pointer_to(UserFunction user_function);
-	void set(pt::Date & date);
+	void set_pointer_to(pt::Date * date);
-
+	void set_pointer_to(morm::Model * model);
-	void set(morm::Model & model);
+	void set_pointer_to(morm::ModelContainerWrapper * model_container_wrapper);
-
-	void set(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_pointer_to(morm::SpaceWrapper * space_wrapper);
-	void set(pt::Space & space, bool create_wrapper = true);
+	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