Application.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     Nils Adermann (naderman at naderman dot de)
* @author     Kai Welke (welke at kit dot edu)
* @author     Jan Issac (jan dot issac at gmail dot com)
* @date       2010
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include "../ArmarXManager.h"
#include "../Component.h"               // for Component
#include "../logging/Logging.h"
#include "../system/ArmarXDataPath.h"
#include "../system/ImportExport.h"     // for ARMARXCORE_IMPORT_EXPORT
#include "../system/cmake/CMakePackageFinder.h"
#include "ApplicationOptions.h"
#include "ApplicationNetworkStats.h"    // for ApplicationNetworkStatsPtr
#include "ArmarXCore/core/ArmarXFwd.h"  // for ArmarXManagerPtr
#include "ArmarXCore/core/ManagedIceObjectRegistryInterface.h"
#include "ArmarXCore/core/application/properties/PropertyDefinitionContainer.h"
#include "ArmarXCore/core/exceptions/Exception.h"  // for LocalException
#include "properties/PropertyUser.h"    // for PropertyDefinitionsPtr, etc
 
#include <Ice/Application.h>            // for Application
#include <Ice/BuiltinSequences.h>       // for StringSeq
#include <Ice/PropertiesF.h>            // for PropertiesPtr
#include <IceUtil/Handle.h>             // for Handle, HandleBase
 
#include <string>                       // for string
#include <vector>                       // for vector
#include <mutex>
 
 
namespace Ice
{
    struct InitializationData;
}  // namespace Ice
 
#define xstr(s) stringify(s)
#define stringify(s) #s
 
namespace std
{
    class thread;
}
 
namespace armarx
{
    // forward declarations
    class ManagedIceObjectRegistryInterface;
    class ThreadPool;
    using ThreadPoolPtr = std::shared_ptr<ThreadPool>;
    class ApplicationNetworkStats;
    using ApplicationNetworkStatsPtr = ::IceUtil::Handle<ApplicationNetworkStats>;
 
    using ManagedIceObjectRegistryInterfacePtr = IceUtil::Handle<ManagedIceObjectRegistryInterface>;
 
    class Application;
 
    using ApplicationPtr = IceUtil::Handle<Application>;
 
    class ARMARXCORE_IMPORT_EXPORT ApplicationPropertyDefinitions:
        public PropertyDefinitionContainer
    {
    public:
        ApplicationPropertyDefinitions(std::string prefix);
    };
 
    class ARMARXCORE_IMPORT_EXPORT Application :
        public Ice::Application,
        public PropertyUser
    {
    public:
        Application();
        template <class T, typename ...Args>
        static ApplicationPtr createInstance(Args&&... args)
        {
            std::unique_lock lock(instanceMutex);
 
            if (instance)
            {
                throw LocalException("Application instance already created");
            }
 
            instance = ApplicationPtr(new T(std::forward<Args>(args)...));
 
            return instance;
        }
 
        static ApplicationPtr getInstance();
 
        static void setInstance(ApplicationPtr const& inst);
 
        static std::string GetVersion()
        {
#ifdef ARMARX_VERSION
            return xstr(ARMARX_VERSION);
#else
            return "undefined";
#endif
        }
 
        int run(int argc, char* argv[]) override;
 
        void setName(const std::string& name);
 
        std::string getName() const;
 
        void interruptCallback(int signal) override;
 
        void registerDataPathsFromDependencies(std::string dependencies);
 
        std::vector<std::string> getArmarXPackageNames();
 
        bool isPackageAutoDiscoveryEnabled();
 
        static std::string GetArmarXConfigDefaultPath(bool envVarExpanded = true);
        static Ice::StringSeq GetDefaultsPaths();
        static void LoadDefaultConfig(Ice::PropertiesPtr properties);
        static const std::string& GetProjectName();
        static const Ice::StringSeq& GetProjectDependencies();
 
        void setIceProperties(Ice::PropertiesPtr properties) override;
 
        void updateIceProperties(const Ice::PropertyDict& properties) override;
 
        void icePropertiesUpdated(const std::set<std::string>& changedProperties) override;
        static const std::string ArmarXUserConfigDirEnvVar;
 
        const ThreadPoolPtr& getThreadPool() const;
        bool getForbidThreadCreation() const;
        void setForbidThreadCreation(bool value);
        void enableLibLoading(bool enable = true);
 
        void storeCommandLineArguments(int argc, char* argv[]);
        const std::vector<std::string>& getCommandLineArguments() const;
    protected:
        PropertyDefinitionsPtr createPropertyDefinitions() override;
 
        virtual void setup(const ManagedIceObjectRegistryInterfacePtr& registry, Ice::PropertiesPtr properties) = 0;
 
        virtual int exec(const ArmarXManagerPtr& armarXManager);
 
        int doMain(int argc, char* argv[], const Ice::InitializationData& initData, Ice::Int i) override;
 
        void loadDefaultConfig(int argc, char* argv[], const Ice::InitializationData& initData);
 
        void loadDependentProjectDatapaths();
 
        virtual std::string getDomainName();
 
        ArmarXManagerPtr getArmarXManager();
 
 
 
        void showHelp(ApplicationOptions::Options& options);
 
        Ice::PropertiesPtr parseOptionsMergeProperties(int argc, char* argv[]);
 
 
        static void HandlerInterrupt(int sig);
 
 
        static void HandlerFault(int sig);
 
    private:
 
        void loadLibrariesFromProperties();
 
        static ApplicationPtr instance;
 
        static std::mutex instanceMutex;
 
        std::string applicationName;
 
        ArmarXManagerPtr armarXManager;
 
        ApplicationNetworkStatsPtr applicationNetworkStats;
 
        std::shared_ptr<std::thread> shutdownThread;
 
        static std::string ProjectName;
        static Ice::StringSeq ProjectDependendencies;
 
        ThreadPoolPtr threadPool;
        bool forbidThreadCreation = false;
        bool libLoadingEnabled = false;
 
        std::vector<std::string> commandLineArguments;
    };
 
