/**
* Assign an external assignable base::DataSource to this property.
* @param dsb The other data source
* @return false if the properties are of different type.
*/
virtual bool setDataSource( const base::DataSourceBase::shared_ptr& dsb )
{
typename internal::AssignableDataSource<DataSourceType>::shared_ptr vptr
= internal::AssignableDataSource<DataSourceType>::narrow(dsb.get());
if (vptr) {
_value.swap(vptr);
return true;
}
return false;
}
virtual bool composeType( base::DataSourceBase::shared_ptr source, base::DataSourceBase::shared_ptr result) const {
// First, try a plain update.
if ( result->update( source.get() ) )
return true;
return false;
}
bool execute() {
try {
if (mdocall) {
CORBA::Any_var any = mfact->callOperation( mop.c_str(), nargs.inout() );
for (size_t i=0; i < margs.size(); ++i ) {
const types::TypeInfo* ti = margs[i]->getTypeInfo();
CorbaTypeTransporter* ctt = dynamic_cast<CorbaTypeTransporter*>( ti->getProtocol(ORO_CORBA_PROTOCOL_ID) );
assert( ctt );
ctt->updateFromAny( &nargs[i], margs[i] );
}
// convert returned any to local type:
if (mctt)
return mctt->updateFromAny(&any.in(), mresult);
} else {
CSendHandle_var sh = mfact->sendOperation( mop.c_str(), nargs.in() );
AssignableDataSource<CSendHandle_var>::shared_ptr ads = AssignableDataSource<CSendHandle_var>::narrow( mresult.get() );
if (ads) {
ads->set( sh ); // _var creates a copy of the obj reference.
}
}
return true;
} catch ( corba::CNoSuchNameException& ) {
return false;
} catch ( corba::CWrongNumbArgException& ) {
return false;
} catch ( corba::CWrongTypeArgException& ) {
return false;
}
}
/**
* Update \a target with the contents of \a any which is an object of a \a protocol.
*/
virtual bool updateFromAny(const CORBA::Any* any, base::DataSourceBase::shared_ptr target) const
{
typename internal::ReferenceDataSource<T>::shared_ptr ad_ref = boost::dynamic_pointer_cast< internal::ReferenceDataSource<T> >( target );
if ( ad_ref ) {
if (AnyConversion<PropertyType>::update(*any, ad_ref->set() ) ) {
return true;
}
return false;
}
typename internal::AssignableDataSource<T>::shared_ptr ad = internal::AssignableDataSource<T>::narrow( target.get() );
if ( ad ) {
PropertyType value = PropertyType();
if (AnyConversion<PropertyType>::update(*any, value ) ) {
ad->set( value );
return true;
}
return false;
}
return false;
}
virtual bool updateFromBlob(const void* blob, int size, base::DataSourceBase::shared_ptr target) const
{
typename internal::AssignableDataSource<T>::shared_ptr ad = internal::AssignableDataSource<T>::narrow( target.get() );
assert( size == sizeof(T) );
if ( ad ) {
ad->set( *(T*)(blob) );
return true;
}
return false;
}
virtual bool composeType( base::DataSourceBase::shared_ptr source, base::DataSourceBase::shared_ptr result) const {
const internal::DataSource<PropertyBag>* pb = dynamic_cast< const internal::DataSource<PropertyBag>* > (source.get() );
if ( !pb )
return false;
typename internal::AssignableDataSource<UserType>::shared_ptr ads = boost::dynamic_pointer_cast< internal::AssignableDataSource<UserType> >( result );
if ( !ads )
return false;
// last fall-back: use user supplied function:
if ( composeTypeImpl( pb->rvalue(), ads->set() ) )
ads->updated();
else {
Logger::log() <<Logger::Debug<<"Failed to compose from "<< source->getTypeName() <<Logger::endl;
return false;
}
Logger::log() <<Logger::Debug<<"Successfuly composed type from "<< source->getTypeName() <<Logger::endl;
return true;
}
virtual base::DataSourceBase::shared_ptr getMember(base::DataSourceBase::shared_ptr item,
base::DataSourceBase::shared_ptr id) const {
typename internal::AssignableDataSource<T>::shared_ptr data = boost::dynamic_pointer_cast< internal::AssignableDataSource<T> >( item );
if ( !data ) {
if ( !item->isAssignable() )
log(Error) << "Can't return reference to members of type "<< this->getTypeName() <<" since given object is not assignable." <<endlog();
else
log(Error) << "Consistency error: TypeInfo of type "<< this->getTypeName() <<" can't handle types of type "<< item->getType() <<endlog();
return base::DataSourceBase::shared_ptr();
}
// discover if user gave us a part name or index:
typename internal::DataSource<int>::shared_ptr id_indx = internal::DataSource<int>::narrow( id.get() );
typename internal::DataSource<string>::shared_ptr id_name = internal::DataSource<string>::narrow( id.get() );
if ( id_name ) {
if ( id_name->get() == "size" ) {
try {
return internal::newFunctorDataSource(&get_size<T>, internal::GenerateDataSource()(item.get()) );
} catch(...) {}
}
if ( id_name->get() == "capacity" ) {
try {
return internal::newFunctorDataSource(&get_capacity<T>, internal::GenerateDataSource()(item.get()) );
} catch(...) {}
}
}
if ( id_indx ) {
try {
return internal::newFunctorDataSource(&get_container_item<T>, internal::GenerateDataSource()(item.get(), id_indx.get() ) );
} catch(...) {}
}
if (id_name) {
log(Error) << "MatrixTypeInfo: No such part : " << id_name->get() << endlog();
}
if (id_indx) {
log(Error) << "MatrixTypeInfo: Invalid index : " << id_indx->get() <<":"<< id_indx->getTypeName() << endlog();
}
return base::DataSourceBase::shared_ptr();
}
bool resize(base::DataSourceBase::shared_ptr arg, int size_rows, int size_columns) const
{
if (arg->isAssignable()) {
typename internal::AssignableDataSource<T>::shared_ptr asarg = internal::AssignableDataSource<T>::narrow( arg.get() );
asarg->set().resize( size_rows, size_columns );
asarg->updated();
return true;
}
return false;
}
virtual base::DataSourceBase::shared_ptr getMember(base::DataSourceBase::shared_ptr item,
base::DataSourceBase::shared_ptr id) const {
using namespace internal;
typename DataSource<T>::shared_ptr data = boost::dynamic_pointer_cast< DataSource<T> >( item );
if ( !data ) {
return base::DataSourceBase::shared_ptr();
}
// discover if user gave us a part name or index:
typename DataSource<string>::shared_ptr id_name = DataSource<string>::narrow( id.get() );
if ( id_name ) {
// size and capacity can not change during program execution:
if (id_name->get() == "size" || id_name->get() == "capacity") {
return new ConstantDataSource<int>( data->rvalue().count() );
} else {
log(Error) << "CArrayTypeInfo: No such part : " << id_name->get() << endlog();
return base::DataSourceBase::shared_ptr();
}
}
typename AssignableDataSource<T>::shared_ptr adata = boost::dynamic_pointer_cast< AssignableDataSource<T> >( item );
if ( !adata ) {
log(Error) << "CArrayTypeInfo: need assignable data type for indexing " << this->getTypeName() << endlog();
return base::DataSourceBase::shared_ptr();
}
typename DataSource<unsigned int>::shared_ptr id_indx = DataSource<unsigned int>::narrow( DataSourceTypeInfo<unsigned int>::getTypeInfo()->convert(id).get() );
if ( id_indx ) {
return new ArrayPartDataSource<typename T::value_type>( *adata->set().address(), id_indx, item, data->rvalue().count() );
}
log(Error) << "CArrayTypeInfo: Invalid index) for type " << this->getTypeName() << endlog();
return base::DataSourceBase::shared_ptr();
}