writeonlypropertybase.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 IDIOSKOPOSWRITEONLYPROPERTYBASE_H
#define IDIOSKOPOSWRITEONLYPROPERTYBASE_H

#include <idioskopos/object.h>
#include <idioskopos/utility_stream.h>

namespace Idioskopos
{

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

      IDIOSKOPOS_OBJECT( WriteOnlyPropertyBase );

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

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

      virtual ~WriteOnlyPropertyBase()
      { }

      virtual void set_value( const Glib::ustring& v )
      {
        T t;
        Idioskopos::set_value( v, t );
        this->set
        ( t );
      }

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

      virtual void set( const T& val ) = 0;

      virtual Glib::ustring xml( int indent = -1 )
      {
        Glib::ustring s;
        for ( int i = 0; i < indent; i++ )
          s += "  ";
        s += "<property type=\"" + this->class_name() + "\" name=\"" + this->name() + "\">";
        if ( indent >= 0 )
          s += "\n";
        s += get_xml( this->get_value(), ( ( indent >= 0 ) ? indent + 1 : indent ) );
        if ( indent >= 0 )
          s += "\n";
        for ( int i = 0; i < indent; i++ )
          s += "  ";
        s += "</property>";
        if ( indent >= 0 )
          s += "\n";
        return s;
      }

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

      virtual void set_xml( const xmlpp::Node* n, bool change_names = false, bool create_missing = true )
      {
        xmlpp::Attribute * attribute;
        xmlpp::NodeSet values;
        const xmlpp::Element *elem, *elem2;
        const xmlpp::TextNode* text;

        elem = dynamic_cast<const xmlpp::Element*>( n );
        if ( !elem )
          return ;

        if ( change_names ) {
          attribute = elem->get_attribute( "name" );
          if ( attribute )
            this->set_name( attribute->get_value() );
        }

        values = elem->find( "value" );

        elem2 = dynamic_cast<const xmlpp::Element*>( values.front() );
        if ( !elem2 )
          return ;
        text = dynamic_cast<const xmlpp::TextNode*>( elem2->get_child_text() );
        if ( !text )
          return ;
        this->set_value( text->get_content() );

        return ;
      }

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

    protected:

