00001 /*************************************************************************** 00002 tag: The SourceWorks Tue Sep 7 00:55:18 CEST 2010 StructTypeInfo.hpp 00003 00004 StructTypeInfo.hpp - description 00005 ------------------- 00006 begin : Tue September 07 2010 00007 copyright : (C) 2010 The SourceWorks 00008 email : peter@thesourceworks.com 00009 00010 *************************************************************************** 00011 * This library is free software; you can redistribute it and/or * 00012 * modify it under the terms of the GNU General Public * 00013 * License as published by the Free Software Foundation; * 00014 * version 2 of the License. * 00015 * * 00016 * As a special exception, you may use this file as part of a free * 00017 * software library without restriction. Specifically, if other files * 00018 * instantiate templates or use macros or inline functions from this * 00019 * file, or you compile this file and link it with other files to * 00020 * produce an executable, this file does not by itself cause the * 00021 * resulting executable to be covered by the GNU General Public * 00022 * License. This exception does not however invalidate any other * 00023 * reasons why the executable file might be covered by the GNU General * 00024 * Public License. * 00025 * * 00026 * This library is distributed in the hope that it will be useful, * 00027 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00028 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00029 * Lesser General Public License for more details. * 00030 * * 00031 * You should have received a copy of the GNU General Public * 00032 * License along with this library; if not, write to the Free Software * 00033 * Foundation, Inc., 59 Temple Place, * 00034 * Suite 330, Boston, MA 02111-1307 USA * 00035 * * 00036 ***************************************************************************/ 00037 00038 00039 #ifndef ORO_STRUCT_TYPE_INFO_HPP 00040 #define ORO_STRUCT_TYPE_INFO_HPP 00041 00042 #include "TemplateTypeInfo.hpp" 00043 #include "type_discovery.hpp" 00044 00045 namespace RTT 00046 { 00047 namespace types 00048 { 00059 template<typename T, bool has_ostream = false> 00060 class StructTypeInfo: public TemplateTypeInfo<T, has_ostream> 00061 { 00062 public: 00063 StructTypeInfo(std::string name) : 00064 TemplateTypeInfo<T, has_ostream> (name) 00065 { 00066 } 00067 00068 virtual std::vector<std::string> getMemberNames() const { 00069 // only discover the parts of this struct: 00070 type_discovery in; 00071 T t; // boost can't work without a value. 00072 in.discover( t ); 00073 return in.mnames; 00074 } 00075 00076 virtual base::DataSourceBase::shared_ptr getMember(base::DataSourceBase::shared_ptr item, const std::string& name) const { 00077 typename internal::AssignableDataSource<T>::shared_ptr adata = boost::dynamic_pointer_cast< internal::AssignableDataSource<T> >( item ); 00078 if ( adata ) { 00079 type_discovery in( item ); 00080 in.discover( adata->set() ); 00081 log(Debug) << "Returning part: " << name << endlog(); 00082 return in.getMember(name); 00083 } 00084 typename internal::DataSource<T>::shared_ptr data = boost::dynamic_pointer_cast< internal::DataSource<T> >( item ); 00085 if ( data ) { 00086 adata = new internal::ValueDataSource<T>( data->get() ); 00087 type_discovery in( adata ); 00088 in.discover( adata->set() ); 00089 log(Debug) << "Returning copy of part: " << name << endlog(); 00090 return in.getConstMember(name); 00091 } 00092 log(Error) << "Wrong call to type info function " + this->getTypeName() << "'s getMember() can not process "<< item->getTypeName() <<endlog(); 00093 return base::DataSourceBase::shared_ptr(); 00094 } 00095 00101 virtual bool composeTypeImpl(const PropertyBag& source, typename internal::AssignableDataSource<T>::reference_t result) const { 00102 // The default implementation decomposes result and refreshes it with source. 00103 internal::ReferenceDataSource<T> rds(result); 00104 rds.ref(); // prevent dealloc. 00105 PropertyBag decomp; 00106 // only try refreshProperties if decomp's type is equal to source type. 00107 // update vs refresh: since it is intentional that the decomposition leads to references to parts of result, 00108 // only refreshProperties() is meaningful (ie we have a one-to-one mapping). In case of sequences, this would 00109 // of course not match, so this is struct specific. 00110 return typeDecomposition( &rds, decomp, false) && ( decomp.getType() == source.getType() ) && refreshProperties(decomp, source); 00111 } 00112 00113 00114 }; 00115 } 00116 } 00117 00118 #endif