property: remove copy() method and allow to construct or create a pro…

…perty with a custom data source

PropertyBag assignment is supposed to have linking semantics (changing the value of a property in the copy
also changes the value in the original bag), which is important for property composition and decomposition.

The PropertyBase::copy() method introduced in 44b9970 had this linking
semantics and was used for PropertyBag assignment, but the term `copy` was actually always
associated with deep-copy semantics in RTT, like in PropertyBase::copy(const PropertyBase *) or in
DataSourceBase::copy().

This patch introduces an alternative signature for the create() method, which accepts a custom data source
instead of creating a default-initialized ValueDataSource. PropertyBag assignment now calls this create()
method with the DataSource pointer of the original property to be copied.

This reverts commit 44b9970.

Signed-off-by: Johannes Meyer <[email protected]>

rtt/Property.hpp

@@ -162,7 +162,7 @@ namespace RTT
          * @post ready() will be true if datasource is a valid pointer.
          */
         Property(const std::string& name, const std::string& description,
-                 typename internal::AssignableDataSource<DataSourceType>::shared_ptr datasource )
+                 const typename internal::AssignableDataSource<DataSourceType>::shared_ptr& datasource )
             : base::PropertyBase(name, description), _value( datasource )
         {
             // need to do this on the datasource in order to have access to set()/rvalue() of the data source.
@@ -370,14 +370,21 @@ namespace RTT
             return new Property<T>(*this);
         }
 
-        virtual Property<T>* copy() const
+        virtual Property<T>* create() const
         {
-            return new Property<T>( _name, _description, _value );
+            return new Property<T>( _name, _description, T() );
         }
 
-        virtual Property<T>* create() const
+        virtual Property<T>* create( const base::DataSourceBase::shared_ptr& datasource ) const
         {
-            return new Property<T>( _name, _description, T() );
+            typename internal::AssignableDataSource<DataSourceType>::shared_ptr value
+                    = internal::AssignableDataSource<DataSourceType>::narrow( datasource.get() );
+            Property<T>* prop = new Property<T>( _name, _description, value );
+            if ( datasource && !prop->ready() ) {
+                log(Error) << "Cannot initialize Property: "
+                           << "incompatible type ( destination type: " << getType() << ", source type: " << datasource->getTypeName() << ")." << endlog();
+            }
+            return prop;
         }
 
         virtual base::DataSourceBase::shared_ptr getDataSource() const {

rtt/PropertyBag.cpp

@@ -233,7 +233,7 @@ namespace RTT
 
         for( const_iterator i = orig.mproperties.begin(); i != orig.mproperties.end(); ++i) {
             if ( orig.ownsProperty( *i ) ) {
-                PropertyBase* copy = (*i)->copy();
+                PropertyBase* copy = (*i)->create( (*i)->getDataSource() );
                 this->ownProperty( copy );
             } else {
                 this->add( *i );

rtt/base/PropertyBase.hpp

@@ -173,18 +173,18 @@ namespace RTT
         virtual PropertyBase* clone() const = 0;
 
         /**
-         * Deliver a shallow copy of this PropertyBase with a shared
-         * DataSource. The original may be deleted and the clone can be
-         * transparantly used in its place or vice versa.
+         * Create a new default instance of the PropertyBase.
+         * This is a factory method to 'make something of the same type'.
+         * The new PropertyBase has the same name and description as this.
          */
-        virtual PropertyBase* copy() const = 0;
+        virtual PropertyBase* create() const = 0;
 
         /**
-         * Create a new default instance of the PropertyBase.
+         * Create a new instance of the PropertyBase with a custom data source.
          * This is a factory method to 'make something of the same type'.
          * The new PropertyBase has the same name and description as this.
          */
-        virtual PropertyBase* create() const = 0;
+        virtual PropertyBase* create( const base::DataSourceBase::shared_ptr& datasource ) const = 0;
 
         /**
          * Get a internal::DataSource through which this PropertyBase can be