ManagedIceObject.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)
* @author     Jan Issac (jan dot issac at gmx dot de)
* @date       2011
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include <ArmarXCore/core/system/ImportExport.h>                    // for ARMARXCORE_IMPORT_EXPORT
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>   // for ARMARX_CHECK_EXPRESSION
#include <ArmarXCore/core/exceptions/LocalException.h>              // for LocalException
#include <ArmarXCore/core/logging/Logging.h>                        // for Logging
#include <ArmarXCore/core/ArmarXFwd.h>                              // for ArmarXManagerPtr, etc
#include <ArmarXCore/core/IceManager.h>                             // for IceManagerPtr
#include <ArmarXCore/core/ManagedIceObjectPlugin.h>
 
#include <Ice/Handle.h>                 // for Handle
#include <Ice/Object.h>                 // for Object
#include <Ice/ProxyF.h>                 // for ObjectPrx
#include <IceUtil/Handle.h>             // for HandleBase
 
#include <type_traits>
#include <typeindex>
#include <string>                       // for string
#include <vector>                       // for vector
#include <memory>                       // for unique_ptr
 
// Forward declarations
namespace std::experimental
{
    inline namespace fundamentals_v2
    {
        template <typename T>
        class observer_ptr;
        
        template<typename _Tp>
        observer_ptr<_Tp>
        make_observer(_Tp* __p) noexcept;
    }
}
 
namespace Ice
{
 
    class Communicator;
    ICE_API ::Ice::LocalObject* upCast(::Ice::Communicator*);
    typedef ::IceInternal::Handle< ::Ice::Communicator> CommunicatorPtr;
 
    class ObjectAdapter;
    ICE_API ::Ice::LocalObject* upCast(::Ice::ObjectAdapter*);
    typedef ::IceInternal::Handle< ::Ice::ObjectAdapter> ObjectAdapterPtr;
 
}
 
namespace armarx::Profiler
{
    class Profiler;
    using ProfilerPtr = std::shared_ptr<Profiler>;
}
namespace armarx
{
    template<class> class SimplePeriodicTask;
#define TYPEDEF_PTRS_SHARED(T)                                      \
    class T;                                                        \
    using T##Ptr = ::std::shared_ptr<T>;                            \
    using Const##T##Ptr = ::std::shared_ptr<const T>
 
#define TYPEDEF_PTRS_HANDLE(T)          \
    class T;                            \
    using T##Ptr = IceUtil::Handle<T>
 
    template<class T, class...Args>
    auto make_shared(Args&& ...args)
    {
        if constexpr(
            std::is_base_of_v<IceUtil::Shared, T> ||
            std::is_base_of_v<IceUtil::SimpleShared, T>
        )
        {
            return IceUtil::Handle<T>(
                       new T(std::forward<Args>(args)...)
                   );
        }
        else
        {
            return std::make_shared<T>(std::forward<Args>(args)...);
        }
    }
}
namespace armarx
{
    class VariantBase;
    typedef ::IceInternal::Handle<::armarx::VariantBase> VariantBasePtr;
    using StringVariantBaseMap = std::map<std::string, VariantBasePtr>;
 
    class ManagedIceObject;
 
    struct ManagedIceObjectConnectivity;
 
 
    class ManagedIceObjectPlugin;
 
    using ManagedIceObjectPtr = IceInternal::Handle<ManagedIceObject>;
 
    class ARMARXCORE_IMPORT_EXPORT ManagedIceObject :
        virtual public Ice::Object,
        virtual public Logging
 