    class DummyApplication : public Application
    {
        // Application interface
    protected:
        void setup(const ManagedIceObjectRegistryInterfacePtr& registry, Ice::PropertiesPtr properties) override
        {
        }
    };
}
 
namespace armarx::internal
{
    template<class ComponentT, class AppT>
    class SimpleSingleComponentApp : virtual public AppT
    {
        void setup(const ManagedIceObjectRegistryInterfacePtr& registry, Ice::PropertiesPtr properties) override
        {
            registry->addObject(Component::create<ComponentT>(properties, "", appConfigDomain));
        }
 
    public:
        std::string appConfigName;
        std::string appConfigDomain;
    };
}
 
namespace armarx
{
    template<class ComponentT, class AppT = armarx::Application>
    int runSimpleComponentApp(int argc, char* argv[], std::string appName, const std::string& configName = "", const std::string& configDomain = "ArmarX", bool enableLibLoading = false)
    {
        armarx::ApplicationPtr app = AppT::template createInstance<internal::SimpleSingleComponentApp<ComponentT, AppT> >();
 
        auto sApp = IceUtil::Handle<internal::SimpleSingleComponentApp<ComponentT, AppT> >::dynamicCast(app);
        sApp->appConfigDomain = configDomain;
        sApp->appConfigName = configName;
        app->enableLibLoading(enableLibLoading);
        app->setName(appName);
        app->storeCommandLineArguments(argc, argv);
        return app->main(argc, argv);
    }
 
    class MultipleComponentsApplication : public Application
    {
    public:
        MultipleComponentsApplication(std::vector<ComponentPtr> components) :
            components(components) {}
 
    private:
        std::vector<ComponentPtr> components;
 
        // Application interface
    protected:
        void setup(const ManagedIceObjectRegistryInterfacePtr& registry, Ice::PropertiesPtr properties) override
        {
            for (ComponentPtr comp : components)
            {
                registry->addObject(comp);
            }
        }
    };
 
    template<class ComponentType>
    std::vector<ComponentPtr> createComponents(ComponentType comp)
    {
        return {comp};
    }
 
    template<class ComponentType, class... ComponentTypes >
    std::vector<ComponentPtr> createComponents(ComponentType comp, ComponentTypes... components)
    {
        std::vector<ComponentPtr> result {comp};
        std::vector<ComponentPtr> tempResult = createComponents(components...);
        result.insert(result.end(), tempResult.begin(), tempResult.end());
        return result;
    }
 
    template<class... ComponentTypes >
    std::vector<ComponentPtr> createComponentsUtil(ComponentTypes&& ... components)
    {
        std::vector<ComponentPtr> result;
        std::vector<ComponentPtr> tempResult = createComponents(components...);
        result.insert(result.end(), tempResult.begin(), tempResult.end());
        return result;
    }
 
    template<class... ComponentTypes >
    std::tuple<armarx::ApplicationPtr, std::vector<ComponentPtr> > runMultipleComponentsApp(int argc, char* argv[], std::string appName, const std::string& configDomain = "ArmarX")
    {
        Ice::PropertiesPtr props = Ice::createProperties(argc, argv);
        std::vector<ComponentPtr> comps = createComponentsUtil(Component::create<ComponentTypes>(props, "", configDomain)...);
        armarx::ApplicationPtr app = new MultipleComponentsApplication(comps);
 
        app->setName(appName);
        return std::make_tuple(app, comps);
    }
 
}