#pragma once

#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