ezc/src/functions.h

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

/* 
 * Copyright (c) 2007-2010, 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:
 * 
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *    
 *  * 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.
 *    
 *  * Neither the name Tomasz Sowa nor the names of contributors to this
 *    project may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * 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 OWNER 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_functions
#define headerfile_ezc_functions

#include <map>
#include "funinfo.h"



namespace Ezc
{



// functions or variables
template<class StreamType>
class Functions
{
public:

	typedef void (*UserFunction)(FunInfo<StreamType> &);
	enum Type { function, variable };

	struct Function
	{	
		Type type;

		UserFunction user_function; // used when type is 'function'
		std::wstring variable;		// used when type is 'variable'

		int  iter;
		bool is_for;				// true if is used by a [for] statement
		bool is_running;			// true if this function is currently executed
		
		Function();
	};



	void Insert(const char * key, UserFunction ufunction);  // inserting a function
	void Insert(const char * key, const char * var);        // inserting a variable
	void Insert(const char * key, const std::string & var); // inserting a variable
	void Insert(const std::string & key, UserFunction ufunction);  // inserting a function
	void Insert(const std::string & key, const char * var);        // inserting a variable
	void Insert(const std::string & key, const std::string & var); // inserting a variable
	void Insert(const std::wstring & key, UserFunction ufunction);
	void Insert(const std::wstring & key, const wchar_t * var);
	void Insert(const std::wstring & key, const std::wstring & var);


	bool Find(const std::string & key, Function ** fun);
	bool Find(const std::wstring & key, Function ** fun);
	void Clear();

	
private:
	typedef std::map<std::wstring, Function> FunctionsTable;
	FunctionsTable functions_tab;
	std::wstring temp_key;
};







template<class StreamType>
Functions<StreamType>::Function::Function()
{
	type = Functions::variable;
	user_function = 0;
	iter = 0;
	is_for = false;
	is_running = false;
}




template<class StreamType>
void Functions<StreamType>::Insert(const char * key, UserFunction ufunction)
{
	Function f;
	f.type = function;
	f.user_function = ufunction;

	AssignString(key, temp_key);
	functions_tab[temp_key] = f;
}


template<class StreamType>
void Functions<StreamType>::Insert(const char * key, const char * var)
{
	Function f;
	f.type = variable;
	AssignString(var, f.variable);
	
	AssignString(key, temp_key);
	functions_tab[temp_key] = f;
}


template<class StreamType>
void Functions<StreamType>::Insert(const char * key, const std::string & var)
{
	Function f;
	f.type = variable;
	AssignString(var, f.variable);
	
	AssignString(key, temp_key);
	functions_tab[temp_key] = f;
}




template<class StreamType>
void Functions<StreamType>::Insert(const std::string & key, UserFunction ufunction)
{
	Insert(key.c_str(), ufunction);
}


template<class StreamType>
void Functions<StreamType>::Insert(const std::string & key, const char * var)
{
	Insert(key.c_str(), var);
}


template<class StreamType>
void Functions<StreamType>::Insert(const std::string & key, const std::string & var)
{
	Insert(key.c_str(), var);
}






template<class StreamType>
void Functions<StreamType>::Insert(const std::wstring & key, UserFunction ufunction)
{
	Function f;
	f.type = function;
	f.user_function = ufunction;
	
	functions_tab[key] = f;
}



template<class StreamType>
void Functions<StreamType>::Insert(const std::wstring & key, const wchar_t * var)
{
	Function f;
	f.type = variable;
	f.variable = var;
	
	functions_tab[key] = f;
}


template<class StreamType>
void Functions<StreamType>::Insert(const std::wstring & key, const std::wstring & var)
{
	Function f;
	f.type = variable;
	f.variable = var;
	
	functions_tab[key] = f;
}






template<class StreamType>
bool Functions<StreamType>::Find(const std::string & key, Function ** fun)
{
	AssignString(key, temp_key);
	return Find(temp_key, fun);
}


template<class StreamType>
bool Functions<StreamType>::Find(const std::wstring & key, Function ** fun)
{
	typename FunctionsTable::iterator i = functions_tab.find( key );

	if( i == functions_tab.end() )
		return false;

	*fun = &(i->second);

return true;
}



template<class StreamType>
void Functions<StreamType>::Clear()
{
	functions_tab.clear();
}



} // namespace Ezc


#endif