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

2025-01-29 17:54:56 +01:00 · 2025-01-15 18:30:30 +01:00 · 2025-01-12 16:58:15 +01:00 · 2024-12-13 15:48:43 +01:00 · 2024-12-11 17:30:13 +01:00 · 2024-12-06 17:07:58 +01:00
4 changed files with 152 additions and 135 deletions
--- a/src/model.cpp
+++ b/src/model.cpp
@@ -282,11 +282,13 @@ Model * Model::get_model(const wchar_t * db_field_name, const wchar_t * flat_fie
 }


-Wrapper Model::get_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name)
+#ifdef MORM_HAS_EZC_LIBRARY
+
+Ezc::Val Model::get_ezc_val(const wchar_t * db_field_name, const wchar_t * flat_field_name)
 {
 	ModelEnv model_env_local;
 	model_env = &model_env_local;
-	model_env->model_work_mode = MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER;
+	model_env->model_work_mode = MORM_MODEL_WORK_MODE_GET_EZC_VAL;
 	model_env->db_field_name = db_field_name;
 	model_env->flat_field_name = flat_field_name;
 	model_env->model = this;
@@ -302,10 +304,12 @@ Wrapper Model::get_wrapper(const wchar_t * db_field_name, const wchar_t * flat_f
 	}

 	model_env = nullptr;
-	return model_env_local.wrapper;
+	return model_env_local.ezc_val;
 }


+#endif
+

 bool Model::get_raw_value(const wchar_t * db_field_name, const wchar_t * flat_field_name, pt::Stream & stream, bool clear_stream)
 {
@@ -1659,15 +1663,16 @@ void Model::field_model(const wchar_t * db_field_name, const wchar_t * flat_fiel
 			}
 		}

-		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
+	#ifdef MORM_HAS_EZC_LIBRARY
+		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
 		{
 			if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-				(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) &&
-				!model_env->wrapper.model )
+				(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 			{
-				model_env->wrapper.model = &field_model;
+				model_env->ezc_val.set_pointer_to(&field_model);
 			}
 		}
+	#endif

 		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_PROPAGATE_SAVE_STATUS )
 		{
@@ -1952,7 +1957,7 @@ void Model::field_member(

 			if( plog )
 			{
-				(*plog) << pt::Log::log1 << "Morm:: getters and setters cannot be used as a primary key" << pt::Log::logend;
+				(*plog) << pt::Log::log1 << "Morm: getters and setters cannot be used as a primary key" << pt::Log::logend;
 			}
 		}

@@ -2108,6 +2113,13 @@ bool Model::convert_to_bool(const pt::Space & space)
 }


+void Model::put_bool_to_stream(bool val, pt::Stream & str)
+{
+	if( val )
+		str << L"true";
+	else
+		str << L"false";
+}


 } // namespace
--- a/src/model.h
+++ b/src/model.h
@@ -51,7 +51,7 @@
 #include "wrapper.h"

 #ifdef MORM_HAS_EZC_LIBRARY
-#include "funinfo.h"
+#include "env.h"
 #endif


@@ -81,15 +81,13 @@

 #ifdef MORM_HAS_EZC_LIBRARY
 #define MORM_MODEL_MEMBER_FIELD_EZC(ClassName) \
-	template<typename FunInfoStreamType> \
-	void field(const wchar_t * field_name, void (ClassName::*method)(Ezc::FunInfo<FunInfoStreamType> &), const morm::FT & field_type = morm::FT::default_type) \
+	void field(const wchar_t * field_name, void (ClassName::*method)(Ezc::Env &), const morm::FT & field_type = morm::FT::default_type) \
 	{ \
 		field(field_name, field_name, method, field_type); \
 	} \
-	template<typename FunInfoStreamType> \
-	void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (ClassName::*method)(Ezc::FunInfo<FunInfoStreamType> &), const morm::FT & field_type = morm::FT::default_type) \
+	void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (ClassName::*method)(Ezc::Env &), const morm::FT & field_type = morm::FT::default_type) \
 	{ \
-		typedef void (Model::*ModelMember)(Ezc::FunInfo<FunInfoStreamType> &); \
+		typedef void (Model::*ModelMember)(Ezc::Env &); \
 		ModelMember model_member = static_cast<ModelMember>(method); \
 		field_member_ezc(db_field_name, flat_field_name, model_member, field_type); \
 	} \
