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;
}
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 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();
}