Activities.hpp

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

#pragma once

#include "fwActivities/config.hpp"

#include <fwCore/BaseObject.hpp>
#include <fwCore/mt/types.hpp>

#include <fwRuntime/ConfigurationElement.hpp>
#include <fwRuntime/EConfigurationElement.hpp>

#include <boost/property_tree/ptree.hpp>

#include <map>
#include <string>

namespace fwData
{
class Vector;
}

namespace fwRuntime
{
struct Extension;
}

namespace fwActivities
{

namespace registry
{

typedef ::boost::property_tree::ptree ConfigType;

struct FWACTIVITIES_CLASS_API ActivityAppConfigParam
{
    ActivityAppConfigParam()
    {
    }
    FWACTIVITIES_API ActivityAppConfigParam(const ConfigType& config);

    //------------------------------------------------------------------------------

    bool isSeshat() const
    {
        return (by.substr(0, 1) == "@") || (by.substr(0, 1) == "!");
    }

    std::string replace;
    std::string by;
};

struct FWACTIVITIES_CLASS_API ActivityAppConfig
{
    typedef std::vector< ActivityAppConfigParam > ActivityAppConfigParamsType;

    ActivityAppConfig()
    {
    }
    FWACTIVITIES_API ActivityAppConfig(const ConfigType& config);

    std::string id;
    ActivityAppConfigParamsType parameters;
};

struct FWACTIVITIES_CLASS_API ActivityRequirementKey
{
    ActivityRequirementKey()
    {
    }
    FWACTIVITIES_API ActivityRequirementKey(const ConfigType& config);

    std::string key;
    std::string path;
};

struct FWACTIVITIES_CLASS_API ActivityRequirement
{
    ActivityRequirement()
    {
    }
    FWACTIVITIES_API ActivityRequirement(const ConfigType& config);

    typedef std::vector< ActivityRequirementKey > KeyType;

    std::string name; 
    std::string type; 
    std::string container; 
    std::string description; 
    std::string validator;  
    unsigned int minOccurs; 
    unsigned int maxOccurs; 
    bool create; 
    KeyType keys; 
};

struct FWACTIVITIES_CLASS_API ActivityInfo
{
    typedef std::vector< ActivityRequirement > RequirementsType;
    typedef std::pair<unsigned int, unsigned int> MinMaxType;
    typedef std::map< std::string, MinMaxType > RequirementsMinMaxCount;
    typedef std::map< std::string, unsigned int > DataCountType;

    ActivityInfo()
    {
    }

    FWACTIVITIES_API ActivityInfo(const SPTR(::fwRuntime::Extension)& ext);

    FWACTIVITIES_API bool usableWith(DataCountType dataCount) const;

    std::string id;
    std::string title;
    std::string description;
    std::string icon;
    std::string tabInfo;
    RequirementsType requirements;
    std::string builderImpl;
    std::string bundleId; 
    std::string bundleVersion; 

    std::vector< std::string > validatorsImpl;

    ActivityAppConfig appConfig;

    protected:

        RequirementsMinMaxCount m_requirementCount;
};

class FWACTIVITIES_CLASS_API Activities : public ::fwCore::BaseObject
{

public:
    typedef std::vector< ActivityInfo > ActivitiesType;

    fwCoreClassDefinitionsWithFactoryMacro( (Activities)(::fwCore::BaseObject), (()), new Activities );

    FWACTIVITIES_API static Activities::sptr getDefault();

    FWACTIVITIES_API virtual ~Activities();

    FWACTIVITIES_API void parseBundleInformation();
    FWACTIVITIES_API void parseBundleInformation(const std::vector< SPTR( ::fwRuntime::Extension ) >& extensions);

    FWACTIVITIES_API const ActivityInfo getInfo( const std::string& extensionId ) const;

    FWACTIVITIES_API bool hasInfo( const std::string& extensionId ) const;

    FWACTIVITIES_API ActivityInfo::DataCountType getDataCount( const CSPTR(::fwData::Vector)& data ) const;

    FWACTIVITIES_API ActivitiesType getInfos() const;

    FWACTIVITIES_API ActivitiesType getInfos( const CSPTR(::fwData::Vector)& data ) const;

    FWACTIVITIES_API std::vector< std::string > getKeys() const;

    FWACTIVITIES_API void clearRegistry();

protected:

    typedef std::map< std::string, ActivityInfo > Registry;

    Registry m_reg;

    FWACTIVITIES_API Activities();

    mutable ::fwCore::mt::ReadWriteMutex m_registryMutex;

    static Activities::sptr s_activities;

};

} // namespace registry

} // namespace fwActivities