@@ -112,16 +110,6 @@
 		typedef bool (Model::*ModelMember)() const; \
 		ModelMember model_member = static_cast<ModelMember>(method); \
 		field_member_ezc(db_field_name, flat_field_name, model_member, field_type); \
-	} \
-	void field(const wchar_t * field_name, void (ClassName::*method)(morm::Wrapper &), const morm::FT & field_type = morm::FT::default_type) \
-	{ \
-		field(field_name, field_name, method, field_type); \
-	} \
-	void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (ClassName::*method)(morm::Wrapper &), const morm::FT & field_type = morm::FT::default_type) \
-	{ \
-		typedef void (Model::*ModelMember)(morm::Wrapper &); \
-		ModelMember model_member = static_cast<ModelMember>(method); \
-		field_member_ezc(db_field_name, flat_field_name, model_member, field_type); \
 	}
 #endif

@@ -260,17 +248,19 @@ public:


 	Model * get_model(const wchar_t * db_field_name, const wchar_t * flat_field_name);
-	Wrapper get_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name);
+

 	bool get_raw_value(const wchar_t * db_field_name, const wchar_t * flat_field_name, pt::Stream & stream, bool clear_stream = true);
 	bool get_raw_value(const wchar_t * db_field_name, const wchar_t * flat_field_name, ModelData * model_data, pt::Stream & stream, bool clear_stream = true);


-
 #ifdef MORM_HAS_EZC_LIBRARY
-	template<typename FunInfoStreamType>
+
+	Ezc::Val get_ezc_val(const wchar_t * db_field_name, const wchar_t * flat_field_name);
+
+	/*
 	bool get_raw_value(const wchar_t * db_field_name, const wchar_t * flat_field_name, ModelData * model_data,
-						 Ezc::FunInfo<FunInfoStreamType> & fun_info, pt::Stream & stream, bool clear_stream = true)
+						 Ezc::Env & ezc_env, pt::Stream & stream, bool clear_stream = true)
 	{
 		if( clear_stream )
 		{
@@ -286,14 +276,12 @@ public:
 		model_env->flat_field_name = flat_field_name;
 		model_env->model_data = model_data;
 		model_env->stream = &stream;
-		model_env->ezc_fun_info = &fun_info;
-		model_env->ezc_fun_info_typeinfo = &typeid(fun_info);
+		model_env->ezc_env = &ezc_env;
 		model_env->model = this;

 		try
 		{
 			fields();
-			fun_info.res = model_env->ezc_fun_result;
 		}
 		catch(...)
 		{
@@ -304,6 +292,8 @@ public:
 		model_env = nullptr;
 		return model_env_local.was_field_found;
 	}
+	*/
+
 #endif


@@ -801,12 +791,26 @@ protected:
 			}

 		#ifdef MORM_HAS_EZC_LIBRARY
-			model_env->ezc_fun_result = convert_to_bool(field_value);
+			//model_env->ezc_fun_result = convert_to_bool(field_value);
 		#endif
 		}
 	}


