virtualproperty.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 IDIOSKOPOSVIRTUALPROPERTY_H
#define IDIOSKOPOSVIRTUALPROPERTY_H

#include <idioskopos/propertybase.h>

namespace Idioskopos {

  template <typename T>
  class ReadOnlyVirtualProperty: public ReadOnlyPropertyBase<T> {
    public:
      typedef IdioskoposPointer<ReadOnlyVirtualProperty> pointer;
      typedef T value_type;
      typedef sigc::slot<T> GetSlotType;

      IDIOSKOPOS_OBJECT(ReadOnlyVirtualProperty);

      ReadOnlyVirtualProperty ( const Glib::ustring& name,
                                sigc::slot<T> get_slot = GetSlotType() ) :
          Object(name),
          ReadOnlyPropertyBase<T>(name),
          m_get_slot( get_slot ) { }

      ReadOnlyVirtualProperty ( const Glib::ustring& name, Introspectable& container, sigc::slot<T> get_slot = GetSlotType() ) :
          Object( name, container ),
          ReadOnlyPropertyBase<T>( name, container ),
          m_get_slot( get_slot ) { }

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

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

      virtual ~ReadOnlyVirtualProperty() { }

      virtual const T& get() const {
        static T t;
        if ( m_get_slot ) {
            t = m_get_slot();
            return t;
          }
          else
            // TODO throw a proper exception class instead of a general throw
            throw;
        }

      virtual T* get_pointer() {
        return 0x00;
      }

      sigc::slot<T> get_slot() { return m_get_slot; }

      void get_slot( sigc::slot<T> slot ) { m_get_slot = slot; }

      void get_slot_clear() { m_get_slot = GetSlotType(); }

    protected:
      sigc::slot<T> m_get_slot;

  };

  template <typename T>
  class WriteOnlyVirtualProperty: public WriteOnlyPropertyBase<T> {
    public:
      typedef IdioskoposPointer<WriteOnlyVirtualProperty> pointer;
      typedef T value_type;
      typedef sigc::slot<void, T> SetSlotType;

      IDIOSKOPOS_OBJECT(WriteOnlyVirtualProperty);

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

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

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

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

      virtual ~WriteOnlyVirtualProperty() { }

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

      sigc::slot<void, T> set_slot() { return m_set_slot; }

      void set_slot( sigc::slot<void, T> slot ) {
        m_set_slot = slot;
        this->signal_value_changed().emit();
      }

      void set_slot_clear() { m_set_slot = SetSlotType(); }

    protected:
      sigc::slot<void, T> m_set_slot;

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

  };

  template <typename T>
  class VirtualProperty: public PropertyBase<T> {
    public:
      typedef IdioskoposPointer<VirtualProperty> pointer;
      typedef T value_type;
      typedef sigc::slot<T> GetSlotType;
      typedef sigc::slot<void, T> SetSlotType;

      IDIOSKOPOS_OBJECT(VirtualProperty);

      VirtualProperty (const Glib::ustring& name):
        Object(name),
        PropertyBase<T>(name)
      { }

      VirtualProperty ( const Glib::ustring& name, Introspectable& container ) :
        Object(name, container),
        PropertyBase<T>(name, container)
        { }

      VirtualProperty ( const Glib::ustring& name, sigc::slot<T> get_slot, sigc::slot<void, T> set_slot ) :
        Object(name),
        PropertyBase<T>(name),
        m_get_slot( get_slot ),
        m_set_slot( set_slot )
      { }

      VirtualProperty ( const Glib::ustring& name,
                        Introspectable& container,
                        sigc::slot<T> get_slot,
                        sigc::slot<void, T> set_slot ) :
        Object(name, container),
        PropertyBase<T>(name, container),
        m_get_slot( get_slot ),
        m_set_slot( set_slot )
      { }

      static pointer create(const Glib::ustring& name)
      {
        return pointer( new VirtualProperty<T>(name) );
      }

      static pointer create( const Glib::ustring& name, Introspectable& container )
      {
        return pointer( new VirtualProperty<T>(name, container) );
      }

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

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

      virtual ~VirtualProperty() { }

      virtual const T& get() const {
        static T t;
        if ( m_get_slot ) {
          t = m_get_slot();
          return t;
        }
        else
            // TODO throw a proper exception class instead of a general throw
          throw;
      }

      virtual T* get_pointer() {
        return 0x00;
      }

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

      sigc::slot<T> get_slot() { return m_get_slot; }

      void get_slot( sigc::slot<T> slot ) { m_get_slot = slot; }

      void get_slot_clear() { m_get_slot = GetSlotType(); }

      sigc::slot<void, T> set_slot() { return m_set_slot; }

      void set_slot( sigc::slot<void, T> slot ) {
        m_set_slot = slot;
        this->signal_value_changed().emit();
      }

      void set_slot_clear() { m_set_slot = SetSlotType(); }

    protected:
      sigc::slot<T> m_get_slot;
      sigc::slot<void, T> m_set_slot;

      virtual T& get_value()
      {
        static T t;
        if ( m_get_slot ) {
          t = m_get_slot();
          return t;
        }
        else
            // TODO throw a proper exception class instead of a general throw
          throw;
      }
  };


// Utility macros
#define INIT_VIRTUAL_PROPERTY( property, id, getter, setter )                          \
  property( id, *this, sigc::mem_fun(*this, &getter), sigc::mem_fun(*this, &setter) )

#define INIT_VIRTUAL_PROPERTY_OVERLOADED( class, type, property, id, getter, setter )   \
  property( id, *this, sigc::mem_fun(*this, &getter),                                   \
                       sigc::mem_fun(*this, static_cast<void(class::*)(type)>(&setter)) \
          )

}


#endif

---