#ifndef TPROPERTYTYPE_H

#define TPROPERTYTYPE_H

#include <vector></vector>

using namespace std;

template <typename t=""></typename>

class TEnumerationT

{

public:

	typedef T value_type;

	TEnumerationT() {}

	void addItem(const string &id, T item)

	{

		m_items.push_back(std::make_pair(id, item));

	}

	int getItemCount() const

	{

		return m_items.size();

	}

	void getItem(unsigned int i, string &idstring, T &value) const

	{

		assert(i < m_items.size());

		ItemData vp = m_items[i];

		idstring = vp.first;

		value = vp.second;

	}

	T getItem(unsigned int i) const

	{

		assert(i < m_items.size());

		ItemData vp = m_items[i];

		return vp.second;

	}

	bool isValid(T item) const

	{

		typename vector<itemdata>::const_iterator it =</itemdata>

			find_if(m_items.begin(), m_items.end(), MatchesItem(item));

		return it != m_items.end();

	}

private:

	typedef pair<string, t=""> ItemData;</string,>

	vector<itemdata> m_items;</itemdata>

	class MatchesItem

	{

	public:

		MatchesItem(const T &item) : m_item(item) {}

		bool operator()(const ItemData &itemData)

		{

			return itemData.second == m_item;

		}

	private:

		T m_item;

	};

};

typedef TEnumerationT<int> TIntEnumeration;</int>

template <typename t=""></typename>

class TValueRangeT

{

public:

	typedef T value_type;

	TValueRangeT() : m_min(-1), m_max(1) {}

	TValueRangeT(T min, T max) : m_min(min), m_max(max) {}

	void getRange(T &min, T &max) const;

	bool isValid(T value) const

	{

		return m_min <= value && value <= m_max;

	}

private:

	T m_min, m_max;

};

typedef TValueRangeT<int> IntValueRange;</int>

typedef TValueRangeT<double> DoubleValueRange;</double>

#endif