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

src/generator.h

@@ -194,6 +194,11 @@ private:
 			return (field_index + 1 == fields.size());
 		}
 
+		bool is_last_field()
+		{
+			return (field_index + 1) == fields.size();
+		}
+
 		//std::wstring * fun_name;
 
 		//BaseObj * base_obj;
@@ -375,13 +380,14 @@ private:
 	bool CallDate(FindHelper & find_helper);
 
 	void PrintLastSpaceField(FindHelper & find_helper, pt::Space * space);
-	void CallSpaceObjectForLastField(FindHelper & find_helper, pt::Space * space);
-	pt::Space * CallSpaceObjectForMiddleField(FindHelper & find_helper, pt::Space * space);
 
-	void CallSpaceTableForLastField(FindHelper & find_helper, morm::SpaceWrapper & space_wrapper,
+	pt::Space * CallSpaceObject(FindHelper & find_helper, pt::Space * space);
-									pt::Space * space, size_t model_wrapper_space_table_index);
 
-	pt::Space * CallSpaceTableForMiddleField(FindHelper & find_helper, morm::SpaceWrapper & space_wrapper, pt::Space * space, size_t model_wrapper_space_table_index);
+	void CallSpaceTableForLastField(FindHelper & find_helper, pt::Space * space);
+
+	pt::Space * CallSpaceTableForMiddleField(FindHelper & find_helper, pt::Space * space);
+	pt::Space * CallSpaceTable(FindHelper & find_helper, pt::Space * space);
+	pt::Space * CallSpacePODtype(FindHelper & find_helper, pt::Space * space);
 
 	bool CallSpace(FindHelper & find_helper);
 
@@ -460,6 +466,7 @@ private:
 	void MakeTextIf(Item & item);
 	void MakeTextIfDef(Item & item);
 	void MakeTextIfNotDef(Item & item);
+	bool MakeTextForEvaluate(Item & item, Val & result);
 	void MakeTextFor(Item & item);
 	void MakeItemText(Item & item);
 	void MakeTextContainer(Item & item);
@@ -1524,53 +1531,44 @@ bool Generator::CallDate(FindHelper & find_helper)
 }
 
 
-
+pt::Space * Generator::CallSpaceObject(FindHelper & find_helper, pt::Space * space)
-
-
-void Generator::CallSpaceObjectForLastField(FindHelper & find_helper, pt::Space * space)
 {
+	std::wstring & field = find_helper.fields[find_helper.field_index];
+	space = space->get_space(field);
+
+	if( find_helper.is_last_field() )
+	{
 		if( IsTestingFunctionExistence() )
 		{
 			find_helper.result.set(true);
-		//last_res = true;
 		}
 		else
 		{
+			find_helper.result.set_pointer_to(space, false);
+
 			DumpSpaceIfNeeded(find_helper, space);
 			//last_res = space->object_size() > 0;
 		}
-}
+	}
-
+	else
-
+	{
-
-pt::Space * Generator::CallSpaceObjectForMiddleField(FindHelper & find_helper, pt::Space * space)
-{
-	std::wstring & next_field = find_helper.fields[find_helper.field_index];
-	space = space->get_space(next_field);
-
 		if( !space && !IsTestingFunctionExistence() )
 		{
 			CreateMsg(L"cannot find a Space field: ", find_helper.fun_name, find_helper.fields, find_helper.field_index + 1);
 		}
+	}
 
 	return space;
 }
 
 
 
