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 <string>
 
#include <OnixS/CME/MDH/Domain.h>
 
#include <OnixS/CME/MDH/FeedSettings.h>
#include <OnixS/CME/MDH/SessionSettings.h>
#include <OnixS/CME/MDH/BookManagement.h>
#include <OnixS/CME/MDH/TradeProcessing.h>
#include <OnixS/CME/MDH/LoggingSettings.h>
#include <OnixS/CME/MDH/HandlerListeners.h>
 
#include <OnixS/CME/MDH/SettingGroup.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN

class ONIXS_CMEMDH_LTWT LicenseSettings : public SettingGroup
{
public:
    typedef std::vector<std::string> LicenseStores;

    LicenseSettings(SettingChangeController* controller = ONIXS_CMEMDH_NULLPTR)
        : SettingGroup(controller)
    {
    }

    LicenseSettings(const LicenseSettings& other)
        : SettingGroup()
        , stores_(other.stores_)
        , licenseString_(other.licenseString_)
    {
    }

    LicenseSettings& addLicenseStore(const std::string& value)
    {
        LicenseStores stores = stores_;
        stores.push_back(value);
 
        controlAssignment("License Store", stores_, stores);
        return *this;
    }

    LicenseSettings& licenseStore(const std::string& value)
    {
        LicenseStores stores;
        stores.push_back(value);
 
        controlAssignment("License Store", stores_, stores);
        return *this;
    }

    LicenseSettings& licenseString(const std::string& value)
    {
        controlAssignment("License String", licenseString_, value);
        return *this;
    }

    const LicenseStores& licenseStores() const
    {
        return stores_;
    }

    const std::string& licenseString() const
    {
        return licenseString_;
    }

    LicenseSettings& operator=(const LicenseSettings& other)
    {
        controlChange("Handler Settings", &LicenseSettings::assignNoControl, *this, other);
 
        return *this;
    }
 
private:
    void assignNoControl(const LicenseSettings& other)
    {
        stores_ = other.stores_;
        licenseString_ = other.licenseString_;
    }
 
    LicenseStores stores_;
    std::string licenseString_;
 
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(HandlerSettings);
};

class ONIXS_CMEMDH_LTWT HandlerSettings : public SettingGroup
{
public:
    HandlerSettings(SettingChangeController* controller = ONIXS_CMEMDH_NULLPTR)
        : SettingGroup(controller)
        , channel_(0)
        , feeds_(controller)
        , session_(controller)
        , tradeProcessing_(TradeProcessing::SummaryLevel)
        , bookManagement_(controller)
        , recoveryQueueMaxSize_(1000000)
        , instrumentCache_()
        , logging_(controller)
        , listeners_(controller)
        , licenseSettings_(controller)
        , dataCenter_(DataCenter::Primary)
 
    {
    }

    HandlerSettings(const HandlerSettings& other)
        : SettingGroup()
        , channel_(other.channel_)
        , feeds_(other.feeds_)
        , session_(other.session_)
        , tradeProcessing_(other.tradeProcessing_)
        , bookManagement_(other.bookManagement_)
        , recoveryQueueMaxSize_(other.recoveryQueueMaxSize_)
        , instrumentCache_(other.instrumentCache_)
        , logging_(other.logging_)
        , listeners_(other.listeners_)
        , licenseSettings_(other.licenseSettings_)
        , configurationFile_(other.configurationFile_)
        , dataCenter_(other.dataCenter_)
    {
    }

    ~HandlerSettings() {}

    ChannelId channel() const
    {
        return channel_;
    }

    HandlerSettings& channel(ChannelId value)
    {
        controlAssignment("Channel Id", channel_, value);
 
        return *this;
    }
 

    const std::string& connectivityConfigurationFile() const
    {
        return configurationFile_;
    }

    DataCenter::Enum dataCenter() const
    {
        return dataCenter_;
    }

    HandlerSettings& connectivityConfigurationFile(
        const std::string& configurationFile,
        DataCenter::Enum dataCenter = DataCenter::Primary
    )
    {
        controlChange(
            "Connectivity Configuration File",
            &HandlerSettings::assignConnectivityConfiguration,
            *this,
            configurationFile,
            dataCenter
        );
 
        return *this;
    }