+#ifdef MORM_HAS_EZC_LIBRARY
+	template<typename FieldValue>
+	void field_generic_get_ezc_val(const wchar_t * db_field_name, const wchar_t * flat_field_name, FieldValue & field_value, const FT & field_type)
+	{
+		if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
+			(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
+		{
+			model_env->was_field_found = true;
+			model_env->ezc_val.set_pointer_to(&field_value);
+		}
+	}
+#endif
+
+
 	template<typename FieldValue>
 	void field_generic(const wchar_t * db_field_name, const wchar_t * flat_field_name, FieldValue & field_value, const FT & field_type)
 	{
@@ -851,6 +855,13 @@ protected:
 			{
 				field_generic_put_raw_value_to_stream(db_field_name, flat_field_name, field_value, field_type);
 			}
+
+		#ifdef MORM_HAS_EZC_LIBRARY
+			if( get_work_mode() == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
+			{
+				field_generic_get_ezc_val(db_field_name, flat_field_name, field_value, field_type);
+			}
+		#endif
 		}
 	}

@@ -859,16 +870,17 @@ protected:
 	{
 		if( model_connector && model_env )
 		{
-			if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
+		#ifdef MORM_HAS_EZC_LIBRARY
+			if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
 			{
 				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) &&
-					!model_env->wrapper.date )
+					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 				{
-					model_env->wrapper.date = &field_value;
+					model_env->ezc_val.set_pointer_to(&field_value);
 				}
 			}
 			else
+		#endif
 			{
 				field_generic(db_field_name, flat_field_name, field_value, field_type);
 			}
@@ -880,16 +892,17 @@ protected:
 	{
 		if( model_connector && model_env )
 		{
-			if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
+		#ifdef MORM_HAS_EZC_LIBRARY
+			if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
 			{
 				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) &&
-					!model_env->wrapper.space_wrapper )
+					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 				{
-					model_env->wrapper.space_wrapper = new SpaceWrapper(&field_value);
+					model_env->ezc_val.set_pointer_to(new SpaceWrapper(&field_value));
 				}
 			}
 			else
+		#endif
 			{
 				field_generic(db_field_name, flat_field_name, field_value, field_type);
 			}
@@ -938,50 +951,54 @@ protected:


 #ifdef MORM_HAS_EZC_LIBRARY
-	template<typename FunInfoStreamType>
-	void field_member_ezc(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (Model::*method)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type)
+
+	void field_member_ezc(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (Model::*method)(Ezc::Env &), const FT & field_type)
 	{
-		if( model_connector && model_env && model_env->ezc_fun_info && model_env->ezc_fun_info_typeinfo && model_env->model )
+		if( model_connector && model_env && model_env->model )
 		{
+
 			if( field_type.is_primary_key() )
 			{
 				pt::Log * plog = model_connector->get_logger();

 				if( plog )
 				{
-					(*plog) << pt::Log::log1 << "Morm:: an ezc method cannot be used as a primary key" << pt::Log::logend;
+					(*plog) << pt::Log::log1 << "Morm: an ezc method cannot be used as a primary key" << pt::Log::logend;
 				}
 			}

+
 			if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM )
 			{
-				field_member_ezc_put_field_value_to_stream(db_field_name, flat_field_name, method, field_type);
-			}
-		}
-	}
-
-
-	template<typename FunInfoStreamType>
-	void field_member_ezc_put_field_value_to_stream(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (Model::*method)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type)
-	{
-		if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-			(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
-		{
-			model_env->was_field_found = true;
-
-			if( typeid(Ezc::FunInfo<FunInfoStreamType>) == *model_env->ezc_fun_info_typeinfo )
-			{
-				Ezc::FunInfo<FunInfoStreamType> * ezc_fun_info = reinterpret_cast<Ezc::FunInfo<FunInfoStreamType>*>(model_env->ezc_fun_info);
-				(model_env->model->*method)(*ezc_fun_info);
-				model_env->ezc_fun_result = ezc_fun_info->res; // ezc_fun_info->res is overwritten in get_raw_value() after fields() method call so we have to remember it in model_env
-			}
-			else
-			{
-				pt::Log * plog = model_connector->get_logger();
-
-				if( plog )
+				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
+					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 				{
-					(*plog) << pt::Log::log2 << "Morm: incorrect method type for field: " << flat_field_name << pt::Log::logend;
+					model_env->was_field_found = true;
+
+					if( model_env->ezc_env )
+					{
+						(model_env->model->*method)(*model_env->ezc_env);
+						// may if the method evaluates to a POD type then we should put such value to the stream?
+					}
+					else
+					{
+						pt::Log * plog = model_connector->get_logger();
+
+						if( plog )
+						{
+							(*plog) << pt::Log::log1 << "Morm: this method requires an Ezc::Env object"; // put a field name?
+						}
+					}
+				}
+			}
+
+			if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
+			{
+				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
+					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
+				{
+					model_env->was_field_found = true;
+					model_env->ezc_val.set_pointer_to(model_env->model, method);
 				}
 			}
 		}
@@ -998,17 +1015,24 @@ protected:

 				if( plog )
 				{
-					(*plog) << pt::Log::log1 << "Morm:: an ezc method cannot be used as a primary key" << pt::Log::logend;
+					(*plog) << pt::Log::log1 << "Morm: an ezc method cannot be used as a primary key" << pt::Log::logend;
 				}
 			}

-			if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM )
+			if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
+				(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 			{
-				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
+				if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM )
 				{
 					model_env->was_field_found = true;
-					model_env->ezc_fun_result = (model_env->model->*method)();
+					bool result = (model_env->model->*method)();
+					put_bool_to_stream(result, *model_env->stream);
+				}
+
+				if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
+				{
+					model_env->was_field_found = true;
+					model_env->ezc_val.set_pointer_to(model_env->model, method);
 				}
 			}
 		}
@@ -1025,48 +1049,30 @@ protected:

 				if( plog )
 				{
-					(*plog) << pt::Log::log1 << "Morm:: an ezc method cannot be used as a primary key" << pt::Log::logend;
+					(*plog) << pt::Log::log1 << "Morm: an ezc method cannot be used as a primary key" << pt::Log::logend;
 				}
 			}

