Connectivity_SessionDefs.h

Go to the documentation of this file.

 
#ifndef _SESSION_DEFINITONS_H_
#define _SESSION_DEFINITONS_H_
 
#include <string>
#include <list>
#include <map>
#include <algorithm>
#include <iterator>
#include <sag_connectivity_plugins.hpp>
 
using namespace com::softwareag::connectivity;
 
#define SESSION_CONFIG_SCHEMA   ("configSchema")    
#define SESSION_CONFIG_PARAMS   ("SCP")                 
#define SESSION_CONFIG_KEY      ("SessionConfigParams") 
#define SESSION_CAPABILITIES    ("sessionCapabilities") 
#define CTRL_PARAMS             ("CtrlParams")          
#define CTRL_PARAMS_CP          ("CP")                  
#define CTRL_PARAMS_SCHEMA      ("CtrlParamsSchema")        
typedef enum
{
    SESSION_UNKNOWN,        
    SESSION_INITIAL,        
    SESSION_REGISTERED,     
    SESSION_DISCONNECTED,   
    SESSION_CONNECTED,      
    SESSION_LOGGEDOUT,      
    SESSION_LOGGEDIN        
}
AP_SESSION_State;
 
struct Param {
    Param() 
    {
    };
 
    Param(
        const std::string&        paramName,
        const std::string&        type,
        const std::string&        defaultVal,
        std::list<std::string>&   allowedVals,
        const std::string&        description,
        bool                      required,
        bool                      referenceOnly
    ) : m_name(paramName)
        , m_type(type)
        , m_defaultVal(defaultVal)
        , m_description(description)
        , m_required(required)
        , m_allowedVals(allowedVals)
        , m_referenceOnly(referenceOnly)
    {
 
    }
 
    ~Param() {};
 
    const std::string toString()
    {
        std::stringstream listToString;
        std::copy(m_allowedVals.begin(), m_allowedVals.end(), std::ostream_iterator<std::string>(listToString, ","));
        
        std::stringstream ss;
        ss << "type=" << m_type << " ,defaultVal=" << m_defaultVal 
            << " ,description=" << m_description << " ,required=" 
            << m_required << " ,allowedVals=[" << listToString.str()
            << "] ,referenceOnly=" << m_referenceOnly << std::endl;
 
        return std::move(ss.str());
    }
 
    map_t getCP(const std::string& eventType) const;
 
    std::string             m_name; 
    std::string             m_type; 
    std::string             m_defaultVal; 
    std::list<std::string>  m_allowedVals; 
    std::string             m_description; 
    bool                    m_required; 
    bool                    m_referenceOnly; 
};
 
struct SessionParam : public Param {
 
    SessionParam() :Param() 
    {
    };
 
    SessionParam(
        const std::string&        paramName,
        const std::string&        type,
        const std::string&        defaultVal,
        std::list<std::string>&   allowedVals,
        const std::string&        description,
        bool                      required,
        bool                      referenceOnly
    )
        : Param(paramName, type, defaultVal, allowedVals, description, required, referenceOnly)
    {
    }
 
    ~SessionParam() {};
 
 
    map_t getCP() const;
 
};
 
struct SessionParams {
 
    SessionParams()
    {};
 
    ~SessionParams()
    {};
 
    map_t getConfigSchemaString() const;
 
    typedef std::map<std::string, SessionParam> Map;
 
    Map m_map;
 
    const std::string toString()
    {
        std::stringstream mapToString;
        for (auto it=m_map.begin(); it!=m_map.end();++it)
        {
            mapToString << it->first << ":" << it->second.toString();
        }
        return std::move(mapToString.str());
    }
};
 
struct CapabilityParam : public Param {
 
    CapabilityParam() : Param() 
    {
    };
 
    CapabilityParam
    (
        std::string               paramName,
        std::string               type,
        std::string               defaultVal,
        std::list<std::string>&   allowedVals,
        std::string               description,
        bool                      required
    )
        : Param(paramName, type, defaultVal, allowedVals, description, required, false)
    {
    }
 
    ~CapabilityParam() {};
 
    map_t getCP() const;
};
 
struct CapabilityParams {
 
    CapabilityParams()
    {};
 
    ~CapabilityParams()
    {};
 
    map_t getCPSchema() const;
 
    typedef std::map<std::string, CapabilityParam> Map;
 
    Map m_map;
 
    const std::string toString()
    {
        std::stringstream mapToString;
        for (auto it = m_map.begin(); it != m_map.end(); ++it)
        {
            mapToString << it->first << ":" << it->second.toString();
        }
        return std::move(mapToString.str());
    }
};
 
typedef std::map<std::string, CapabilityParams> Capabilities;
 
 
struct Capability {
    Capability()
    {
    };
 
    Capability
    (
        const std::string    streamName,
        CapabilityParam      capability
    )
        : streamName_(streamName), capability_(capability)
    {
    }
 
    ~Capability() {};
 
    std::string streamName_;
    CapabilityParam capability_;
};
 
struct SessionConfigs
{
    SessionConfigs()
    {
        m_state = SESSION_UNKNOWN;
    };
 
 
    SessionConfigs(
        std::string transportName,
        std::string sessionName,
        std::string channelName,
        std::string description
    )
        : m_transportName(transportName)
        , m_sessionName(sessionName)
        , m_channelName(channelName)
        , m_description(description)
        , m_generationId("")
    {
        m_state = SESSION_UNKNOWN;
        std::stringstream ss;
        ss << "CONNECTION_" << sessionName;
        m_connectionID = ss.str();
    };
 
 
    ~SessionConfigs()
    {};
 
    const std::string toString()
    {
        std::stringstream ss;
        ss << "sourceId=" << m_sourceId << ", transportName=" << m_transportName << ", sessionName="
            << m_sessionName << ", channelName=" << m_channelName << ", state=" << (int)m_state
            << ", connectionID=" << m_connectionID << ", generationId=" << m_generationId << " ,SessionParams=" << m_sessionParams.toString();
        return std::move(ss.str());
    }
    map_t getCapabilitiesString() const;
 
    int64_t                 m_sourceId; 
    std::string             m_transportName; 
    std::string             m_sessionName; 
    std::string             m_channelName; 
    std::string             m_description; 
    AP_SESSION_State        m_state; 
    std::string             m_connectionID; 
    std::string             m_generationId; 
    SessionParams           m_sessionParams; 
    Capabilities            m_capabilitiesMap; 
};
#endif