HandlerSettings.h

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable ONIXS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/
 
#pragma once
 
#include <OnixS/FmxUST/MarketData/Bimp/ABI.h>
#include <OnixS/FmxUST/MarketData/Bimp/Defines.h>
#include <OnixS/FmxUST/MarketData/Bimp/LogSettings.h>
 
#include <sstream>
#include <string>
#include <set>
#include <vector>
 
namespace OnixS
{
    namespace FmxUST
    {
        namespace MarketData
        {
            namespace Bimp
            {
                struct ServiceDescriptor
                {
                    ServiceDescriptor()
                        : port (0)
                    {}

                    ServiceDescriptor (const std::string& a, unsigned int port)
                        : address (a)
                        , port (port)
                    {}

                    std::string address;

                    unsigned port;

                    bool operator == (const ServiceDescriptor& other) const
                    {
                        return address == other.address && port == other.port;
                    }

                    bool operator != (const ServiceDescriptor& other) const
                    {
                        return !operator==(other);
                    }

                    bool valid() const
                    {
                        return !address.empty() && port > 0;
                    }
                };
 
                ONIXS_FMXUST_BIMP_API std::ostream& operator << (std::ostream& stream, const ServiceDescriptor& descriptor);

                struct FeedDescriptor
                {
                    ServiceDescriptor serviceA;

                    ServiceDescriptor serviceB;

                    bool operator == (const FeedDescriptor& other) const
                    {
                        return serviceA == other.serviceA && serviceB == other.serviceB;
                    }

                    bool operator != (const FeedDescriptor& other) const
                    {
                        return !operator==(other);
                    }
                };
 
                ONIXS_FMXUST_BIMP_API std::ostream& operator << (std::ostream& stream, const FeedDescriptor& descriptor);

                struct TcpServiceDescriptor : ServiceDescriptor
                {
                    TcpServiceDescriptor() {}

                    TcpServiceDescriptor (
                            const std::string& addr, unsigned int port,
                            const std::string& name, const std::string& pass, const std::string& ni = "")
                        : ServiceDescriptor(addr, port)
                        , username(name)
                        , password(pass)
                        , networkInterface(ni)
                    {}

                    bool valid() const
                    {
                        return
                            ServiceDescriptor::valid() &&
                            (!username.empty()) &&
                            (!password.empty());
                    }

                    bool operator == (const TcpServiceDescriptor& other) const
                    {
                        return
                            ServiceDescriptor::operator==(other) &&
                            (username == other.username);
                    }

                    bool operator != (const TcpServiceDescriptor& other) const
                    {
                        return !operator==(other);
                    }

                    std::string username;

                    std::string password;

                     std::string networkInterface;
                };

                ONIXS_FMXUST_BIMP_API std::ostream& operator << (std::ostream& stream, const TcpServiceDescriptor& descriptor);
 

                struct TcpFeedDescriptor
                {
                    TcpServiceDescriptor serviceA;

                    TcpServiceDescriptor serviceB;
                };

                ONIXS_FMXUST_BIMP_API std::ostream& operator << (std::ostream& stream, const TcpFeedDescriptor& descriptor);
 

                typedef std::set<std::string> Symbols;
 
                struct HandlerSettings;
 
                ONIXS_FMXUST_BIMP_API std::ostream& operator << (std::ostream& stream, const HandlerSettings& settings);

                struct HandlerSettings
                {
                    HandlerSettings()
                        : licenseString()
                        , licenseDirectory()
                        , logDirectory("logs")
                        , logFileNamePrefix("FenicsUstBimp")
                        , logSettings(LogSettings::Default)
                        , logLevel(LogLevel::Info)
                        , logFilePermissions(LogFilePermission::Default)
                        , heartbeatInterval(1)
                        , outOfOrderPacketMaxInterval(3)
                        , lostPacketWaitTime(100000)
                        , useFeedA(true)
                        , useFeedB(true)
                        , maxBooksObjectAmount(1000)
                        , maxPacketSize(1500)
                        , maxConnectingAttempts(3)
                        , minReconnectingTimeout(3)
                        , replayMaxPacketsNumber(10000)
                        , buildInternalOrderBooks(false)
                    {}

                    std::string licenseString;

                    std::string licenseDirectory;

                    std::string logDirectory;

                    std::string logFileNamePrefix ;

                    LogSettings::Enum logSettings;

                    LogLevel::Enum logLevel;

                    LogFilePermission::Enum logFilePermissions;

                    std::string networkInterface;

                    std::string networkInterfaceA;

                    std::string networkInterfaceB;

                    UInt32 heartbeatInterval;

                    UInt32 outOfOrderPacketMaxInterval;

                    UInt32 lostPacketWaitTime;

                    bool useFeedA;

                    bool useFeedB;

                    FeedDescriptor multicastFeed;

                    FeedDescriptor reRequestFeed;

                    TcpFeedDescriptor snapshotService;

                    ThreadAffinity snapshotServiceSendingAffinity;

                    ThreadAffinity snapshotServiceRecvAffinity;

                    std::string networkInterfaceForTcpServices;

                    unsigned int  maxBooksObjectAmount;

                    unsigned short maxPacketSize;

                    unsigned int maxConnectingAttempts;

                    unsigned int minReconnectingTimeout;

                    unsigned int replayMaxPacketsNumber;

                    Symbols symbols;

                    bool buildInternalOrderBooks;

                    std::string toString() const
                    {
                        std::ostringstream out;
                        out << *this;
                        return out.str();
                    }
                };
 
            }
        }
    }
}