-			if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM )
+			if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
+				(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 			{
-				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
+				if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM )
 				{
 					model_env->was_field_found = true;
-					model_env->ezc_fun_result = (model_env->model->*method)();
+					bool result = (model_env->model->*method)();
+					put_bool_to_stream(result, *model_env->stream);
+				}
+
+				if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
+				{
+					model_env->was_field_found = true;
+					model_env->ezc_val.set_pointer_to(model_env->model, method);
 				}
 			}
 		}
 	}


-	void field_member_ezc(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (Model::*method)(Wrapper & wrapper), const FT & field_type)
-	{
-		if( model_connector && model_env && model_env->model )
-		{
-			if( field_type.is_primary_key() )
-			{
-				pt::Log * plog = model_connector->get_logger();
-
-				if( plog )
-				{
-					(*plog) << pt::Log::log1 << "Morm:: an ezc method cannot be used as a primary key" << pt::Log::logend;
-				}
-			}
-
-			if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
-			{
-				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
-				{
-					(model_env->model->*method)(model_env->wrapper);
-				}
-			}
-		}
-	}
-
 #endif


@@ -1270,19 +1276,20 @@ protected:
 	{
 		ContainerItemType * item_type_null_pointer = nullptr;

-		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
+	#ifdef MORM_HAS_EZC_LIBRARY
+		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
 		{
 			if constexpr (std::is_base_of<Model, ContainerItemType>())
 			{
 				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) &&
-					!model_env->wrapper.model_container_wrapper )
+					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 				{
-					model_env->wrapper.model_container_wrapper = new ModelWrapperVector(&field_value);
+					model_env->ezc_val.set_pointer_to(new ModelWrapperVector(&field_value));
 				}
 			}
 		}
 		else
+	#endif
 		{
 			ContainerItemType * pointer = nullptr;
 			field_list_generic(db_field_name, flat_field_name, field_value, item_type_null_pointer, field_type, pointer);
@@ -1295,19 +1302,20 @@ protected:
 	{
 		ContainerItemType * item_type_null_pointer = nullptr;

-		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
+	#ifdef MORM_HAS_EZC_LIBRARY
+		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
 		{
 			if constexpr (std::is_base_of<Model, ContainerItemType>())
 			{
 				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) &&
-					!model_env->wrapper.model_container_wrapper )
+					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 				{
-					model_env->wrapper.model_container_wrapper = new ModelWrapperList(&field_value);
+					model_env->ezc_val.set_pointer_to(new ModelWrapperList(&field_value));
 				}
 			}
 		}
 		else
+	#endif
 		{
 			ContainerItemType * pointer = nullptr;
 			field_list_generic(db_field_name, flat_field_name, field_value, item_type_null_pointer, field_type, pointer);
@@ -1320,19 +1328,20 @@ protected:
 	{
 		ContainerItemType * item_type_null_pointer = nullptr;

-		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
+	#ifdef MORM_HAS_EZC_LIBRARY
+		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
 		{
 			if constexpr (std::is_base_of<Model, ContainerItemType>())
 			{
 				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) &&
-					!model_env->wrapper.model_container_wrapper )
+					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 				{
-					model_env->wrapper.model_container_wrapper = new ModelWrapperVectorPointer(&field_value);
+					model_env->ezc_val.set_pointer_to(new ModelWrapperVectorPointer(&field_value));
 				}
 			}
 		}
 		else
+	#endif
 		{
 			void * pointer = nullptr;
 			field_list_generic(db_field_name, flat_field_name, field_value, item_type_null_pointer, field_type, pointer);
@@ -1345,19 +1354,20 @@ protected:
 	{
 		ContainerItemType * item_type_null_pointer = nullptr;

-		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
+	#ifdef MORM_HAS_EZC_LIBRARY
+		if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_EZC_VAL )
 		{
 			if constexpr (std::is_base_of<Model, ContainerItemType>())
 			{
 				if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
-					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) &&
-					!model_env->wrapper.model_container_wrapper )
+					(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
 				{
-					model_env->wrapper.model_container_wrapper = new ModelWrapperListPointer(&field_value);
+					model_env->ezc_val.set_pointer_to(new ModelWrapperListPointer(&field_value));
 				}
 			}
 		}
 		else
