property.h

/***************************************************************************
 *   Copyright (C) 2004 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License as        *
 *   published by the Free Software Foundation version 2.1.                *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA              *
 ***************************************************************************/

#ifndef IDIOSKOPOSPROPERTY_H
#define IDIOSKOPOSPROPERTY_H

#include <idioskopos/propertybase.h>
#include <idioskopos/array.h>

namespace Idioskopos {

  template <typename T>
  class ReadOnlyProperty: public ReadOnlyPropertyBase<T> {
    public:
      typedef IdioskoposPointer<ReadOnlyProperty> pointer;
      typedef T value_type;

      IDIOSKOPOS_OBJECT(ReadOnlyProperty);

      ReadOnlyProperty ( const Glib::ustring& name,
                         sigc::slot<void> slot=sigc::slot<void>()):
          Object(name, slot),
          ReadOnlyPropertyBase<T>(name)
      { }

          ReadOnlyProperty ( const Glib::ustring& name,
                             const T& val,
                             sigc::slot<void> slot=sigc::slot<void>() ) :
          Object(name, slot),
          ReadOnlyPropertyBase<T>(name),
          m_value( val )
      { }

      ReadOnlyProperty( const Glib::ustring& name,
                        Introspectable& container,
                        sigc::slot<void> slot=sigc::slot<void>() ) :
          Object(name, container, slot),
          ReadOnlyPropertyBase<T>( name, container )
      { }

      ReadOnlyProperty ( const Glib::ustring& name,
                         const T& val,
                         Introspectable& container,
                         sigc::slot<void> slot=sigc::slot<void>() ) :
          Object(name, container, slot),
          ReadOnlyPropertyBase<T>( name, container ),
          m_value( val )
      { }

      static Object::pointer create_object()
      {
        return Object::pointer( new ReadOnlyProperty<T>(Glib::ustring()) );
      }

      static pointer create(const Glib::ustring& name,
                            sigc::slot<void> slot=sigc::slot<void>())
      {
        return pointer( new ReadOnlyProperty<T>(name, slot) );
      }

      static pointer create( const Glib::ustring& name,
                             const T& val,
                             sigc::slot<void> slot=sigc::slot<void>() )
      {
        return pointer( new ReadOnlyProperty<T>(name, val, slot) );
      }

      static pointer create( const Glib::ustring& name,
                             Introspectable& container,
                             sigc::slot<void> slot=sigc::slot<void>() )
      {
        return pointer( new ReadOnlyProperty<T>(name, container, slot) );
      }

      static pointer create( const Glib::ustring& name,
                             const T& val,
                             Introspectable& container,
                             sigc::slot<void> slot=sigc::slot<void>())
      {
        return pointer( new ReadOnlyProperty<T>(name, val, container, slot) );
      }

      virtual ~ReadOnlyProperty() { }

      virtual const T& get() const { return m_value; }

      virtual T* get_pointer() { return & m_value; }

    protected:
      T m_value;

  };

  template <typename T>
  class WriteOnlyProperty: public WriteOnlyPropertyBase<T> {
    public:
      typedef IdioskoposPointer<WriteOnlyProperty> pointer;
      typedef T value_type;

      IDIOSKOPOS_OBJECT(WriteOnlyProperty);

      WriteOnlyProperty (const Glib::ustring& name, sigc::slot<void> slot=sigc::slot<void>()):
          Object(name, slot),
          WriteOnlyPropertyBase<T>(name) { }

          WriteOnlyProperty ( const Glib::ustring& name,
                              const T& val,
                              sigc::slot<void> slot=sigc::slot<void>() ) :
          Object(name, slot),
          WriteOnlyPropertyBase<T>(name),
          m_value( val ) { }

      WriteOnlyProperty( const Glib::ustring& name,
                         Introspectable& container,
                         sigc::slot<void> slot=sigc::slot<void>() ) :
          Object(name, container, slot),
          WriteOnlyPropertyBase<T>( name, container ) { }

