ezc/src/objects.h

/*
 * This file is a part of EZC -- Easy templating in C++ library
 * and is distributed under the 2-Clause BSD licence.
 * Author: Tomasz Sowa <t.sowa@ttmath.org>
 */

/*
 * Copyright (c) 2015, 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_ezc_objects
#define headerfile_ezc_objects

#include <vector>
#include <string>
#include "utf8/utf8.h"




namespace Ezc
{


template<class StreamType>
class BaseObj
{
public:

	virtual ~BaseObj() {}


	/*
	 *
	 */
	virtual std::wstring & GetObjectName() = 0;


	/*
	 *
	 */
	virtual int FindFun(const std::wstring & fun_name) = 0;


	/*
	 *
	 */
	virtual void CallFun(int fun_index, FunInfo<StreamType> &) = 0;


	/*
	 *
	 */
	virtual void ClearFunctions() = 0;


	/*
	 *
	 */
	virtual size_t FunctionsSize() = 0;


	/*
	 *
	 */
	virtual void AddFunctions() {};


};





#define EZC_DEFINE_OBJECT_METHODS(classname)																	\
																												\
																												\
protected:																										\
																												\
	struct EzcTemplateMethod																					\
	{																											\
		std::wstring fun_name;																					\
		void (classname::*fun)(Info &);																			\
	};																											\
																												\
public:																											\
																												\
	virtual std::wstring & GetObjectName()																		\
	{																											\
		return ezc_object_name;																					\
	}																											\
																												\
	virtual void CallFun(int fun_index, Info & info)															\
	{																											\
		if( fun_index >=0 && (size_t)fun_index < ezc_template_method_tab.size() )								\
		{																										\
			(this->*(ezc_template_method_tab[fun_index].fun))(info);												\
		}																										\
	}																											\
																												\
	virtual int FindFun(const std::wstring & fun_name)															\
	{																											\
		for(size_t i=0 ; i<ezc_template_method_tab.size() ; ++i)												\
		{																										\
			if( ezc_template_method_tab[i].fun_name == fun_name )												\
			{																									\
				return (int)i;																					\
			}																									\
		}																										\
																												\
	return -1;																									\
	}																											\
																												\
																												\
protected:																										\
																												\
	virtual void ClearFunctions()																				\
	{																											\
		ezc_template_method_tab.clear();																		\
	}																											\
																												\
	virtual size_t FunctionsSize()																				\
	{																											\
		return ezc_template_method_tab.size();																	\
	}																											\
																												\
	void Insert(const char * name, void (classname::*fun)(Info &))												\
	{																											\
		EzcTemplateMethod item;																					\
																												\
		pt::utf8_to_wide(name, item.fun_name);																	\
		item.fun = fun;																							\
																												\
		ezc_template_method_tab.push_back(item);																\
	}																											\
																												\
	void Insert(const std::string & name, void (classname::*fun)(Info &))										\
	{																											\
		EzcTemplateMethod item;																					\
																												\
		pt::utf8_to_wide(name, item.fun_name);																	\
		item.fun = fun;																							\
																												\
		ezc_template_method_tab.push_back(item);																\
	}																											\
																												\
	void Insert(const wchar_t * name, void (classname::*fun)(Info &))											\
	{																											\
		EzcTemplateMethod item;																					\
																												\
		item.fun_name = name;																					\
		item.fun = fun;																							\
																												\
		ezc_template_method_tab.push_back(item);																\
	}																											\
																												\
	void Insert(const std::wstring & name, void (classname::*fun)(Info &))										\
	{																											\
		EzcTemplateMethod item;																					\
																												\
		item.fun_name = name;																					\
		item.fun = fun;																							\
																												\
		ezc_template_method_tab.push_back(item);																\
	}																											\
																												\
std::vector<EzcTemplateMethod> ezc_template_method_tab;															\
std::wstring ezc_object_name;																					\
																												\
private:











template<class StreamType>
class Objects
{
public:

	typedef std::vector<BaseObj<StreamType> * > ObjectsTable;
	typedef typename ObjectsTable::iterator Iterator;

	void Insert(BaseObj<StreamType> * base_fun);
	void Insert(BaseObj<StreamType> & base_fun);

	Iterator Begin();
	Iterator End();
	size_t   Size() const;
	void     Clear();

	Iterator Find(const std::wstring & key, int & method_index);

private:

	ObjectsTable obj_tab;

};



template<class StreamType>
typename Objects<StreamType>::Iterator Objects<StreamType>::Find(const std::wstring & key, int & method_index)
{
	Iterator i = obj_tab.begin();
	method_index = -1;

	for( ; i != obj_tab.end() ; ++i)
	{
		int index = (*i)->FindFun(key);

		if( index != -1 )
		{
			method_index = index;
			return i;
		}
	}

	return obj_tab.end();
}




template<class StreamType>
void Objects<StreamType>::Insert(BaseObj<StreamType> * base_fun)
{
	obj_tab.push_back(base_fun);
}


template<class StreamType>
void Objects<StreamType>::Insert(BaseObj<StreamType> & base_fun)
{
	obj_tab.push_back(&base_fun);
}



template<class StreamType>
typename Objects<StreamType>::Iterator Objects<StreamType>::Begin()
{
	return obj_tab.begin();
}


template<class StreamType>
typename Objects<StreamType>::Iterator Objects<StreamType>::End()
{
	return obj_tab.end();
}


template<class StreamType>
size_t Objects<StreamType>::Size() const
{
	return obj_tab.size();
}


template<class StreamType>
void Objects<StreamType>::Clear()
{
	obj_tab.clear();
}




} // namespace Ezc


#endif