TypeInfo.hpp

Go to the documentation of this file.

/***************************************************************************
  tag: Peter Soetens  Mon Jan 19 14:11:26 CET 2004  TypeInfo.hpp

                        TypeInfo.hpp -  description
                           -------------------
    begin                : Mon January 19 2004
    copyright            : (C) 2004 Peter Soetens
    email                : peter.soetens@mech.kuleuven.ac.be

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU General Public                   *
 *   License as published by the Free Software Foundation;                 *
 *   version 2 of the License.                                             *
 *                                                                         *
 *   As a special exception, you may use this file as part of a free       *
 *   software library without restriction.  Specifically, if other files   *
 *   instantiate templates or use macros or inline functions from this     *
 *   file, or you compile this file and link it with other files to        *
 *   produce an executable, this file does not by itself cause the         *
 *   resulting executable to be covered by the GNU General Public          *
 *   License.  This exception does not however invalidate any other        *
 *   reasons why the executable file might be covered by the GNU General   *
 *   Public License.                                                       *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU General Public             *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/

#ifndef ORO_CORELIB_TYPEINFO_HPP
#define ORO_CORELIB_TYPEINFO_HPP

#include <vector>
#include <string>
#include "../base/DataSourceBase.hpp"
#include "../base/ChannelElementBase.hpp"

#ifndef NO_TYPE_INFO_FACTORY_FUNCTIONS
#include "../internal/ConnFactory.hpp"
#include "MemberFactory.hpp"
#include "ValueFactory.hpp"
#include "CompositionFactory.hpp"
#ifndef NO_TYPE_INFO_STREAMS
#include "StreamFactory.hpp"
#endif
#endif


namespace RTT
{ namespace types {
        using internal::ConnFactory;
        using internal::ConnFactoryPtr;

    class RTT_API TypeInfo
    {
    public:
        typedef const std::type_info * TypeId;

        TypeInfo(const std::string& name) : mtypenames(1,name) {}

        ~TypeInfo();
        const std::string& getTypeName() const { return mtypenames[0]; }

        std::vector<std::string> getTypeNames() const;

        void addAlias(const std::string& alias);

        bool isType(const std::string& name);
        
        TypeId getTypeId() const { return mtid; }

        const char * getTypeIdName() const { return mtid_name; }

        base::DataSourceBase::shared_ptr construct(const std::vector<base::DataSourceBase::shared_ptr>& args) const;

        base::DataSourceBase::shared_ptr convert(base::DataSourceBase::shared_ptr arg) const;

        void addConstructor(TypeConstructor* tb);

        bool addProtocol(int protocol_id, TypeTransporter* tt);

        TypeTransporter* getProtocol(int protocol_id) const;

        bool hasProtocol(int protocol_id) const;

        std::vector<int> getTransportNames() const;

#ifndef NO_TYPE_INFO_FACTORY_FUNCTIONS

        base::AttributeBase* buildConstant(std::string name,base::DataSourceBase::shared_ptr source, int sizehint) const
        {
            return mdsf ? mdsf->buildConstant(name, source, sizehint) : 0;
        }

        base::AttributeBase* buildConstant(std::string name,base::DataSourceBase::shared_ptr source) const
        {
            return mdsf ? mdsf->buildConstant(name, source) : 0;
        }
        base::AttributeBase* buildVariable(std::string name,int sizehint) const;
        base::AttributeBase* buildVariable(std::string name) const
        {
            return mdsf ? mdsf->buildVariable(name) : 0;
        }

        bool resize(base::DataSourceBase::shared_ptr arg, int size) const
        {
            return mmembf ? mmembf->resize(arg, size) : false;
        }

        base::AttributeBase* buildAlias(std::string name, base::DataSourceBase::shared_ptr b ) const
        {
            return mdsf ? mdsf->buildAlias(name, b) : 0;
        }

        base::PropertyBase* buildProperty(const std::string& name, const std::string& desc, base::DataSourceBase::shared_ptr source = 0) const
        {
            return mdsf ? mdsf->buildProperty(name, desc, source) : 0;
        }

        base::AttributeBase* buildAttribute(std::string name, base::DataSourceBase::shared_ptr source = 0 ) const
        {
            return mdsf ? mdsf->buildAttribute(name, source) : 0;
        }

        base::DataSourceBase::shared_ptr buildValue() const
        {
            return mdsf ? mdsf->buildValue() : base::DataSourceBase::shared_ptr();
        }

        base::DataSourceBase::shared_ptr buildReference(void* ptr) const
        {
            return mdsf ? mdsf->buildReference(ptr) : base::DataSourceBase::shared_ptr();
        }

        base::DataSourceBase::shared_ptr buildActionAlias(base::ActionInterface* action, base::DataSourceBase::shared_ptr source) const
        {
            return mdsf ? mdsf->buildActionAlias(action,source) : base::DataSourceBase::shared_ptr();
        }

#ifndef NO_TYPE_INFO_STREAMS

        std::ostream& write(std::ostream& os, base::DataSourceBase::shared_ptr in ) const
        {
            return mstrf ? mstrf->write(os, in) : os;
        }

        std::istream& read(std::istream& os, base::DataSourceBase::shared_ptr out ) const
        {
            return mstrf ? mstrf->read(os, out) : os;
        }


        std::string toString( base::DataSourceBase::shared_ptr in ) const
        {
            return mstrf ? mstrf->toString(in) : std::string();
        }

        bool fromString( const std::string& value, base::DataSourceBase::shared_ptr out ) const
        {
            return mstrf ? mstrf->fromString(value, out) : false;
        }

        bool isStreamable() const
        {
            return mstrf ? mstrf->isStreamable() : false;
        }
#endif

        std::vector<std::string> getMemberNames() const
        {
            return mmembf ? mmembf->getMemberNames() : std::vector<std::string>();
        }

        base::DataSourceBase::shared_ptr getMember(base::DataSourceBase::shared_ptr item, const std::string& name) const
        {
            return mmembf ? mmembf->getMember(item,name) : base::DataSourceBase::shared_ptr();
        }

        bool getMember(internal::Reference* ref, base::DataSourceBase::shared_ptr item, const std::string& name) const
        {
            return mmembf ? mmembf->getMember(ref, item,name) : false;
        }

        base::DataSourceBase::shared_ptr getMember(base::DataSourceBase::shared_ptr item,
                                                   base::DataSourceBase::shared_ptr id) const
        {
            return mmembf ? mmembf->getMember(item,id) : base::DataSourceBase::shared_ptr();
        }

        bool composeType( base::DataSourceBase::shared_ptr source, base::DataSourceBase::shared_ptr target) const
        {
            return mcompf ? mcompf->composeType(source,target) : false;
        }

        base::DataSourceBase::shared_ptr decomposeType(base::DataSourceBase::shared_ptr source) const
        {
            return mcompf ? mcompf->decomposeType(source) : base::DataSourceBase::shared_ptr();
        }

        base::DataSourceBase::shared_ptr convertType(base::DataSourceBase::shared_ptr source) const
        {
            return mcompf ? mcompf->convertType(source) : base::DataSourceBase::shared_ptr();
        }

        base::InputPortInterface* inputPort(std::string const& name) const
        {
            return mconnf ? mconnf->inputPort(name) : 0; 
        }

        base::OutputPortInterface* outputPort(std::string const& name) const
        {
            return mconnf ? mconnf->outputPort(name) : 0; 
        }

        base::ChannelElementBase::shared_ptr buildDataStorage(ConnPolicy const& policy) const
        {
            return mconnf ? mconnf->buildDataStorage(policy) : base::ChannelElementBase::shared_ptr();
        }
        base::ChannelElementBase::shared_ptr buildChannelOutput(base::InputPortInterface& port) const
        {
            return mconnf ? mconnf->buildChannelOutput(port) : base::ChannelElementBase::shared_ptr();
        }
        base::ChannelElementBase::shared_ptr buildChannelInput(base::OutputPortInterface& port) const
        {
            return mconnf ? mconnf->buildChannelInput(port) : base::ChannelElementBase::shared_ptr();
        }

#endif // NO_TYPE_INFO_FACTORY_FUNCTIONS

        void setTypeId(TypeId tid) {
            mtid = tid;
            mtid_name = tid->name();
        }

        void setPortFactory( ConnFactoryPtr cf ) { if (cf) mconnf = cf; }

        ConnFactoryPtr getPortFactory() const { return mconnf; }

        void setMemberFactory( MemberFactoryPtr mf ) { if (mf) mmembf = mf; }

        MemberFactoryPtr getMemberFactory() const { return mmembf; }

        void setValueFactory( ValueFactoryPtr dsf) { if (dsf) mdsf = dsf; }

        ValueFactoryPtr getValueFactory() const { return mdsf; }

        void setCompositionFactory( CompositionFactoryPtr cf) { if(cf) mcompf = cf; }

        CompositionFactoryPtr getCompositionFactory() const { return mcompf; }

        void setStreamFactory( StreamFactoryPtr sf ) { if (sf) mstrf = sf; }

        StreamFactoryPtr getStreamFactory() const { return mstrf; }
    protected:
        typedef std::vector<TypeConstructor*> Constructors;
        typedef std::vector<TypeTransporter*> Transporters;
        Constructors constructors;
        Transporters transporters;
        std::vector<std::string> mtypenames;
        const char* mtid_name;
        TypeId mtid;
        boost::shared_ptr<ConnFactory> mconnf;
        boost::shared_ptr<MemberFactory> mmembf;
        boost::shared_ptr<ValueFactory> mdsf;
        boost::shared_ptr<CompositionFactory> mcompf;
        boost::shared_ptr<StreamFactory> mstrf;
    };

}}

#endif