      WriteOnlyProperty ( const Glib::ustring& name,
                          const T& val,
                          Introspectable& container,
                          sigc::slot<void> slot=sigc::slot<void>() ) :
          Object(name, container, slot),
          WriteOnlyPropertyBase<T>( name, container ),
          m_value( val ) { }

      static Object::pointer create_object()
      {
        return Object::pointer( new WriteOnlyProperty<T>(Glib::ustring()) );
      }

      static pointer create(const Glib::ustring& name,
                            sigc::slot<void> slot=sigc::slot<void>())
      {
        return pointer( new WriteOnlyProperty<T>(name, slot) );
      }

      static pointer create( const Glib::ustring& name,
                             const T& val,
                             sigc::slot<void> slot=sigc::slot<void>() )
      {
        return pointer( new WriteOnlyProperty<T>(name, val, slot) );
      }

      static pointer create( const Glib::ustring& name,
                             Introspectable& container,
                             sigc::slot<void> slot=sigc::slot<void>() )
      {
        return pointer( new WriteOnlyProperty<T>(name, container, slot) );
      }

      static pointer create( const Glib::ustring& name,
                             const T& val,
                             Introspectable& container,
                             sigc::slot<void> slot=sigc::slot<void>() )
      {
        return pointer( new WriteOnlyProperty<T>(name, val, container, slot) );
      }

      virtual ~WriteOnlyProperty() { }

      virtual void set( const T& val )
      {
        m_value = val;
        this->signal_value_changed().emit();
      }

    protected:
      T m_value;

      virtual T& get_value()
      {
        return m_value;
      }
  };

  template <typename T>
  class Property: public PropertyBase<T> {
    public:
      typedef IdioskoposPointer<Property> pointer;
      typedef T value_type;

      IDIOSKOPOS_OBJECT(Property);

      Property (const Glib::ustring& name,
                sigc::slot<void> slot=sigc::slot<void>()):
          Object(name, slot),
          PropertyBase<T>(name),
          m_value()
      { }

      Property ( const Glib::ustring& name,
                 const T& val,
                 sigc::slot<void> slot=sigc::slot<void>() ) :
          Object(name, slot),
          PropertyBase<T>(name),
          m_value( val )
      { }

      Property( const Glib::ustring& name,
                Introspectable& container,
                sigc::slot<void> slot=sigc::slot<void>() ) :
          Object( name, container, slot ),
          PropertyBase<T>(name, container),
          m_value()
      { }

      Property ( const Glib::ustring& name,
                 const T& val,
                 Introspectable& container,
                 sigc::slot<void> slot=sigc::slot<void>() ) :
          Object( name, container, slot ),
          PropertyBase<T>(name, container),
          m_value( val )
      { }

      static Object::pointer create_object()
      {
        return Object::pointer( new Property<T>(Glib::ustring()) );
      }

      static pointer create(const Glib::ustring& name,
                            sigc::slot<void> slot=sigc::slot<void>())
      {
        return pointer( new Property<T>(name, slot) );
      }

      static pointer create( const Glib::ustring& name,
                             const T& val,
                             sigc::slot<void> slot=sigc::slot<void>() )
      {
        return pointer( new Property<T>(name, val, slot) );
      }

      static pointer create( const Glib::ustring& name,
                             Introspectable& container,
                             sigc::slot<void> slot=sigc::slot<void>() )
      {
        return pointer( new Property<T>(name, container, slot) );
      }

      static pointer create( const Glib::ustring& name,
                             const T& val,
                             Introspectable& container,
                             sigc::slot<void> slot=sigc::slot<void>() )
      {
        return pointer( new Property<T>(name, val, container, slot) );
      }

      virtual ~Property() { }

      virtual const T& get() const { return m_value; }

      virtual T* get_pointer()
      {
        return & m_value;
      }

      virtual void set
        ( const T& val )
      {
        m_value = val;
        this->signal_value_changed().emit();
      }

      Property<T>& operator= (const T& val)
      {
        this->set(val);
        return *this;
      }

    protected:
      T m_value;

      virtual T& get_value()
      {
        return m_value;
      }
  };

}


#endif

---