introspectable.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 IDIOSKOPOSINTROSPECTABLE_H
#define IDIOSKOPOSINTROSPECTABLE_H

#include <map>
#include <string>

#include <sigc++/sigc++.h>

#include <idioskopos/pointer.h>
#include <idioskopos/error.h>
#include <idioskopos/object.h>
#include <idioskopos/property.h>
#include <idioskopos/referenceproperty.h>

namespace Idioskopos
{

  typedef std::map<Object*, Object::pointer> DynamicPropertyMap;
  typedef std::map<Glib::ustring, Object*> PropertyMap;

  class Introspectable: public Object
  {
    public:
      typedef IdioskoposPointer<Introspectable> pointer;

      IDIOSKOPOS_OBJECT_AND_REGISTRAR(Introspectable);

      Introspectable( const Glib::ustring& name,
                      sigc::slot<void> slot=sigc::slot<void>() );

      Introspectable( const Glib::ustring& name,
                      Introspectable& container,
                      sigc::slot<void> slot=sigc::slot<void>() );

      static pointer create( const Glib::ustring& name,
                             sigc::slot<void> slot=sigc::slot<void>() );

      static pointer create( const Glib::ustring& name,
                             Introspectable& container,
                             sigc::slot<void> slot=sigc::slot<void>() );

      ~Introspectable();

      Object* get_property( const Glib::ustring& name );

      bool has_property( const Glib::ustring& name );

      bool add_property( Object& property );

      bool add_property( Object::pointer property );

      void remove_property( const Glib::ustring& name );

      sigc::signal<void, Object*> signal_property_value_changed();

      sigc::signal<void, Object*, const Glib::ustring&> signal_property_name_changed();

      virtual sigc::signal<void, Object*> signal_property_added();

      virtual sigc::signal<void, Object*> signal_property_removed();

      template <typename T>
      PropertyBase<T>& property( const Glib::ustring& name );

      template <typename T>
      PropertyBase<T>* property_ptr( const Glib::ustring& name );

      const std::type_info& type() const
      {
        return typeid( Introspectable );
      }

      virtual size_t num_properties() const;

      virtual Glib::ustring xml(int indent=-1);

      virtual void set_xml(const Glib::ustring& s, bool change_names=false, bool create_missing=true);

      virtual void set_xml(const xmlpp::Node* n, bool change_names=false, bool create_missing=true);

      virtual iterator properties_begin();
      virtual iterator properties_end();

      virtual Object& operator[] ( const Glib::ustring& name ) throw ( error::bad_property_name );

    protected:
      std::set<Object*> m_properties;
      PropertyMap m_property_name_map;
      DynamicPropertyMap m_dynamic_property_map;

      Glib::ustring m_separator;

      sigc::signal<void, Object*> m_signal_property_value_changed;
      std::map<Object*, sigc::connection> m_property_value_changed_connection;
      void on_property_value_changed( Object* );

      sigc::signal<void, Object*, const Glib::ustring&> m_signal_property_name_changed;
      std::map<Object*, sigc::connection> m_property_name_changed_connection;
      void on_property_name_changed( const Glib::ustring&, Object* );


      sigc::signal<void, Object*> m_signal_property_added;

      sigc::signal<void, Object*> m_signal_property_removed;

      virtual iterator next_property(std::set<Object*>::iterator i);

      virtual iterator previous_property(std::set<Object*>::iterator i);
  };

  template <typename T>
  inline
  PropertyBase<T>& Introspectable::property( const Glib::ustring& name )
  {
    Object * pb = get_property( name );
    if ( pb == NULL )
      throw error::bad_property_name();
    try {
      PropertyBase<T>& prop = dynamic_cast<PropertyBase<T>&>( *pb );
      return prop;
    } catch ( ... ) {
      throw error::cast::wrong_property_type();
    }
  }

  template <typename T>
  inline
  PropertyBase<T>* Introspectable::property_ptr( const Glib::ustring& name )
  {
    PropertyBase<T>* prop;
    Object* pb = get_property( name );
    if ( pb == NULL )
      return NULL;
    try {
      prop = dynamic_cast<PropertyBase<T>*>( pb );
      return prop;
    } catch ( ... ) {
      return NULL;
    }
  }

}

#endif

---