Property.hpp

/***************************************************************************
  tag: Peter Soetens  Mon Jan 19 14:11:19 CET 2004  Property.hpp

                        Property.hpp -  description
                           -------------------
    begin                : Mon January 19 2004
    copyright            : (C) 2004 Peter Soetens
    email                : peter.soetens@mech.kuleuven.ac.be

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU General Public                   *
 *   License as published by the Free Software Foundation;                 *
 *   version 2 of the License.                                             *
 *                                                                         *
 *   As a special exception, you may use this file as part of a free       *
 *   software library without restriction.  Specifically, if other files   *
 *   instantiate templates or use macros or inline functions from this     *
 *   file, or you compile this file and link it with other files to        *
 *   produce an executable, this file does not by itself cause the         *
 *   resulting executable to be covered by the GNU General Public          *
 *   License.  This exception does not however invalidate any other        *
 *   reasons why the executable file might be covered by the GNU General   *
 *   Public License.                                                       *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU General Public             *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/

#ifndef ORO_PROPERTY_HPP
#define ORO_PROPERTY_HPP

#include "rtt-config.h"
#include "Marshaller.hpp"
#include "PropertyBase.hpp"
#include "PropertyBag.hpp"
#include "PropertyCommands.hpp"
#include "DataSources.hpp"
#include "BuildType.hpp"
#include <boost/type_traits.hpp>

#include <string>
#include <ostream>

#ifdef ORO_PRAGMA_INTERFACE
#pragma interface
#endif

namespace RTT
{
    template<typename T>
    class Property
        : public PropertyBase
    {
    public:
        typedef typename boost::remove_const<typename boost::remove_reference<T>::type>::type value_t;
        typedef typename boost::call_traits<value_t>::param_type param_t;
        typedef typename boost::call_traits<value_t>::reference reference_t;
        typedef typename boost::call_traits<value_t>::const_reference const_reference_t;
        typedef value_t DataSourceType;

        Property()
        {}

        Property(const std::string& name, const std::string& description, param_t value = value_t() )
            : PropertyBase(name, description), _value( detail::BuildType<value_t>::Value( value ) )
        {
        }

        Property( const Property<T>& orig)
            : PropertyBase(orig.getName(), orig.getDescription()),
              _value( orig._value ? orig._value->clone() : 0 )
        {}

        Property( PropertyBase* source)
            : PropertyBase(source ? source->getName() : "", source ? source->getDescription() : ""),
              _value( source ? AssignableDataSource<DataSourceType>::narrow(source->getDataSource().get() ) : 0 )
        {
        }

        Property(const std::string& name, const std::string& description,
                 typename AssignableDataSource<DataSourceType>::shared_ptr datasource )
            : PropertyBase(name, description), _value( datasource )
        {}

        Property<T>& operator=( param_t value )
        {
            _value->set( value );
            return *this;
        }

        Property<T>& operator=( PropertyBase* source )
        {
            if ( this == source )
                return *this;

            if ( source ) {
                this->setName( source->getName() );
                this->setDescription( source->getDescription() );
                typename AssignableDataSource<DataSourceType>::shared_ptr vptr
                    = AssignableDataSource<DataSourceType>::narrow(source->getDataSource().get() );
                if (vptr)
                    _value = vptr;
                else
                    _value = detail::BuildType<value_t>::Value() ;
            } else {
                this->setName( "" );
                this->setDescription( "" );
                _value = 0;
            }
            return *this;
        }

        Property<T>& operator<<=(Property<T> &p)
        {
            this->update( p );
            return *this;
        }

        operator value_t() const
        {
            return _value->get();
        }

        DataSourceType get() const
        {
            return _value->get();
        }

        reference_t set()
        {
            return _value->set();
        }

        void set(param_t v)
        {
            _value->set(v);
        }

        reference_t value()
        {
            return set();
        }

        const_reference_t rvalue() const
        {
            return _value->rvalue();
        }

        static Property<T>* narrow( PropertyBase* prop );

        virtual void identify( PropertyIntrospection* pi);

        virtual void identify( PropertyBagVisitor* pi);

        virtual bool update( const PropertyBase* other)
        {
            const Property<T>* origin = dynamic_cast< const Property<T>* >( other );
            if ( origin != 0 ) {
                return this->update( *origin );
            }
            return false;
        }

        virtual CommandInterface* updateCommand( const PropertyBase* other)
        {
            // try to update from identical type or from const_reference_t.
            const Property<T>* origin = dynamic_cast<const Property<T>* >( other );
            if ( origin != 0 && _value )
                return new detail::UpdatePropertyCommand<T>(this, origin);
            return 0;
        }

        virtual bool refresh( const PropertyBase* other)
        {
            const Property<T>* origin = dynamic_cast< const Property<T>* >( other );
            if ( origin != 0 && _value ) {
                return this->refresh( *origin );
            }
            return false;
        }

        virtual CommandInterface* refreshCommand( const PropertyBase* other)
        {
            if ( !_value )
                return 0;
            // refresh is just an update of the datasource.
            DataSourceBase::shared_ptr sourcebase = other->getDataSource();
            return _value->updateCommand( sourcebase.get() );
        }

        virtual bool copy( const PropertyBase* other )
        {
            const Property<T>* origin = dynamic_cast< const Property<T>* >( other );
            if ( origin != 0 && _value ) {
                return this->copy( *origin );
            }
            return false;
        }

        virtual CommandInterface* copyCommand( const PropertyBase* other)
        {
            const Property<T>* origin = dynamic_cast< const Property<T>* >( other );
            if ( origin != 0 && _value )
                return new detail::CopyPropertyCommand<T>(this, origin);
            return 0;
        }

        bool copy( const Property<T>& orig)
        {
            if ( !ready() )
                return false;
            _description = orig.getDescription();
            _name = orig.getName();
            *this = orig.rvalue();
            return true;
        }

        bool update( const Property<T>& orig)
        {
            if ( !ready() )
                return false;
            if ( _description.empty() )
                _description = orig.getDescription();
            *this = orig.rvalue();
            return true;
        }

        bool refresh( const Property<T>& orig)
        {
            if ( !ready() )
                return false;
            *this = orig.rvalue();
            return true;
        }

        virtual Property<T>* clone() const
        {
            return new Property<T>(*this);
        }

        virtual Property<T>* create() const
        {
            return new Property<T>( _name, _description );
        }

        virtual DataSourceBase::shared_ptr getDataSource() const {
            return _value;
        }

        typename AssignableDataSource<DataSourceType>::shared_ptr getAssignableDataSource() const {
            return _value;
        }

        virtual std::string getType() const {
            return DataSource<T>::GetType();
        }

        virtual const TypeInfo* getTypeInfo() const {
            return DataSource<T>::GetTypeInfo();
        }
    protected:
        typename AssignableDataSource<DataSourceType>::shared_ptr _value;
    };


    template<>
    RTT_API bool Property<PropertyBag>::update( const Property<PropertyBag>& orig);

    template<>
    RTT_API bool Property<PropertyBag>::refresh( const Property<PropertyBag>& orig);

    template<>
    RTT_API bool Property<PropertyBag>::copy( const Property<PropertyBag>& orig);

    template<typename T>
    std::ostream& operator<<(std::ostream &os, Property<T> &p)
    {
#ifdef OS_HAVE_STREAMS
        os << p.getDataSource();
#endif
        return os;
    }

    template<class T>
    Property<T>* Property<T>::narrow( PropertyBase* prop ) {
        Property<T>* res = dynamic_cast<Property<T>*>( prop );
        if (res)
            return res->clone();
        // If this property is a proxy:
        int p_id = prop->getDataSource()->serverProtocol();
        if ( p_id ) {
            assert(false); // untested code.
#if 0
            T result;
            void* ret = propbase->getDataSource()->getBlob(p_id);
            if( A n y Conversion<T>::update( any.in() , result ) ) {
                return new Property<T>( propbase->getName(), propbase->getDescription(), result );
            }
#endif
        }
        return 0;
    }

#if !defined(ORO_EMBEDDED) && defined(__GNUC__)
    extern template class Property<double>;
    extern template class Property<bool>;
    extern template class Property<float>;
    extern template class Property<int>;
    extern template class Property<unsigned int>;
    extern template class Property<std::string>;
    extern template class Property<const std::string &>;
#endif
}

#include "PropertyIntrospection.hpp"

namespace RTT
{
    template< class T>
    void Property<T>::identify( PropertyIntrospection* pi)
    {
        pi->introspect( *this );
    }

    template< class T>
    void Property<T>::identify( PropertyBagVisitor* pi)
    {
        return PropertyBase::identify(pi);
    }

    template<>
    RTT_API void Property<PropertyBag>::identify( PropertyBagVisitor* pbi);
}

#endif