      virtual T& get_value() = 0;


  };

  template <typename X, typename A>
  class WriteOnlyPropertyBase<std::vector<X,A> >: public virtual Object
  {
    public:
      typedef IdioskoposPointer<WriteOnlyPropertyBase> pointer;
      typedef std::vector<X,A> value_type;

      IDIOSKOPOS_OBJECT( WriteOnlyPropertyBase );

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

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

      virtual ~WriteOnlyPropertyBase()
      { }

      virtual void set_value( const Glib::ustring& v )
      {
        std::vector<X,A> t;
        Idioskopos::set_value( v, t );
        this->set
        ( t );
      }

      WriteOnlyPropertyBase<std::vector<X,A> >& operator= ( const std::vector<X,A> & val )
      {
        this->set( val );
        return *this;
      }

      virtual void set( const std::vector<X,A> & val ) = 0;

      virtual void set_element( int n, const X& x ) {
        if ( n < 0 ) throw;
        this->get_value()[n] = x;
        m_signal_value_changed.emit();
      }

      virtual void set_element( unsigned int n, const X& x ) {
        this->get_value()[n] = x;
        m_signal_value_changed.emit();
      }

      virtual void set_element( long int n, const X& x ) {
        if ( n < 0 ) throw;
        this->get_value()[n] = x;
        m_signal_value_changed.emit();
      }

      virtual void set_element( long unsigned int n, const X& x ) {
        this->get_value()[n] = x;
        m_signal_value_changed.emit();
      }

      virtual Glib::ustring xml( int indent = -1 )
      {
        Glib::ustring s;
        for ( int i = 0; i < indent; i++ )
          s += "  ";
        s += "<property type=\"" + this->class_name() + "\" name=\"" + this->name() + "\">";
        if ( indent >= 0 )
          s += "\n";
        s += get_xml( this->get_value(), ( ( indent >= 0 ) ? indent + 1 : indent ) );
        if ( indent >= 0 )
          s += "\n";
        for ( int i = 0; i < indent; i++ )
          s += "  ";
        s += "</property>";
        if ( indent >= 0 )
          s += "\n";
        return s;
      }

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

      virtual void set_xml( const xmlpp::Node* n, bool change_names = false, bool create_missing = true )
      {
        xmlpp::Attribute * attribute;
        xmlpp::NodeSet values;
        const xmlpp::Element *elem, *elem2;
        const xmlpp::TextNode* text;
        X x;

        elem = dynamic_cast<const xmlpp::Element*>( n );
        if ( !elem )
          return ;

        if ( change_names ) {
          attribute = elem->get_attribute( "name" );
          if ( attribute )
            this->set_name( attribute->get_value() );
        }

        values = elem->find( "vector" );
        if ( values.size() == 0 )
          values = elem->find( "array" );
        if ( values.size() == 0 )
          return ;

        elem = dynamic_cast<const xmlpp::Element*>( values.front() );
        if ( !elem )
          return ;

        values = elem->find( "value" );

        xmlpp::NodeSet::iterator iter;
        size_t i;

        for ( i = 0, iter = values.begin(); iter != values.end(); i++, iter++ ) {
          elem2 = dynamic_cast<const xmlpp::Element*>( *iter );
          if ( !elem2 )
            return ;
          text = dynamic_cast<const xmlpp::TextNode*>( elem2->get_child_text() );
          if ( !text )
            return ;
          Idioskopos::set_value( text->get_content(), x );
          if ( i < get_value().size() )
            get_value() [ i ] = x;
          else
            get_value().push_back( x );
        }

        return ;
      }

      const std::type_info& type() const
      {
        return typeid( std::vector<X,A> );
      }

    protected:

      virtual std::vector<X,A> & get_value() = 0;


  };

  template <typename X, size_t N>
  class WriteOnlyPropertyBase<IdioskoposArray<X,N> >: public virtual Object
  {
    public:
      typedef IdioskoposPointer<WriteOnlyPropertyBase> pointer;
      typedef IdioskoposArray<X,N> value_type;

      IDIOSKOPOS_OBJECT( WriteOnlyPropertyBase );

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

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

      virtual ~WriteOnlyPropertyBase()
      { }

      virtual void set_value( const Glib::ustring& v )
      {
        IdioskoposArray<X,N> t;
        Idioskopos::set_value( v, t );
        this->set
        ( t );
      }

      WriteOnlyPropertyBase<IdioskoposArray<X,N> >& operator= ( const IdioskoposArray<X,N> & val )
      {
        this->set( val );
        return *this;
      }

      virtual void set( const IdioskoposArray<X,N> & val ) = 0;

      virtual void set_element( int n, const X& x ) {
        if ( n < 0 ) throw;
        this->get_value()[n] = x;
        m_signal_value_changed.emit();
      }

      virtual void set_element( unsigned int n, const X& x ) {
        this->get_value()[n] = x;
        m_signal_value_changed.emit();
      }

      virtual void set_element( long int n, const X& x ) {
        if ( n < 0 ) throw;
        this->get_value()[n] = x;
        m_signal_value_changed.emit();
      }

      virtual void set_element( long unsigned int n, const X& x ) {
        this->get_value()[n] = x;
        m_signal_value_changed.emit();
      }

      virtual Glib::ustring xml( int indent = -1 )
      {
        Glib::ustring s;
        for ( int i = 0; i < indent; i++ )
          s += "  ";
        s += "<property type=\"" + this->class_name() + "\" name=\"" + this->name() + "\">";
        if ( indent >= 0 )
          s += "\n";
        s += get_xml( this->get_value(), ( ( indent >= 0 ) ? indent + 1 : indent ) );
        if ( indent >= 0 )
          s += "\n";
        for ( int i = 0; i < indent; i++ )
          s += "  ";
        s += "</property>";
        if ( indent >= 0 )
          s += "\n";
        return s;
      }

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

      virtual void set_xml( const xmlpp::Node* n, bool change_names = false, bool create_missing = true )
      {
        xmlpp::Attribute * attribute;
        xmlpp::NodeSet values;
        const xmlpp::Element *elem, *elem2;
        const xmlpp::TextNode* text;

        elem = dynamic_cast<const xmlpp::Element*>( n );
        if ( !elem )
          return ;

        if ( change_names ) {
          attribute = elem->get_attribute( "name" );
          if ( attribute )
            this->set_name( attribute->get_value() );
        }

        values = elem->find( "array" );
        if ( values.size() == 0 )
          return ;
        elem = dynamic_cast<const xmlpp::Element*>( values.front() );
        if ( !elem )
          return ;

        values = elem->find( "value" );

        xmlpp::NodeSet::iterator iter;
        size_t i;

        for ( i = 0, iter = values.begin(); i < N && iter != values.end(); i++, iter++ ) {
          elem2 = dynamic_cast<const xmlpp::Element*>( *iter );
          if ( !elem2 )
            return ;
          text = dynamic_cast<const xmlpp::TextNode*>( elem2->get_child_text() );
          if ( !text )
            return ;
          Idioskopos::set_value( text->get_content(), get_value()[i] );
        }

        return ;
      }

      const std::type_info& type() const
      {
        return typeid( IdioskoposArray<X,N> );
      }

    protected:

      virtual IdioskoposArray<X,N> & get_value() = 0;


  };

}

#endif

---