    const FeedSettings& feeds() const
    {
        return feeds_;
    }

    FeedSettings& feeds()
    {
        return feeds_;
    }

    SessionSettings& session()
    {
        return session_;
    }

    const SessionSettings& session() const
    {
        return session_;
    }

    HandlerListeners& listeners()
    {
        return listeners_;
    }

    const HandlerListeners& listeners() const
    {
        return listeners_;
    }

    TradeProcessing::Enum tradeProcessing() const
    {
        return tradeProcessing_;
    }

    HandlerSettings& tradeProcessing(TradeProcessing::Enum strategy)
    {
        controlAssignment("Trade Processing Strategy", tradeProcessing_, strategy);
 
        return *this;
    }

    const BookManagement& bookManagement() const
    {
        return bookManagement_;
    }

    BookManagement& bookManagement()
    {
        return bookManagement_;
    }

    UInt32 recoveryQueueMaxSize() const
    {
        return recoveryQueueMaxSize_;
    }

    HandlerSettings& recoveryQueueMaxSize(UInt32 queueMaxSize)
    {
        controlAssignment("Recovery Queue Max Size", recoveryQueueMaxSize_, queueMaxSize);
 
        return *this;
    }

    const std::string& instrumentCache() const
    {
        return instrumentCache_;
    }

    HandlerSettings& instrumentCache(const std::string& filename)
    {
        controlAssignment("Instrument Cache Path", instrumentCache_, filename);
 
        return *this;
    }

    LoggingSettings& logging()
    {
        return logging_;
    }

    const LoggingSettings& logging() const
    {
        return logging_;
    }

    LicenseSettings& licenseSettings()
    {
        return licenseSettings_;
    }

    const LicenseSettings& licenseSettings() const
    {
        return licenseSettings_;
    }
 
#if !defined(ONIXS_CMEMDH_NO_DEPRECATED)

    HandlerDebugLoggingSettings& debugLogging()
    {
        return logging_.debug();
    }

    const HandlerDebugLoggingSettings& debugLogging() const
    {
        return logging_.debug();
    }
 
#endif // ONIXS_CMEMDH_NO_DEPRECATED

    HandlerSettings& operator=(const HandlerSettings& other)
    {
        controlChange("Handler Settings", &HandlerSettings::assignNoControl, *this, other);
 
        return *this;
    }
 
private:
    ChannelId channel_;
 
    FeedSettings feeds_;
 
    SessionSettings session_;
 
    TradeProcessing::Enum tradeProcessing_;
    BookManagement bookManagement_;
 
    UInt32 recoveryQueueMaxSize_;
    std::string instrumentCache_;
 
    LoggingSettings logging_;
 
    HandlerListeners listeners_;
 
    LicenseSettings licenseSettings_;
 
    std::string configurationFile_;
 
    DataCenter::Enum dataCenter_;
 
    void assignNoControl(const HandlerSettings& other)
    {
        channel_ = other.channel_;
 
        feeds_.assignNoControl(other.feeds_);
 
        session_.assignNoControl(other.session_);
 
        tradeProcessing_ = other.tradeProcessing_;
 
        bookManagement_.assignNoControl(other.bookManagement_);
 
        recoveryQueueMaxSize_ = other.recoveryQueueMaxSize_;
 
        instrumentCache_ = other.instrumentCache_;
 
        logging_.assignNoControl(other.logging_);
 
        listeners_.assignNoControl(other.listeners_);
 
        licenseSettings_.assignNoControl(other.licenseSettings_);
 
        configurationFile_ = other.configurationFile_;
 
        dataCenter_ = other.dataCenter_;
    }

    void assignConnectivityConfiguration(const std::string& configurationFile, DataCenter::Enum dataCenter)
    {
        configurationFile_ = configurationFile;
 
        dataCenter_ = dataCenter;
    }
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const HandlerSettings&);

inline std::string toStr(const HandlerSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}

ONIXS_CMEMDH_EXPORTED
std::string makeInstrumentCacheFilename(ChannelId);
 
ONIXS_CMEMDH_NAMESPACE_END