Connectivity_MDInterfaces.h

Go to the documentation of this file.

 
#ifndef _SAG_MDM_INTERFACE_H_
#define _SAG_MDM_INTERFACE_H_
 
/* The timestamp tags are tempararily allocated
 
TIMESTAMP_UPSTREAM_MDM_ENTRY 19800
TIMESTAMP_UPSTREAM_MDM_EXIT  19850
 
TIMESTAMP_DOWNSTREAM_MDM_ENTRY 1100
TIMESTAMP_DOWNSTREAM_MDM_EXIT  1150
*/
 
#include <string>
#include<memory>
#include <vector>
#include <list>
#include <set>
#include "sag_connectivity_plugins.hpp"
 
using namespace com::softwareag::connectivity;
 
 
 
#if defined(_APBUILD_WIN32_ALL__) || defined(__WIN32__) || defined(WIN32)
/*
* DLL import/export symbols for Win32 builds.  Everything will work correctly
* as long as the following symbols are *not* defined when this file is
* included (These symbols are for Apama external use only):
*  SAG_MDM_BACKEND
*/
 
#ifndef _APBUILD_WIN32_ALL__
#define _APBUILD_WIN32_ALL__ 
#endif
 
#ifdef SAG_MDM_BACKEND
#define SAG_MDM_API __declspec(dllexport)
#define SAG_MDM_CALL __stdcall  
#else
#define SAG_MDM_API __declspec(dllimport)
#define SAG_MDM_CALL __stdcall
#endif
 
#elif defined(_APBUILD_UNIX_ALL__) || defined(__unix__)
#define SAG_MDM_API
#define SAG_MDM_CALL
#else
#error "Can't determine platform: try #define _APBUILD_WIN32_ALL__ or _APBUILD_UNIX_ALL__"
#endif
 
namespace com {
    namespace softwareag {
        namespace marketdata {
 
#define STREAMTYPE_BBA          ("com.apama.md.BBA")    
#define STREAMTYPE_TRADE        ("com.apama.md.T")      
#define STREAMTYPE_MBP          ("com.apama.md.D")      
#define STREAMTYPE_MBO          ("com.apama.md.O")      
#define STREAMTYPE_EP           ("com.apama.md.EP")     
#define STREAMTYPE_QUOTEBOOK    ("com.apama.md.QB")     
#define STREAMTYPE_NEWS         ("com.apama.md.N")      
            typedef enum {
                MDM_UNKNOWN_STREAM = 0,     
                MDM_BBA_STREAM = 1,         
                MDM_TRADE_STREAM = 2,       
                MDM_MBP_STREAM = 8,         
                MDM_MBO_STREAM = 16,        
                MDM_EP_STREAM = 32,         
                MDM_QUOTEBOOK_STREAM = 64,  
                MDM_NEWS_STREAM = 128       
            }
            AP_MDM_StreamType;
 
 
 
#define MDM_DEFAULT_STRING      "~#"        
#define MDM_DEFAULT_FLOAT       0.000001    
#define MDM_DEFAULT_INT         -999999     
            typedef enum {
                MDM_COMPOUND_DELTA = 1,     
                MDM_SNAPSHOT_ONLY           
            }
            AP_MDM_TransferMode;
 
            typedef enum {
                MDM_FATAL,      
                MDM_ERROR,      
                MDM_WARNING,    
                MDM_INFO        
            }
            AP_MDM_ErrorLevel;
 
 
            typedef std::vector<std::string> StringList;    
            typedef std::set<std::string> StringSet;        
            class SchemaItemValue
            {
            public:
                SchemaItemValue(const std::string &paramName, const std::string &value) : paramName_(paramName), value_(value) {}
 
                bool operator==(const SchemaItemValue& rhs) const { return (paramName_ == rhs.paramName_) && (value_ == rhs.value_); }
 
                std::string paramName_; 
                std::string value_;     
            };
 
            class SchemaItem : public SchemaItemValue
            {
            public:
                SchemaItem(const std::string &paramName, const std::string &type, const std::string &value, const std::string &description)
                    : SchemaItemValue(paramName, value)
                    , type_(type)
                    , description_(description)
                {}
 
                std::string type_;          
                std::string description_;   
            };
 
