virtual bool updateAny( base::DataSourceBase::shared_ptr source, CORBA::Any& any) const { if (warn) { Logger::In in("CorbaFallBackProtocol"); log(Error) << "Could not send data of type '"<< source->getTypeName()<<"' : data type not known to CORBA Transport." <<Logger::endl; } source->evaluate(); 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; }
/** * 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; }
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 convert(base::DataSourceBase::shared_ptr arg) const { if ( boost::function_traits<S>::arity != 1) { return base::DataSourceBase::shared_ptr(); } else { // The compiler should optimise this out... // these checks are necessary because produce(args) calls convert, which could lead to endless loops. // detect same type converion. if ( arg->getTypeInfo() == internal::DataSourceTypeInfo<result_type>::getTypeInfo() ) { return arg; } // detect invalid type conversion. if ( arg->getTypeInfo() != internal::DataSourceTypeInfo<arg1_type>::getTypeInfo() ) { return base::DataSourceBase::shared_ptr(); } // from now on, it should always succeed. std::vector<base::DataSourceBase::shared_ptr> args; args.push_back(arg); base::DataSourceBase::shared_ptr ret = this->build(args); assert( ret ); if (!automatic) log(Warning) << "Conversion from " << arg->getTypeName() << " to " << ret->getTypeName() <<endlog(); return ret; } }
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(); }
virtual bool getMember(internal::Reference* ref, base::DataSourceBase::shared_ptr item, const std::string& name) const { typename internal::AssignableDataSource<T>::shared_ptr adata = boost::dynamic_pointer_cast< internal::AssignableDataSource<T> >( item ); // Use a copy in case our parent is not assignable: if ( !adata ) { // is it non-assignable ? typename internal::DataSource<T>::shared_ptr data = boost::dynamic_pointer_cast< internal::DataSource<T> >( item ); if ( data ) { // create a copy -> this is the only place & case where we allocate -> how to fix ? adata = new internal::ValueDataSource<T>( data->get() ); } } if (adata) { type_discovery in( adata ); return in.referenceMember( ref, adata->set(), name ); } log(Error) << "Wrong call to type info function " + this->getTypeName() << "'s getMember() can not process "<< item->getTypeName() <<endlog(); return false; }
virtual base::DataSourceBase::shared_ptr getMember(base::DataSourceBase::shared_ptr item, const std::string& name) const { typename internal::AssignableDataSource<T>::shared_ptr adata = boost::dynamic_pointer_cast< internal::AssignableDataSource<T> >( item ); // Use a copy in case our parent is not assignable: if ( !adata ) { // is it non-assignable ? typename internal::DataSource<T>::shared_ptr data = boost::dynamic_pointer_cast< internal::DataSource<T> >( item ); if ( data ) { // create a copy adata = new internal::ValueDataSource<T>( data->get() ); } } if (adata) { type_discovery in( adata ); return in.discoverMember( adata->set(), name ); } log(Error) << "Wrong call to type info function " + this->getTypeName() << "'s getMember() can not process "<< item->getTypeName() <<endlog(); return base::DataSourceBase::shared_ptr(); }
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; }
/** * 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 ActionInterface* copy( std::map<const DataSourceBase*, DataSourceBase*>& alreadyCloned ) const { vector<DataSourceBase::shared_ptr> argcopy( margs.size() ); unsigned int v=0; for (vector<DataSourceBase::shared_ptr>::iterator it = argcopy.begin(); it != argcopy.end(); ++it, ++v) argcopy[v] = (*it)->copy(alreadyCloned); return new CorbaOperationCallerCall(CService::_duplicate( mfact.in() ), mop, argcopy, mcaller, mctt, mresult->copy(alreadyCloned), mdocall); }
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; } }
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 ArrayPartDataSource<T>* copy( std::map<const base::DataSourceBase*, base::DataSourceBase*>& replace ) const { // if somehow a copy exists, return the copy, otherwise return this (see Attribute copy) if ( replace[this] != 0 ) { assert ( dynamic_cast<ArrayPartDataSource<T>*>( replace[this] ) == static_cast<ArrayPartDataSource<T>*>( replace[this] ) ); return static_cast<ArrayPartDataSource<T>*>( replace[this] ); } replace[this] = new ArrayPartDataSource<T>(*mref, mindex->copy(replace), mparent->copy(replace), mmax); return static_cast<ArrayPartDataSource<T>*>(replace[this]); }
void updated() { if (mparent) mparent->updated(); }
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(); }