#ifndef PROPERTIES_INCLUDED
#define PROPERTIES_INCLUDED

// These templated classes make it trivial to express properties in C++.

enum AccessLevel
{
  iGetIsPublic,
  iSetIsPublic,
  iGetIsProtected,
  iSetIsProtected,
  iGetIsPrivate,
  iSetIsPrivate
};

/*
Implemented so far:
public, protected
public private
public public

protected protected
protected public        - is this useful?
protected private

private private
private protected       - is this useful?
private public          - is this useful?

*/

template <typename T,
      int GetAccessor = iGetIsPublic,
      int SetAccessor = iSetIsPublic >
struct Property;

template <typename T>
struct Property<T, iGetIsPublic, iSetIsProtected>
{
  explicit Property<T, iGetIsPublic, iSetIsProtected>( T value ):
    m_value( value )
  {
  }

  // getters
  // x = Value();
  T operator() () const
  {
    return m_value;
  }

  // x = Value;
  operator T() const
  {
    return m_value;
  }

protected:
  // setters
  void operator() ( T const & value )
  {
    m_value = value;
  }

  void operator= ( T const & value )
  {
    m_value = value;
  }

private:
  T  m_value;

};

template <typename T>
struct Property<T, iGetIsPublic, iSetIsPrivate>
{
  explicit Property<T, iGetIsPublic, iSetIsPrivate>( T value ):
    m_value( value )
  {
  }

  // getters
  // x = Value();
  T operator() () const
  {
    return m_value;
  }

  // x = Value;
  operator T() const
  {
    return m_value;
  }

private:
  // setters
  void operator() ( T const & value )
  {
    m_value = value;
  }

  void operator= ( T const & value )
  {
    m_value = value;
  }

  T  m_value;
};


template <typename T>
struct Property<T, iGetIsPublic, iSetIsPublic>
{
  explicit Property<T, iGetIsPublic, iSetIsPublic>( T value ):
    m_value( value )
  {
  }

  // getters
  // x = Value();
  T operator() () const
  {
    return m_value;
  }

  // x = Value;
  operator T() const
  {
    return m_value;
  }

  // setters
  void operator() ( T const & value )
  {
    m_value = value;
  }

  void operator= ( T const & value )
  {
    m_value = value;
  }

private:
  T  m_value;
};


template <typename T>
struct Property<T, iGetIsProtected, iSetIsProtected>
{
  explicit Property<T, iGetIsProtected, iSetIsProtected>( T value ):
    m_value( value )
  {
  }

protected:
  // getters
  // x = Value();
  T operator() () const
  {
    return m_value;
  }

  // x = Value;
  operator T() const
  {
    return m_value;
  }

  // setters
  void operator() ( T const & value )
  {
    m_value = value;
  }

  void operator= ( T const & value )
  {
    m_value = value;
  }

private:
  T  m_value;
};


template <typename T>
struct Property<T, iGetIsProtected, iSetIsPublic>
{
  explicit Property<T, iGetIsProtected, iSetIsPublic>( T value ):
    m_value( value )
  {
  }

protected:
  // getters
  // x = Value();
  T operator() () const
  {
    return m_value;
  }

  // x = Value;
  operator T() const
  {
    return m_value;
  }

public:
  // setters
  void operator() ( T const & value )
  {
    m_value = value;
  }

  void operator= ( T const & value )
  {
    m_value = value;
  }

private:
  T  m_value;
};


template <typename T>
struct Property<T, iGetIsProtected, iSetIsPrivate>
{
  explicit Property<T, iGetIsProtected, iSetIsPrivate>( T value ):
    m_value( value )
  {
  }

protected:
  // getters
  // x = Value();
  T operator() () const
  {
    return m_value;
  }

  // x = Value;
  operator T() const
  {
    return m_value;
  }

private:
  // setters
  void operator() ( T const & value )
  {
    m_value = value;
  }

  void operator= ( T const & value )
  {
    m_value = value;
  }

private:
  T  m_value;
};

struct Property<T, iGetIsPrivate, iSetIsPrivate>
{
  explicit Property<T, iGetIsPrivate, iSetIsPrivate>( T value ):
    m_value( value )
  {
  }

private:
  // getters
  // x = Value();
  T operator() () const
  {
    return m_value;
  }

  // x = Value;
  operator T() const
  {
    return m_value;
  }

  // setters
  void operator() ( T const & value )
  {
    m_value = value;
  }

  void operator= ( T const & value )
  {
    m_value = value;
  }

private:
  T  m_value;
};


struct Property<T, iGetIsPrivate, iSetIsPrivate>
{
  explicit Property<T, iGetIsPrivate, iSetIsProtected>( T value ):
    m_value( value )
  {
  }

private:
  // getters
  // x = Value();
  T operator() () const
  {
    return m_value;
  }

  // x = Value;
  operator T() const
  {
    return m_value;
  }

protected:
  // setters
  void operator() ( T const & value )
  {
    m_value = value;
  }

  void operator= ( T const & value )
  {
    m_value = value;
  }

private:
  T  m_value;
};


struct Property<T, iGetIsPrivate, iSetIsPublic>
{
  explicit Property<T, iGetIsPrivate, iSetIsProtected>( T value ):
    m_value( value )
  {
  }

private:
  // getters
  // x = Value();
  T operator() () const
  {
    return m_value;
  }

  // x = Value;
  operator T() const
  {
    return m_value;
  }

public:
  // setters
  void operator() ( T const & value )
  {
    m_value = value;
  }

  void operator= ( T const & value )
  {
    m_value = value;
  }

private:
  T  m_value;
};









#endif  // PROPERTIES_INCLUDED