Component.h

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @package    ArmarXCore::core
* @author     Kai Welke (welke at kit dot edu)
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include <ArmarXCore/core/system/ImportExport.h>
#include <ArmarXCore/core/ManagedIceObject.h>  // for ManagedIceObject
#include <ArmarXCore/core/ComponentPlugin.h>
#include <ArmarXCore/core/application/properties/PropertyUser.h>
#include <ArmarXCore/core/application/properties/PropertyDefinition.h>
#include <ArmarXCore/core/application/properties/PropertyDefinition.hpp>
#include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
#include <ArmarXCore/util/CPPUtility/GetTypeString.h>
 
#include <Ice/Handle.h>                 // for Handle
 
#include <string>                       // for string
 
// Forward declarations
namespace Ice
{
    Ice::PropertiesPtr createProperties();
}
 
namespace armarx
{
 
    class Component;
 
    using ComponentPtr = IceInternal::Handle<Component>;
 
    class ComponentPlugin;
 
 
    class ComponentPropertyDefinitions :
        public PropertyDefinitionContainer
    {
    public:
 
        ComponentPropertyDefinitions(std::string prefix, bool hasObjectNameParameter = true);
    };
 
 
    class ARMARXCORE_IMPORT_EXPORT Component :
        virtual public ManagedIceObject,
        virtual public PropertyUser
    {
    public:
        template <class T, class TPtr = IceInternal::Handle<T>>
        static TPtr create(Ice::PropertiesPtr properties = Ice::createProperties(),
                           const std::string& configName = "", const std::string& configDomain = "ArmarX")
        {
            ARMARX_TRACE;
            ARMARX_DEBUG_S << "create component (configName = " << configName
                           << ", configDomain = " << configDomain << " of type "
                           << GetTypeString<T>();
            TPtr ptr = new T();
            ptr->createdByComponentCreate = true;
 
            ComponentPtr compPtr = ptr;
 
            ARMARX_DEBUG_S << "initializing properties";
            if (configName == "")
            {
                ptr->initializeProperties(compPtr->getDefaultName(), properties, configDomain);
            }
            else
            {
                ptr->initializeProperties(configName, properties, configDomain);
            }
            ARMARX_DEBUG_S << "call post ini properties hook";
            compPtr->icePropertiesInitialized();
            ARMARX_DEBUG_S << "returning component";
            return ptr;
        }
 
        using PropertyUser::getProperty;
 
        virtual void componentPropertiesUpdated(const std::set<std::string>& changedProperties);
 
        virtual void preOnInitComponent() override;
        virtual void preOnConnectComponent() override;
 
        void initializeProperties(const std::string& configName, Ice::PropertiesPtr const& properties, const std::string& configDomain);
 
        void injectPropertyDefinitions(PropertyDefinitionsPtr& props) override;
 
        void forceComponentCreatedByComponentCreateFunc();
 
 
        std::vector<PropertyUserPtr> getAdditionalPropertyUsers() const;
 
 
        // Convenience wrappers for {offering|using|get}{Topic|Proxy}() with name from property.
 
        void offeringTopicFromProperty(const std::string& propertyName);
 
        void usingTopicFromProperty(const std::string& propertyName, bool orderedPublishing = false);
 
        bool usingProxyFromProperty(const std::string& propertyName, const std::string& endpoints = "");
 
        template <class TopicProxyType>
        TopicProxyType getTopicFromProperty(const std::string& propertyName)
        {
            return getTopic<TopicProxyType>(getProperty<std::string>(propertyName));
        }
        template <class TopicProxyType>
        void getTopicFromProperty(TopicProxyType& top, const std::string& propertyName)
        {
            top = getTopic<TopicProxyType>(getProperty<std::string>(propertyName));
        }
 
        template <class ProxyType>
        ProxyType getProxyFromProperty(const std::string& propertyName,
                                       bool addToDependencies = false,
                                       const std::string& endpoints = "",
                                       bool throwOnProxyError = true)
        {
            return getProxy<ProxyType>(getProperty<std::string>(propertyName),
                                       addToDependencies, endpoints, throwOnProxyError);
        }
        template <class ProxyType>
        void getProxyFromProperty(ProxyType& proxy, const std::string& propertyName,
                                  bool addToDependencies = false,
                                  const std::string& endpoints = "",
                                  bool throwOnProxyError = true)
        {
            proxy = getProxy<ProxyType>(getProperty<std::string>(propertyName),
                                        addToDependencies, endpoints, throwOnProxyError);
        }
 
 
    protected:
 
        Component();
 
 
        PropertyDefinitionsPtr createPropertyDefinitions() override;
 
        std::string getConfigDomain();
 
        std::string getConfigName();
 
        std::string getConfigIdentifier();
 
 
 
        virtual void icePropertiesInitialized() {}
 
        void addPropertyUser(const PropertyUserPtr& subPropertyUser);
 
 
    private:
 
        friend class ArmarXManager;
 
        void icePropertiesUpdated(const std::set<std::string>& changedProperties) override final;
 
 
        // idenfitication of properties
        std::string configDomain;
        std::string configName;
 
        std::vector<PropertyUserPtr> additionalPropertyUsers;
 
 
        bool createdByComponentCreate;
    };
 
}