    {
    private:
        friend class Component;
        friend class ManagedIceObjectPlugin;
        std::map<std::pair<std::type_index, std::string>, std::unique_ptr<ManagedIceObjectPlugin>> _plugins;
 
        void foreach_plugin(std::function<void(std::type_index, std::string const&, ManagedIceObjectPlugin*)> const& f,
                            int line, const char* file, const char* function);
 
    protected:
 
        std::unique_ptr<ManagedIceObjectPlugin>& getPluginPointer(std::type_info const& type, std::string const& prefix);
 
 
        template <class PluginT, class...ParamsT>
        PluginT* addPlugin(const std::string prefix = "", ParamsT && ...params)
        {
            static_assert(std::is_base_of_v<ManagedIceObjectPlugin, PluginT>);
            auto& ptr = getPluginPointer(typeid(PluginT), prefix);
            if (ptr)
            {
                auto tptr = dynamic_cast<PluginT*>(ptr.get());
                ARMARX_CHECK_NOT_NULL(tptr) << "Plugin is of wrong type. This should be impossible!";
                return tptr;
            }
            PluginT* tptr = new PluginT(*this, prefix, std::forward<ParamsT>(params)...);
            ptr.reset(tptr);
            return tptr;
        }
 
        template<class PluginT, class...ParamsT>
        void addPlugin(PluginT*& targ, const std::string prefix = "", ParamsT && ...params)
        {
            ARMARX_CHECK_NULL(targ) << "This is an out parameter";
            targ = addPlugin<PluginT>(prefix, std::forward<ParamsT>(params)...);
        }
 
        template<class PluginT, class...ParamsT>
        void addPlugin(std::experimental::observer_ptr<PluginT>& targ, const std::string prefix = "", ParamsT && ...params)
        {
            ARMARX_CHECK_NULL(targ) << "This is an out parameter";
            targ = std::experimental::make_observer(addPlugin<PluginT>(prefix, std::forward<ParamsT>(params)...));
        }
 
 
    private:
        friend class ArmarXObjectScheduler;
        friend class ArmarXManager;
 
    public:
        using PeriodicTaskPtr = IceUtil::Handle<SimplePeriodicTask<std::function<void(void)>>>;
 
        static const ManagedIceObjectPtr NullPtr;
 
        ManagedIceObject(ManagedIceObject const& other);
 
 
        std::string getName() const;
 
        static std::string generateSubObjectName(const std::string& superObjectName, const std::string& subObjectName);
 
        std::string generateSubObjectName(const std::string& subObjectName);
 
        Ice::ObjectPrx getProxy(long timeoutMs = 0, bool waitForScheduler = true) const;
        template<class Prx>
        Prx getProxy(long timeoutMs = 0, bool waitForScheduler = true) const
        {
            return Prx::checkedCast(getProxy(timeoutMs, waitForScheduler));
        }
        template<class Prx>
        void getProxy(Prx& prx, long timeoutMs = 0, bool waitForScheduler = true) const
        {
            prx = Prx::checkedCast(getProxy(timeoutMs, waitForScheduler));
        }
 
        int getState() const;
 
 
 
        ArmarXObjectSchedulerPtr getObjectScheduler() const;
 
        ManagedIceObjectConnectivity getConnectivity() const;
 
        ArmarXManagerPtr getArmarXManager() const;
 
        IceManagerPtr getIceManager() const;
 
        bool usingProxy(const std::string& name,
                        const std::string& endpoints = "");
 
        void waitForProxy(std::string const& name, bool addToDependencies);
 
        template <class ProxyType>
        ProxyType getProxy(const std::string& name,
                           bool addToDependencies = false,
                           const std::string& endpoints = "",
                           bool throwOnProxyError = true)
        {
            waitForProxy(name, addToDependencies);
 
            // return proxy
            try
            {
                return getIceManager()->getProxy<ProxyType>(name, endpoints);
            }
            catch (...)
            {
                if (throwOnProxyError)
                {
                    throw;
                }
                else
                {
                    return nullptr;
                }
            }
        }
 
        template <class ProxyTarg, class...Args>
        void getProxy(IceInternal::ProxyHandle<ProxyTarg>& proxy, const std::string& name, Args&& ...args)
        {
            using ProxyType = IceInternal::ProxyHandle<ProxyTarg>;
            proxy = getProxy<ProxyType>(name, std::forward<Args>(args)...);
        }
        template <class ProxyTarg, class...Args>
        void getProxy(const std::string& name, IceInternal::ProxyHandle<ProxyTarg>& proxy, Args&& ...args)
        {
            using ProxyType = IceInternal::ProxyHandle<ProxyTarg>;
            proxy = getProxy<ProxyType>(name, std::forward<Args>(args)...);
        }
        template <class ProxyTarg, class...Args>
        void getProxy(IceInternal::ProxyHandle<ProxyTarg>& proxy, const char* name, Args&& ...args)
        {
            using ProxyType = IceInternal::ProxyHandle<ProxyTarg>;
            proxy = getProxy<ProxyType>(name, std::forward<Args>(args)...);
        }
        template <class ProxyTarg, class...Args>
        void getProxy(const char* name, IceInternal::ProxyHandle<ProxyTarg>& proxy, Args&& ...args)
        {
            using ProxyType = IceInternal::ProxyHandle<ProxyTarg>;
            proxy = getProxy<ProxyType>(name, std::forward<Args>(args)...);
        }
 
        template <class ProxyType>
        inline void getProxy(ProxyType& proxy, const char* name,
                             bool addToDependencies = false,
                             const std::string& endpoints = "",
                             bool throwOnProxyError = true)
        {
            getProxy<ProxyType>(proxy, std::string(name), addToDependencies, endpoints, throwOnProxyError);
        }
 
        std::vector<std::string> getUnresolvedDependencies() const;
 
        static std::string GetObjectStateAsString(int state);
 
        Profiler::ProfilerPtr getProfiler() const;
 
        void enableProfiler(bool enable);
 
        Ice::ObjectAdapterPtr getObjectAdapter() const;
 
        void usingTopic(const std::string& name, bool orderedPublishing = false);
 
        bool unsubscribeFromTopic(const std::string& name);
 
        void offeringTopic(const std::string& name);
 
        void preambleGetTopic(std::string const& name);
 
        template <class TopicProxyType>
        TopicProxyType getTopic(const std::string& name)
        {
            preambleGetTopic(name);
 
            // retrieve topic
            return getIceManager()->getTopic<TopicProxyType>(name);
        }
 
        template <class TopicProxyType>
        void getTopic(TopicProxyType& topicProxy, const std::string& name)
        {
            topicProxy = getTopic<TopicProxyType>(name);
        }
 
        void waitForObjectScheduler();
 
        virtual std::string getDefaultName() const = 0;
 
        void setMetaInfo(const std::string& id, const VariantBasePtr& value);
        VariantBasePtr getMetaInfo(const std::string& id);
        StringVariantBaseMap getMetaInfoMap() const;
 
        void startPeriodicTask(const std::string& uniqueName,
                               std::function<void(void)> f,
                               int periodMs,
                               bool assureMeanInterval = false,
                               bool forceSystemTime = true);
        bool stopPeriodicTask(const std::string& name);
        PeriodicTaskPtr getPeriodicTask(const std::string& name);
    protected:
        ManagedIceObject();
        ~ManagedIceObject() override;
 
        bool removeProxyDependency(const std::string& name);
 
 
        void terminate();
 
        void setName(std::string name);
 
        virtual void onInitComponent() = 0;
        virtual void preOnInitComponent() {}
        virtual void postOnInitComponent() {}
 
        virtual void onConnectComponent() = 0;
        virtual void preOnConnectComponent() {}
        virtual void postOnConnectComponent() {}
 
        virtual void onDisconnectComponent() {}
        virtual void preOnDisconnectComponent() {}
        virtual void postOnDisconnectComponent() {}
 
        virtual void onExitComponent() {}
        virtual void preOnExitComponent() {}
        virtual void postOnExitComponent() {}
 
        Ice::CommunicatorPtr getCommunicator() const;
 
    private:
        // init sets members and calls onInitComponent hook
        void init(IceManagerPtr iceManager);
        // start sets members and calls onConnectComponent hook
        void start(Ice::ObjectPrx& proxy, const Ice::ObjectAdapterPtr& objectAdapter);
        void disconnect();
        // exit sets members and calls onExitComponent hook
        void exit();
 
        void setObjectState(int newState);
 
    private:
        struct Impl;
        std::unique_ptr<Impl> impl;
 
        static void Noop(ManagedIceObject* object);
 
        static void EnableProfilerOn(ManagedIceObject* object);
    };
 
}