            typedef SchemaItem ExtraParam;                              
            typedef SchemaItemValue ExtraParamValue;                    
            typedef std::list<ExtraParam> ExtraParamList;               
            typedef std::list<ExtraParamValue> ExtraParamValueList;     
            typedef SchemaItem NewsData;                                
            typedef std::list<NewsData> NewsDataList;                   
            typedef SchemaItemValue StringPair;                         
            typedef std::vector<StringPair> StringDictionary;           
            typedef struct timeStampConfig{
                bool recordUpstream; 
                bool recordDownstream; 
                bool logUpstream; 
                bool logDownstream; 
                bool logRoundtrip; 
                //enum AP_LogLevel logLevel;
 
                timeStampConfig()
                    : recordUpstream(false)
                    , recordDownstream(false)
                    , logUpstream(false)
                    , logDownstream(false)
                    , logRoundtrip(false)
                {
                };
            } TimestampConfig;
 
 
            class MarketDataSession;
            typedef int64_t TimestampSetIndex; 
            typedef double TimestampSetTime; 
            class TimestampSet;
            typedef std::shared_ptr<TimestampSet> TimestampSetPtr;          
            class SAG_MDM_API MDMInterface
            {
            public:
                MDMInterface() {}
 
                virtual ~MDMInterface() {}
 
                virtual const char* getKey(const std::string& symbol, int64_t sourceId, AP_MDM_StreamType streamType, map_t& ctrlParams) = 0;
 
                virtual void connect(const std::string& subKey, AP_MDM_StreamType streamType, map_t& ctrlParams) = 0;
 
                virtual void disconnect(const std::string& subKey, AP_MDM_StreamType streamType, map_t& ctrlParams) = 0;
 
                virtual void setMarketDataSession(MarketDataSession* mdSession) = 0;
 
            };
 
            class SAG_MDM_API MarketDataManager
            {
 
            public:
                MarketDataManager(Logger* logger, MDMInterface* mdIface);
 
                virtual ~MarketDataManager();
 
                virtual void Start() = 0;
                
                virtual void Stop() = 0;
 
                virtual bool ProcessMessage(Message& msgObj) = 0;
 
 
                virtual void setHostSide(HostSide* hostSide);
 
                virtual void setTimeStampConfig(map_t& timeStampConfig) = 0;
 
            protected:
                HostSide* hostSide_;
                Logger* logger_;
                MDMInterface* mdInterface_;
            };
 
            class MarketDataPublisher;
 
            class SAG_MDM_API MDManagerFactory {
            public:
                static MarketDataManager* createMarketDataManager(Logger* logger, MDMInterface* mdmConntInterface);
            };
 
            class SAG_MDM_API MarketDataSession {
            public:
 
                virtual ~MarketDataSession() {};
 
                virtual void setConnectSuccess(const std::string& subKey, TimestampSetPtr tss) = 0;
 
                virtual void setConnectFailed(const std::string& subKey, const std::string& description, TimestampSetPtr tss) = 0;
 
                virtual void setDisconnectSuccess(const std::string& subKey, TimestampSetPtr tss) = 0;
 
                virtual void setDisconnectFailed(const std::string& subKey, const std::string & description, TimestampSetPtr tss) = 0;
 
                virtual void SubscriptionCommit(const std::string& subKey, TimestampSetPtr tss) = 0;
 
                virtual void RemoveSubscription(const std::string& subKey) = 0;
 
                virtual void RemoveSourceSubscriptions(int64_t sourceId) = 0;
 
                virtual void RemoveSubscriptions() = 0;
 
                virtual void ClearSubscriptionData(const std::string& subKey) = 0;
 
 
                virtual void ClearSourceData(int64_t sourceId) = 0;
 
                virtual void ClearData() = 0;
 
                virtual MarketDataPublisher* getPublisher(AP_MDM_StreamType stype) = 0;
            };
 
        
            class SAG_MDM_API TimestampSet
            {
            public:
                TimestampSet() {};
                ~TimestampSet() { _timeStampmap.clear(); }
 
                void addNow(TimestampSetIndex index);
 
                void addTime(TimestampSetIndex index, TimestampSetTime time);
 
                TimestampSetTime findTime(TimestampSetIndex index);
                
                map_t& getTimeStamp() { return _timeStampmap; }
 
            private:
                //key -> index
                //val -> time(double)
                map_t  _timeStampmap;
                TimestampSetTime getRelativeTime();
            };
        }
    }
}
 
#endif /*_SAG_MDM_INTERFACE_H_*/