-
+void Generator::CallSpaceTableForLastField(FindHelper & find_helper, pt::Space * space)
-void Generator::CallSpaceTableForLastField(
-	FindHelper & find_helper, morm::SpaceWrapper & space_wrapper, pt::Space * space, size_t model_wrapper_space_table_index)
 {
 	pt::Space::TableType * table = space->get_table();
 
 	if( is_generating_for )
 	{
-		// we are in [for...]statement, increment iterator and check the range
-		space_wrapper.increment_iterator(model_wrapper_space_table_index, table->size());
-		space_wrapper.invalidate_iterators(model_wrapper_space_table_index + 1);
-		//size_t iterator_value = space_wrapper.get_space_iterator_value(model_wrapper_space_table_index);
-		//last_res = (iterator_value < table->size());
 	}
 	else
 	{
@@ -1578,11 +1576,11 @@ void Generator::CallSpaceTableForLastField(
 		if( IsTestingFunctionExistence() )
 		{
 			find_helper.result.set(true);
-			//last_res = true;
 		}
 		else
 		{
 			//last_res = !table->empty();
+			find_helper.result.set_pointer_to(space, false);
 		}
 	}
 
@@ -1590,26 +1588,32 @@ void Generator::CallSpaceTableForLastField(
 	{
 		DumpSpaceIfNeeded(find_helper, space);
 
+		morm::SpaceWrapper * space_wrapper = find_helper.currentval->space_wrapper;
+
+		if( space_wrapper )
+		{
 			if( HasParam(find_helper.parameters, L"index") )
 			{
-			find_helper.out_stream << space_wrapper.get_space_iterator_value(model_wrapper_space_table_index);
+				find_helper.out_stream << space_wrapper->get_space_iterator_value(find_helper.currentval->space_table_index);
 			}
 
 			if( HasParam(find_helper.parameters, L"index-one") )
 			{
-			find_helper.out_stream << (space_wrapper.get_space_iterator_value(model_wrapper_space_table_index) + 1);
+				find_helper.out_stream << (space_wrapper->get_space_iterator_value(find_helper.currentval->space_table_index) + 1);
+			}
 		}
 	}
 }
 
 
 
-pt::Space * Generator::CallSpaceTableForMiddleField(FindHelper & find_helper, morm::SpaceWrapper & space_wrapper, pt::Space * space, size_t model_wrapper_space_table_index)
+pt::Space * Generator::CallSpaceTableForMiddleField(FindHelper & find_helper, pt::Space * space)
 {
+	morm::SpaceWrapper * space_wrapper = find_helper.currentval->space_wrapper;
 	pt::Space::TableType * table = space->get_table();
 
 	// check the current iterator, if it is correct then select the item from the table
-	size_t iterator_value = space_wrapper.get_space_iterator_value(model_wrapper_space_table_index);
+	size_t iterator_value = space_wrapper->get_space_iterator_value(find_helper.currentval->space_table_index);
 
 	if( iterator_value < table->size() )
 	{
@@ -1627,6 +1631,74 @@ pt::Space * Generator::CallSpaceTableForMiddleField(FindHelper & find_helper, mo
 }
 
 
+pt::Space * Generator::CallSpaceTable(FindHelper & find_helper, pt::Space * space)
+{
+	morm::SpaceWrapper * space_wrapper = find_helper.currentval->space_wrapper;
+
+	if( find_helper.currentval->space_table_index < space_wrapper->space_indices_table_size() )
+	{
+		if( find_helper.is_last_field() )
+		{
+			CallSpaceTableForLastField(find_helper, space);
+			find_helper.field_index += 1;
+		}
+		else
+		{
+			space = CallSpaceTableForMiddleField(find_helper, space);
+			// increment field_index only if next_field is 'this' and space is not an object
+
+			if( space && !space->is_object() )
+			{
+				std::wstring & next_field = find_helper.fields[find_helper.field_index];
+
+				if( next_field == L"this" )
+				{
+					find_helper.field_index += 1;
+				}
+			}
+		}
+	}
+	else
+	{
+		CreateMsg(L"", find_helper.fun_name, find_helper.fields, find_helper.field_index, L" exceeded the maximum number of fields for a Space object");
+		space = nullptr;
+	}
+
+	return space;
+}
+
+
+pt::Space * Generator::CallSpacePODtype(FindHelper & find_helper, pt::Space * space)
+{
+	if( find_helper.is_last_field() )
+	{
+		if( IsTestingFunctionExistence() )
+		{
+			find_helper.result.set(true);
+			//last_res = true;
+		}
+		else
+		{
+			//PrintLastSpaceField(find_helper, space);
+			//last_res = space->to_bool();
+			find_helper.result.set_pointer_to(space, false);
+		}
+
+		find_helper.field_index += 1;
+	}
+	else
+	{
+		if( !IsTestingFunctionExistence() )
+		{
+			CreateMsg(L"", find_helper.fun_name, find_helper.fields, find_helper.field_index, L" of a space is not an object nor a table");
+		}
+
+		space = nullptr;
+	}
+
+	return space;
+}
+
 
 void Generator::PrintLastSpaceField(FindHelper & find_helper, pt::Space * space)
 {
@@ -1645,100 +1717,39 @@ 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.currentval->pointer);
+	pt::Space * space = reinterpret_cast<pt::Space*>(find_helper.currentval->pointer);
-	pt::Space * space = space_wrapper->get_space();
-	//last_res = false;
-	size_t field_index = find_helper.field_index;
-	size_t model_wrapper_space_table_index = 0;
 
-	/*
+	while( (find_helper.field_index < find_helper.fields.size()) && space )
-	 *
-	 * we are iterating through such objects:
-	 * [root_space, fields[field_index], fields[field_index+1], fields[field_index+2], fields[field_index+3] ...]
-	 * the first item is the root_space with a find_helper.fun_name name
-	 *
-	 */
-	while( (field_index < find_helper.fields.size() + 1) && space )
 	{
-		bool is_last_field = (field_index == find_helper.fields.size());
-
 		if( space->is_object() )
 		{
-			if( is_last_field )
+			space = CallSpaceObject(find_helper, space);
-			{
+			find_helper.field_index += 1;
-				CallSpaceObjectForLastField(find_helper, space);
-			}
-			else
-			{
-				space = CallSpaceObjectForMiddleField(find_helper, space);
-			}
-
-			field_index += 1;
 		}
 		else
 		if( space->is_table() )
 		{
-			if( model_wrapper_space_table_index < space_wrapper->space_indices_table_size() )
+			space = CallSpaceTable(find_helper, space);
-			{
+			find_helper.currentval->space_table_index += 1;
-				if( is_last_field )
-				{
-					CallSpaceTableForLastField(find_helper, *space_wrapper, space, model_wrapper_space_table_index);
-					field_index += 1;
 		}
 		else
 		{
-					space = CallSpaceTableForMiddleField(find_helper, *space_wrapper, space, model_wrapper_space_table_index);
+			space = CallSpacePODtype(find_helper, space);
-					// increment field_index only if next_field is 'this' and space is not an object
-
-					if( space && !space->is_object() )
-					{
-						std::wstring & next_field = find_helper.fields[field_index];
-
-						if( next_field == L"this" )
-						{
-							field_index += 1;
-						}
-					}
-				}
-			}
-			else
-			{
-				CreateMsg(L"", find_helper.fun_name, find_helper.fields, field_index, L" exceeded the maximum number of fields for a space object");
-				space = nullptr;
-			}
-		}
-		else
-		{
-			if( is_last_field )
-			{
-				if( IsTestingFunctionExistence() )
-				{
-					//last_res = true;
-				}
-				else
-				{
-					PrintLastSpaceField(find_helper, space);
-					//last_res = space->to_bool();
-				}
-
-				field_index += 1;
-			}
-			else
-			{
-				if( !IsTestingFunctionExistence() )
-				{
-					CreateMsg(L"", find_helper.fun_name, find_helper.fields, field_index, L" of a space is not an object nor a table");
-				}
-
-				space = nullptr;
 		}
 	}
 
-		model_wrapper_space_table_index += 1;
+	if( space )
+	{
+		find_helper.result.set_pointer_to(space, false);
+
+		if( find_helper.currentval->space_wrapper )
+		{
+			find_helper.result.space_wrapper = find_helper.currentval->space_wrapper;
+			find_helper.result.space_wrapper->increment_reference_counter();
+			find_helper.result.space_table_index = find_helper.currentval->space_table_index;
+		}
 	}
 
 	return space != nullptr;
@@ -1746,6 +1757,7 @@ bool Generator::CallSpace(FindHelper & find_helper)
 
 
 
+
 #ifdef EZC_HAS_MORM_LIBRARY
 
 
@@ -1905,18 +1917,20 @@ bool Generator::CallModelContainerWrapper(FindHelper & find_helper)
 
 	if( find_helper.all_fields_known() )
 	{
+		find_helper.result.set_pointer_to(model_container_wrapper);
+
 		if( is_generating_for )
 		{
-			model_container_wrapper->increment_iterator();
+			// model_container_wrapper->increment_iterator();
-			find_helper.currentval->clear_childs();
+			// find_helper.currentval->clear_childs();
-			find_helper.result.set(model_container_wrapper->is_iterator_correct());
+			// 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());
+			//find_helper.result.set(model_container_wrapper->is_container_empty());
 		}
 	}
 
@@ -2066,7 +2080,7 @@ bool Generator::ReduceFields(FindHelper & find_helper)
 
 bool Generator::CallValue(FindHelper & find_helper)
 {
-	if( find_helper.baseval->pointer && find_helper.currentval->pointer )
+	if( find_helper.currentval->pointer )
 	{
 	#ifdef EZC_HAS_MORM_LIBRARY
 		if( find_helper.currentval->type == Val::TYPE_MODEL )
@@ -2082,7 +2096,7 @@ bool Generator::CallValue(FindHelper & find_helper)
 			//return CallWrapper(find_helper);
 			return CallDate(find_helper);
 		else
-		if( find_helper.currentval->type == Val::TYPE_SPACE_WRAPPER )
+		if( find_helper.currentval->type == Val::TYPE_SPACE )
 			return CallSpace(find_helper);
 			//return CallWrapper(find_helper);
 		else
@@ -2101,8 +2115,15 @@ bool Generator::CallValue(FindHelper & 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);
+
+	// if( find_helper.currentval->has_pod_type() )
+	// 	return CallPodType(find_helper);
+
+	if( find_helper.currentval->type == Val::TYPE_SPACE_LOCAL )
+	{
+		find_helper.result = *find_helper.currentval; // IMPROVEME this makes a copy
+		return true;
 	}
 
 	return false;
@@ -2673,7 +2694,7 @@ void Generator::MakeTextIf(Item & item)
 			return;
 	}
 
-	MakeTextIf_go(item, result.to_bool(false));
+	MakeTextIf_go(item, result.to_bool());
 }
 
 
@@ -2717,6 +2738,55 @@ void Generator::MakeTextIfNotDef(Item & item)
 }
 
 
+bool Generator::MakeTextForEvaluate(Item & item, Val & result)
+{
+	bool status = false;
+
+	if( result.type == Val::TYPE_MODEL_CONTAINER_WRAPPER && result.pointer )
+	{
+		morm::ModelContainerWrapper * model_container_wrapper = reinterpret_cast<morm::ModelContainerWrapper*>(result.pointer);
+
+		model_container_wrapper->increment_iterator();
+		//find_helper.currentval->clear_childs();
+		//find_helper.result.set(model_container_wrapper->is_iterator_correct());
+		result.clear_childs(); // is it ok?
+		status = model_container_wrapper->is_iterator_correct();
+	}
+	else
+	if( result.type == Val::TYPE_SPACE && result.pointer )
+	{
+		if( result.space_wrapper )
+		{
+			pt::Space * space = reinterpret_cast<pt::Space*>(result.pointer);
+
+			if( space->is_table() )
+			{
+				pt::Space::TableType * table = space->get_table();
+				result.space_wrapper->increment_iterator(result.space_table_index, table->size());
+				result.space_wrapper->invalidate_iterators(result.space_table_index + 1);
+
+				size_t iterator_value = result.space_wrapper->get_space_iterator_value(result.space_table_index);
+				status = (iterator_value < table->size());
+			}
+			else
+			{
+				// log some error
+			}
+		}
+		else
+		{
+			//CreateMsg();
+			// log some error
+		}
+	}
+	else
+	{
+		status = result.to_bool();
+	}
+
+	return status;
+}
+
 
 void Generator::MakeTextFor(Item & item)
 {
@@ -2735,6 +2805,7 @@ void Generator::MakeTextFor(Item & item)
 		// is_generating_for will be changed by next call to MakeText()
 		// so we should set it in each iterations
 		is_generating_for = true;
+		result.clear();
 
 		if( program_mode )
 		{
@@ -2746,7 +2817,7 @@ void Generator::MakeTextFor(Item & item)
 				return;
 		}
 
-		if( !result.to_bool(true) )
+		if( !MakeTextForEvaluate(item, result) )
 			break;
 
 		if( !item.item_tab.empty() )
@@ -2755,7 +2826,6 @@ void Generator::MakeTextFor(Item & item)
 }
 
 
-
 void Generator::MakeTextDefine(Item & item, Val & val)
 {
 	/*

src/models.cpp

@@ -109,6 +109,14 @@ void Models::Add(const std::wstring & name, pt::Date * date)
 }
 
 
+void Models::Add(const std::wstring & name, const std::wstring & value)
+{
+	Val val;
+	val.set(value);
+	models_map[name] = val;
+}
+
+
 Val * Models::Find(const std::wstring & name)
 {
 	auto iterator = models_map.find(name);

src/models.h

@@ -63,6 +63,8 @@ public:
 	void Add(const std::wstring & name, pt::Date & space);
 	void Add(const std::wstring & name, pt::Date * space);
 
+	void Add(const std::wstring & name, const std::wstring & value);
+
 	template<typename VectorType>
 	void Add(const std::wstring & name, std::vector<VectorType> & container)
 	{

src/val.cpp

@@ -79,6 +79,17 @@ void Val::copy(const Val & val)
 	type    = val.type;
 	pointer = val.pointer;
 
+	if( type == Type::TYPE_SPACE )
+	{
+		space_wrapper     = val.space_wrapper;
+		space_table_index = val.space_table_index;
+	}
+
+	if( type == Type::TYPE_SPACE_LOCAL )
+	{
+		space_local = val.space_local;
+	}
+
 	// user_function 	= val.user_function;
 	// model 			= val.model;
 	// model_container_wrapper = val.model_container_wrapper;
@@ -110,9 +121,8 @@ void Val::increment_model_container_wrapper_ref()
 
 void Val::increment_space_wrapper_ref()
 {
-	if( type == Type::TYPE_SPACE_WRAPPER && pointer )
+	if( type == Type::TYPE_SPACE && space_wrapper )
 	{
-		morm::SpaceWrapper * space_wrapper = reinterpret_cast<morm::SpaceWrapper*>(pointer);
 		space_wrapper->increment_reference_counter();
 	}
 }
@@ -143,6 +153,9 @@ void Val::initialize_empty()
 	type = TYPE_VOID;
 	pointer = nullptr;
 
+	space_wrapper = nullptr;
+	space_table_index = 0;
+
 	// user_function = nullptr;
 	// model = nullptr;
 	// model_container_wrapper = nullptr;
@@ -181,14 +194,14 @@ void Val::clear_model_container_wrapper()
 
 void Val::clear_space_wrapper()
 {
-	if( type == Type::TYPE_SPACE_WRAPPER && pointer )
+	if( type == Type::TYPE_SPACE && space_wrapper )
 	{
-		morm::SpaceWrapper * space_wrapper = reinterpret_cast<morm::SpaceWrapper*>(pointer);
 		space_wrapper->decrement_reference_counter();
 
 		if( space_wrapper->get_reference_counter() == 0 && space_wrapper->should_be_auto_removed() )
 		{
 			delete space_wrapper;
+			space_wrapper = nullptr;
 		}
 	}
 }
@@ -249,7 +262,7 @@ bool Val::has_pod_type()
 }
 
 
-bool Val::to_bool(bool is_loop_context) const
+bool Val::to_bool() const
 {
 	switch(type)
 	{
@@ -268,14 +281,11 @@ bool Val::to_bool(bool is_loop_context) const
 	case TYPE_ITEM_BLOCK:
 		break;
 
-	case TYPE_SPACE_WRAPPER:
-		return to_bool_space_wrapper();
-
 	case TYPE_SPACE:
 		return to_bool_space();
 
 	case TYPE_MODEL_CONTAINER_WRAPPER:
-		return to_bool_model_container_wrapper(is_loop_context);
+		return to_bool_model_container_wrapper();
 
 	case TYPE_OUTPUT_STREAM:
 		return output_stream->size() != output_stream_original_size;
@@ -299,25 +309,10 @@ bool Val::to_bool_space() const
 }
 
 
-bool Val::to_bool_space_wrapper() const
+bool Val::to_bool_model_container_wrapper() const
-{
-	morm::SpaceWrapper * space_wrapper = reinterpret_cast<morm::SpaceWrapper*>(pointer);
-	return space_wrapper->get_space()->to_bool();
-}
-
-
-bool Val::to_bool_model_container_wrapper(bool is_loop_context) const
 {
 	morm::ModelContainerWrapper * model_container_wrapper = reinterpret_cast<morm::ModelContainerWrapper*>(pointer);
-
-	if( is_loop_context )
-	{
-		return model_container_wrapper->is_iterator_correct();
-	}
-	else
-	{
 	return !model_container_wrapper->is_container_empty();
-	}
 }
 
 
@@ -493,25 +488,22 @@ void Val::set_pointer_to(morm::ModelContainerWrapper * model_container_wrapper)
 void Val::set_pointer_to(morm::SpaceWrapper * space_wrapper)
 {
 	clear();
-	type = TYPE_SPACE_WRAPPER;
+	type = TYPE_SPACE;
-	this->pointer = space_wrapper;
+	this->pointer = space_wrapper->get_space();
-	space_wrapper->increment_reference_counter();
+	this->space_wrapper = space_wrapper;
+	this->space_wrapper->increment_reference_counter();
 }
 
 
 void Val::set_pointer_to(pt::Space * space, bool create_wrapper)
 {
 	clear();
+	type = TYPE_SPACE;
+	this->pointer = space;
 
 	if( create_wrapper )
 	{
-		type = TYPE_SPACE_WRAPPER;
+		space_wrapper = new morm::SpaceWrapper(space);
-		this->pointer = new morm::SpaceWrapper(space);
-	}
-	else
-	{
-		type = TYPE_SPACE;
-		this->pointer = &space;
 	}
 }
 
@@ -949,10 +941,6 @@ void Val::serialize_to(pt::Stream & str)
 		serialize_model_container_wrapper_to(str);
 		break;
 
-	case TYPE_SPACE_WRAPPER:
-		serialize_space_wrapper_to(str);
-		break;
-
 	case TYPE_SPACE:
 		serialize_space_to(str);
 		break;
@@ -999,13 +987,6 @@ void Val::serialize_model_container_wrapper_to(pt::Stream & str)
 }
 
 
-void Val::serialize_space_wrapper_to(pt::Stream & str)
-{
-	morm::SpaceWrapper * space_wrapper = reinterpret_cast<morm::SpaceWrapper*>(pointer);
-	space_wrapper->get_space()->serialize_to_string(str);
-}
-
-
 void Val::serialize_space_to(pt::Stream & str)
 {
 	pt::Space * space = reinterpret_cast<pt::Space*>(pointer);

src/val.h

@@ -75,7 +75,6 @@ public:
 		TYPE_DATE,
 		TYPE_MODEL,
 		TYPE_MODEL_CONTAINER_WRAPPER,
-		TYPE_SPACE_WRAPPER,
 		TYPE_SPACE,
 		TYPE_OUTPUT_STREAM,
 		TYPE_ITEM_BLOCK,
@@ -114,7 +113,7 @@ public:
 	void clear_childs();
 
 
-	bool to_bool(bool is_loop_context = false) const;
+	bool to_bool() const;
 
 
 	void set(const char * str);
@@ -220,9 +219,13 @@ public:
 
 	Type type;
 	pt::Space space_local;
-
 	void * pointer;
 
+	// used when pointer is pointing to a pt::Space
+	// but can be null
+	morm::SpaceWrapper * space_wrapper;
+	size_t space_table_index;
+
 	// UserFunction user_function;
 
 	// // Wrapper
@@ -273,14 +276,12 @@ 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);
 	void serialize_model_to(pt::Stream & str);
 	void serialize_model_container_wrapper_to(pt::Stream & str);
-	void serialize_space_wrapper_to(pt::Stream & str);
 	void serialize_space_to(pt::Stream & str);