Profile.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2017.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#ifndef __FWRUNTIME_PROFILE_PROFILE_HPP__
#define __FWRUNTIME_PROFILE_PROFILE_HPP__

#include "fwRuntime/config.hpp"

#include <fwCore/base.hpp>

#include <boost/filesystem/path.hpp>
#include <boost/make_shared.hpp>
#include <boost/utility.hpp>

#include <functional>
#include <vector>

#ifdef ANDROID
class android_app;
#endif

namespace fwRuntime
{

namespace profile
{

class Activater;
class Starter;
class Stopper;
class Initializer;
class Uninitializer;

class Profile : public ::fwCore::BaseObject
{
public:

    typedef std::vector< std::string >  ParamsContainer;
    typedef std::function< int () > RunCallbackType;

    fwCoreClassDefinitionsWithFactoryMacro( (Profile)(BaseObject), (()), std::make_shared< Profile >);

    FWRUNTIME_API Profile();

    FWRUNTIME_API ~Profile();

    FWRUNTIME_API void add( SPTR( Activater ) activater );

    FWRUNTIME_API void add( SPTR( Starter ) starter );

    FWRUNTIME_API void add( SPTR( Stopper ) stopper );

    FWRUNTIME_API void add( SPTR( Initializer ) initializer );

    FWRUNTIME_API void add( SPTR( Uninitializer ) uninitializer );

    FWRUNTIME_API void start();
    FWRUNTIME_API void stop();

    FWRUNTIME_API int run();
    FWRUNTIME_API int defaultRun();
    FWRUNTIME_API void setRunCallback(RunCallbackType callback);

    FWRUNTIME_API void setup();
    FWRUNTIME_API void cleanup();

    std::string getName() const
    {
        return m_sName;
    }

    void setName(std::string _sName)
    {
        m_sName = _sName;
    }

    ::boost::filesystem::path getFilePath() const
    {
        return m_filePath;
    }

    void setFilePath(const ::boost::filesystem::path& _filePath)
    {
        m_filePath = _filePath;
    }

    std::string getVersion() const
    {
        return m_sVersion;
    }

    void setVersion(std::string _sVersion)
    {
        m_sVersion = _sVersion;
    }

    bool getCheckSingleInstance() const
    {
        return m_checkSingleInstance;
    }

    void setCheckSingleInstance(bool _checkSingleInstance)
    {
        m_checkSingleInstance = _checkSingleInstance;
    }

#ifdef ANDROID
    android_app* getApp() const
    {
        return m_app;
    }
    //------------------------------------------------------------------------------

    void setApp(android_app* app)
    {
        m_app = app;
    }
#endif
    //------------------------------------------------------------------------------

    ParamsContainer getParams() const
    {
        return m_params;
    }

    FWRUNTIME_API void setParams(const ParamsContainer& params);
    FWRUNTIME_API void setParams(int argc, char** argv);

    int& getRawArgCount()
    {
        return m_argc;
    }

    char** getRawParams() const
    {
        return m_argv;
    }

private:

    typedef std::vector< SPTR(Activater) >     ActivaterContainer;
    typedef std::vector< SPTR(Starter) >       StarterContainer;
    typedef std::vector< SPTR(Stopper) >       StopperContainer;
    typedef std::vector< SPTR(Initializer) >   InitializerContainer;
    typedef std::vector< SPTR(Uninitializer) > UninitializerContainer;

    ActivaterContainer m_activaters;            
    StarterContainer m_starters;                
    StopperContainer m_stoppers;                
    InitializerContainer m_initializers;        
    UninitializerContainer m_uninitializers;    

    std::string m_sName;                    
    std::string m_sVersion;                 
    ::boost::filesystem::path m_filePath;   

    bool m_checkSingleInstance;
    RunCallbackType m_run;

#ifdef ANDROID
    android_app* m_app; 
#endif
    ParamsContainer m_params;
    int m_argc;
    char**          m_argv;
};

FWRUNTIME_API void setCurrentProfile(Profile::sptr prof);

FWRUNTIME_API Profile::sptr getCurrentProfile();

} // namespace profile

} // namespace fwRuntime

#endif /*__FWRUNTIME_PROFILE_PROFILE_HPP__*/