/*
 * This file is a part of morm
 * and is distributed under the 2-Clause BSD licence.
 * Author: Tomasz Sowa <t.sowa@ttmath.org>
 */

/*
 * Copyright (c) 2018-2021, Tomasz Sowa
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef headerfile_morm_baseexpression
#define headerfile_morm_baseexpression

#include <list>
#include <set>
#include "textstream/textstream.h"
#include "date/date.h"
#include "morm_types.h"
#include "modelenv.h"
#include "ft.h"


namespace morm
{
class Model;
class ModelConnector;


class BaseExpression
{
public:

	BaseExpression();
	virtual ~BaseExpression();

	virtual void set_work_mode(int work_mode);
	virtual int  get_work_mode();

	virtual pt::TextStream * get_text_stream();
	virtual void set_text_stream(pt::TextStream * out_stream);

	virtual void clear();

	virtual void generate_from_model(pt::TextStream & stream, Model & model);

	virtual pt::TextStream * get_current_stream();

	// rename me
	virtual void allow_to_use_prefix(bool use_prefix);
	virtual bool get_allow_to_use_prefix();



	template<typename FieldValue>
	void field(const wchar_t * field_name, const FieldValue & field_value, const FT & field_type, ModelEnv * model_env)
	{
		if( out_stream && can_field_be_generated(field_type) )
		{
			field_before();

			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS )
			{
				put_field_name_and_table_if_needed(field_name, field_type, model_env);
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_SAVE_FIELDS )
			{
				save_foreign_key(field_name, field_type, model_env);
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_VALUES )
			{
				put_field_value_or_null(field_value, field_type, model_env);
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
			{
				if( model_env && model_env->set_field_name_helper )
				{
					if( (size_t)model_env->field_index < model_env->set_field_name_helper->size() )
					{
						put_field_name_and_table_if_needed((*model_env->set_field_name_helper)[model_env->field_index], field_type, model_env);
						put_name_value_separator();
						put_field_value_or_null(field_value, field_type, model_env);
					}

					model_env->field_index += 1;
				}
				else
				{
					put_field_name_and_table_if_needed(field_name, field_type, model_env);
					put_name_value_separator();
					put_field_value_or_null(field_value, field_type, model_env);
				}
			}


			field_after();
		}
	}




	template<typename FieldValue>
	void put_field_value_or_null(const FieldValue & field_value, const FT & field_type, ModelEnv * model_env)
	{
		if( field_type.is_primary_key() )
		{
			if( model_env && model_env->has_primary_key_set )
				put_field_value(field_value, field_type);
			else
				put_null_value();
		}
		else
		{
			put_field_value(field_value, field_type);
		}
	}

	template<typename FieldValue>
	void field_in(pt::TextStream & stream, const wchar_t * field_name, const std::set<FieldValue> & container, ModelEnv * model_env)
	{
		field_in_generic<FieldValue, std::set<FieldValue>>(stream, field_name, container, model_env);
	}


	template<typename FieldValue>
	void field_in(pt::TextStream & stream, const wchar_t * field_name, const std::list<FieldValue> & container, ModelEnv * model_env)
	{
		field_in_generic<FieldValue, std::list<FieldValue>>(stream, field_name, container, model_env);
	}


	template<typename FieldValue>
	void field_in(pt::TextStream & stream, const wchar_t * field_name, const std::vector<FieldValue> & container, ModelEnv * model_env)
	{
		field_in_generic<FieldValue, std::vector<FieldValue>>(stream, field_name, container, model_env);
	}


	template<typename ModelContainer>
	void field_list(const wchar_t * field_name, ModelContainer & field_value, const FT & field_type, ModelConnector * model_connector, ModelEnv * model_env)
	{
		if( out_stream && can_field_be_generated(field_type) )
		{
			field_before();

//			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS )
//			{
//				put_field_name_and_table_if_needed(field_name);
//			}
//			else
			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
			{
				put_field_name_and_table_if_needed(field_name, field_type, model_env);
				put_name_value_separator();
				put_field_value_list(field_value, model_connector, model_env);
			}

			field_after();
		}
	}

	template<typename ModelClass>
	void field_model(const wchar_t * field_name, ModelClass & field_model, const FT & field_type, ModelEnv * model_env)
	{
		if( out_stream && can_field_be_generated(field_type) )
		{
			field_before();

			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS )
			{
				put_field_name_and_table_if_needed(field_name, field_type, model_env);
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_VALUES )
			{
				generate_from_model(field_model); // is it ok as a value?
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
			{
				put_field_name_and_table_if_needed(field_name, field_type, model_env);
				put_name_value_separator();
				generate_from_model(field_model);
			}

			field_after();
		}
	}

	template<typename FieldValue>
	void field_to_stream(pt::TextStream & stream, const wchar_t * field_name, const FieldValue & field_value, const FT & field_type, ModelEnv * model_env)
	{
		this->out_stream = &stream;
		field(field_name, field_value, field_type, model_env);
		this->out_stream = nullptr;
	}


	virtual void put_schema_table(const wchar_t * schema_name, const wchar_t * table_name);
	virtual void put_schema_table(const pt::WTextStream & schema_name, const pt::WTextStream & table_name);
	virtual void put_table(const wchar_t * table_name);
	virtual void put_table(const pt::WTextStream & table_name);
	virtual void put_table_with_index(const wchar_t * table_name, int index);
	virtual void put_table_with_index(const pt::WTextStream & table_name, int index);
	virtual void put_table_with_index_and_field(const wchar_t * table_name, int index, const wchar_t * field_name, const FT & field_type);
	virtual void put_table_with_index_and_field(const pt::WTextStream & table_name, int index, const wchar_t * field_name, const FT & field_type);
	virtual void put_table_and_field(const wchar_t * table_name, const wchar_t * field_name, const FT & field_type);
	virtual void put_table_and_field(const pt::WTextStream & table_name, const wchar_t * field_name, const FT & field_type);

	virtual void schema_table_to_stream(pt::TextStream & stream, const wchar_t * schema_name, const wchar_t * table_name);
	virtual void schema_table_to_stream(pt::TextStream & stream, const pt::WTextStream & schema_name, const pt::WTextStream & table_name);
	virtual void table_to_stream(pt::TextStream & stream, const wchar_t * table_name);
	virtual void table_to_stream(pt::TextStream & stream, const pt::WTextStream & table_name);
	virtual void table_with_index_to_stream(pt::TextStream & stream, const wchar_t * table_name, int index);
	virtual void table_with_index_to_stream(pt::TextStream & stream, const pt::WTextStream & table_name, int index);
	virtual void table_with_index_and_field_to_stream(pt::TextStream & stream, const wchar_t * table_name, int index, const wchar_t * field_name, const FT & field_type);
	virtual void table_with_index_and_field_to_stream(pt::TextStream & stream, const pt::WTextStream & table_name, int index, const wchar_t * field_name, const FT & field_type);
	virtual void table_and_field_to_stream(pt::TextStream & stream, const wchar_t * table_name, const wchar_t * field_name, const FT & field_type);
	virtual void table_and_field_to_stream(pt::TextStream & stream, const pt::WTextStream & table_name, const wchar_t * field_name, const FT & field_type);


	/*
	 * IMPLEMENT ME
	 * esc for: signed char, wchar_t, char16_t, char32_t
	 *
	 */
	virtual void esc(char val, 					pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(unsigned char val, 		pt::TextStream & stream, const FT & field_type = FT::default_type);

	virtual void esc(wchar_t val, 				pt::TextStream & stream, const FT & field_type = FT::default_type);

	virtual void esc(const std::wstring & val, 	pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(const wchar_t * val, 		pt::TextStream & stream, const FT & field_type = FT::default_type);

	virtual void esc(const std::string & val, 	pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(const char * val, 			pt::TextStream & stream, const FT & field_type = FT::default_type);

	virtual void esc(bool val, 					pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(short val, 				pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(unsigned short val, 		pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(int val, 					pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(unsigned int val, 			pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(long val, 					pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(unsigned long val, 		pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(long long val, 			pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(unsigned long long val, 	pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(float val, 				pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(double val, 				pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(long double val, 			pt::TextStream & stream, const FT & field_type = FT::default_type);
	//virtual void esc(void* val, 					pt::TextStream & stream);

	virtual void esc(const pt::Date & date, 	pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(const pt::TextStream & val,pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(const pt::WTextStream & val,pt::TextStream & stream, const FT & field_type = FT::default_type);
	virtual void esc(const pt::Space & space, 	pt::TextStream & stream, const FT & field_type = FT::default_type);



protected:

	int work_mode;   /* what to do: generating fields list, values list or fields-values list */
	bool is_first_field;

	pt::TextStream * out_stream;

	bool use_prefix;

	virtual void generate_from_model(Model & model);

	virtual void before_generate_from_model();
	virtual void after_generate_from_model();
	virtual bool can_field_be_generated(const FT &);
	virtual void field_before();
	virtual void field_after();

	virtual void put_field_name_and_table_if_needed(const wchar_t * field_name, const FT & field_type, ModelEnv * model_env);
	virtual void put_field_name(const wchar_t * field_name, const FT & field_type, ModelEnv * model_env);

	virtual void save_foreign_key(const wchar_t * field_name, const FT & field_type, ModelEnv * model_env);
	virtual void dump_additional_info(Model & model);

	template<typename FieldValue>
	void put_field_value(const FieldValue & field_value, const FT & field_type)
	{
		if( out_stream )
		{
			before_field_value(field_value, field_type);
			esc(field_value, *out_stream, field_type);
			after_field_value(field_value, field_type);
		}
	}


	virtual void put_null_value()
	{
		(*out_stream) << "null";
	}


	virtual void before_field_value_list()
	{
	}


	virtual void after_field_value_list()
	{
	}


	virtual void field_value_list_separator()
	{
		(*out_stream) << ",";
	}

	virtual void put_statement_in_starts()
	{
		(*out_stream) << "(";
	}

	virtual void put_statement_in_ends()
	{
		(*out_stream) << ") ";
	}


	template<typename ModelContainer>
	void put_field_value_list_non_model(ModelContainer & field_value, ModelConnector * model_connector)
	{
		if( model_connector && out_stream )
		{
			bool is_first = true;
			before_field_value_list();

			for(const auto & m : field_value)
			{
				if( !is_first )
				{
					field_value_list_separator();
				}

				put_field_value(m, FT::default_type);
				is_first = false;
			}

			after_field_value_list();
		}
	}


	template<typename ModelContainer>
	void put_field_value_list(ModelContainer & field_value, ModelConnector * model_connector, ModelEnv * model_env)
	{
		if( model_connector && model_env && out_stream )
		{
			bool is_first = true;
			before_field_value_list();

			for(auto & m : field_value)
			{
				if( !is_first )
				{
					field_value_list_separator();
				}

				ModelEnv model_env_local(*model_env);
				m.model_env = &model_env_local;
				m.model_env->has_primary_key_set = m.get_has_primary_key_set();
				m.set_connector(model_connector);

				generate_from_model(m);

				m.model_env = nullptr;
				is_first = false;
			}

			after_field_value_list();
		}
	}


	void put_field_value_list(std::vector<char> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<unsigned char> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<std::wstring> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<std::string> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<bool> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<short> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<unsigned short> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<int> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<unsigned int> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<long> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<unsigned long> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<long long> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<unsigned long long> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<float> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<double> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<long double> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::vector<pt::Date> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}





	void put_field_value_list(std::list<char> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<unsigned char> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<std::wstring> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<std::string> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<bool> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<short> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<unsigned short> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<int> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<unsigned int> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<long> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<unsigned long> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<long long> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<unsigned long long> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<float> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<double> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<long double> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}

	void put_field_value_list(std::list<pt::Date> & field_value, ModelConnector * model_connector, ModelEnv *)
	{
		put_field_value_list_non_model(field_value, model_connector);
	}



	// used in 'in()' statements, may should be renamed?
	template<typename FieldValue, typename Container>
	void field_in_generic(pt::TextStream & stream, const wchar_t * field_name, const Container & container, ModelEnv * model_env)
	{
		// IMPROVE ME
		// what about if container is empty?
		// only 'in()' statement would be generated
		this->out_stream = &stream;

		field_before();
		put_field_name_and_table_if_needed(field_name, FT::default_type, model_env);
		put_name_value_separator();

		bool is_first = true;
		put_statement_in_starts();

		for(const FieldValue & v : container)
		{
			if( !is_first )
			{
				field_value_list_separator();
			}

			put_field_value(v, FT::default_type);
			is_first = false;
		}

		put_statement_in_ends();
		field_after();
		this->out_stream = nullptr;
	}


	virtual void schema_table_separator();
	virtual void table_field_separator();

	virtual void before_schema_name();
	virtual void after_schema_name();

	virtual void before_table_name();
	virtual void after_table_name();

	virtual void before_field_name();
	virtual void after_field_name();


	virtual void before_field_value(const std::wstring &, const FT & field_type);
	virtual void after_field_value(const std::wstring &, const FT & field_type);

	virtual void before_field_value(const std::string &, const FT & field_type);
	virtual void after_field_value(const std::string &, const FT & field_type);

	virtual void before_field_value(const wchar_t *, const FT & field_type);
	virtual void after_field_value(const wchar_t *, const FT & field_type);

	virtual void before_field_value(const char *, const FT & field_type);
	virtual void after_field_value(const char *, const FT & field_type);

	virtual void before_field_value(wchar_t, const FT & field_type);
	virtual void after_field_value(wchar_t, const FT & field_type);

	virtual void before_field_value(char, const FT & field_type);
	virtual void after_field_value(char, const FT & field_type);

	virtual void before_field_value(const pt::Date &, const FT & field_type);
	virtual void after_field_value(const pt::Date &, const FT & field_type);

	virtual void before_field_value(const pt::Space &, const FT & field_type);
	virtual void after_field_value(const pt::Space &, const FT & field_type);

	template<typename FieldValue>
	void before_field_value(const FieldValue &, const FT & field_type)
	{
	}

	template<typename FieldValue>
	void after_field_value(const FieldValue &, const FT & field_type)
	{
	}

	virtual void put_name_value_separator();


	/*
	 * IMPLEMENT ME
	 * put_type for: signed char, wchar_t, char16_t, char32_t
	 *
	 */
//	virtual void put_type(char val, 				pt::TextStream & stream);
//	virtual void put_type(unsigned char val, 		pt::TextStream & stream);
//
//	virtual void put_type(const std::wstring & val, pt::TextStream & stream);
//	virtual void put_type(const wchar_t * val, 		pt::TextStream & stream);
//
//	virtual void put_type(const std::string & val, 	pt::TextStream & stream);
//	virtual void put_type(const char * val, 			pt::TextStream & stream);
//
//	virtual void put_type(bool val, 				pt::TextStream & stream);
//	virtual void put_type(short val, 				pt::TextStream & stream);
//	virtual void put_type(unsigned short val, 		pt::TextStream & stream);
//	virtual void put_type(int val, 					pt::TextStream & stream);
//	virtual void put_type(unsigned int val, 		pt::TextStream & stream);
//	virtual void put_type(long val, 				pt::TextStream & stream);
//	virtual void put_type(unsigned long val, 		pt::TextStream & stream);
//	virtual void put_type(long long val, 			pt::TextStream & stream);
//	virtual void put_type(unsigned long long val, 	pt::TextStream & stream);
//	virtual void put_type(float val, 				pt::TextStream & stream);
//	virtual void put_type(double val, 				pt::TextStream & stream);
//	virtual void put_type(long double val, 			pt::TextStream & stream);
	//virtual void put_type(void* val, 				pt::TextStream & stream);

//	virtual void put_type(const pt::Date & date, 	pt::TextStream & stream);
//	virtual void put_type(const Model & model, 		pt::TextStream & stream);
//
//	template<typename ListType>
//	void put_type(const std::list<ListType> & model, 		pt::TextStream & stream)
//	{
//		stream << "table"; // may just use std::list?
//	}
//
//	template<typename ListType>
//	void put_type(const std::vector<ListType> & model, 		pt::TextStream & stream)
//	{
//		stream << "table"; // may just just std::vector?
//	}



	virtual void before_field_value_string(const FT & field_type);
	virtual void after_field_value_string(const FT & field_type);

	char char_to_hex_part(char c);
	void char_to_hex(char c, pt::TextStream & stream);

	void esc(const wchar_t * val, bool has_known_length, size_t len, pt::TextStream & stream, const FT & field_type = FT::default_type);

	bool is_empty_field(const wchar_t * value);
};

}

#endif