+	#endif
 		{
 			void * pointer = nullptr;
 			field_list_generic(db_field_name, flat_field_name, field_value, item_type_null_pointer, field_type, pointer);
@@ -1672,6 +1682,7 @@ protected:
 	virtual bool convert_to_bool(const pt::Stream & val);
 	virtual bool convert_to_bool(const pt::Space & space);

+	virtual void put_bool_to_stream(bool val, pt::Stream & str);

 	template<typename ModelClass> friend class Finder;
 	template<typename ModelClass> friend class Cursor;
--- a/src/modelenv.h
+++ b/src/modelenv.h
@@ -40,7 +40,7 @@
 #include "finderhelper.h"
 #include "fieldvaluehelper.h"
 #include "morm_types.h"
-#include "wrapper.h"
+#include "val.h"
 #include "select.h"


@@ -93,13 +93,11 @@ public:
 	Model * child_model;
 	pt::Stream * stream;
 	bool was_field_found; // used only in MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM
-	Wrapper wrapper;


 	#ifdef MORM_HAS_EZC_LIBRARY
-	void * ezc_fun_info;
-	bool ezc_fun_result;
-	const std::type_info * ezc_fun_info_typeinfo;
+	Ezc::Val ezc_val;
+	Ezc::Env * ezc_env;
 	#endif

 	bool status;
@@ -145,7 +143,6 @@ public:
 		child_model = e.child_model;
 		stream = e.stream;
 		was_field_found = e.was_field_found;
-		wrapper = e.wrapper;
 		status = e.status;
 		has_autogenerated_select = e.has_autogenerated_select;
 		select_flags = e.select_flags;
@@ -156,9 +153,8 @@ public:
 		add_postfix_percent = e.add_postfix_percent;

 	#ifdef MORM_HAS_EZC_LIBRARY
-		ezc_fun_info = e.ezc_fun_info;
-		ezc_fun_result = e.ezc_fun_result;
-		ezc_fun_info_typeinfo = e.ezc_fun_info_typeinfo;
+		ezc_val = e.ezc_val;
+		ezc_env = e.ezc_env;
 	#endif

 		// schema_name and table_name don't have to be copied
@@ -204,7 +200,6 @@ public:
 		child_model = nullptr;
 		stream = nullptr;
 		was_field_found = false;
-		wrapper.clear();
 		status = true;
 		has_autogenerated_select = false;
 		select_flags = Select::default_type;
@@ -215,9 +210,8 @@ public:
 		add_postfix_percent = false;

 	#ifdef MORM_HAS_EZC_LIBRARY
-		ezc_fun_info = nullptr;
-		ezc_fun_result = false;
-		ezc_fun_info_typeinfo = nullptr;
+		ezc_val.clear();
+		ezc_env = nullptr;
 	#endif
 	}

--- a/src/morm_types.h
+++ b/src/morm_types.h
@@ -46,7 +46,7 @@
 #define MORM_MODEL_WORK_MODE_ITERATE_PRIMARY_KEY_VALUES 8
 #define MORM_MODEL_WORK_MODE_SET_FIELD_VALUE 9
 #define MORM_MODEL_WORK_MODE_GET_FIELD_MODEL 10
-#define MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER 11
+#define MORM_MODEL_WORK_MODE_GET_EZC_VAL 11
 #define MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM 12
 #define MORM_MODEL_WORK_MODE_PROPAGATE_SAVE_STATUS 13
Author	SHA1	Message	Date
Tomasz Sowa	0a69d9998e	WIP: add a Val struct as an input/output when calling a function	2025-01-29 17:54:56 +01:00
Tomasz Sowa	aaaf38cd79	WIP: add a Val struct as an input/output when calling a function	2025-01-15 18:30:30 +01:00
Tomasz Sowa	e2cfedda6c	WIP: add a Val struct as an input/output when calling a function	2025-01-12 16:58:15 +01:00
Tomasz Sowa	0ceb2d9c75	WIP: add a Val struct as an input/output when calling a function	2024-12-13 15:48:43 +01:00
Tomasz Sowa	04144e81be	WIP: add a Val struct as an input/output when calling a function	2024-12-11 17:30:13 +01:00
Tomasz Sowa	4f8ef38002	use Ezc::Env instead of Ezc::FunInfo Ezc::FunInfo has been renamed to Ezc::Env in the pikotools library.	2024-12-06 17:07:58 +01:00
Tomasz Sowa	af242dfba6	WIP: use pt::Stream instead of a template argument	2024-12-05 17:48:50 +01:00