HandlerListeners.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/HandlerListener.h>
#include <OnixS/CME/MDH/ChannelFeedListener.h>
 
#include <OnixS/CME/MDH/MarketDataListener.h>
#include <OnixS/CME/MDH/SecurityListener.h>
 
#include <OnixS/CME/MDH/SettingGroup.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN

struct ONIXS_CMEMDH_EXPORTED DefaultListeners
{
    static HandlerListener& handler()
    {
        static HandlerListener listener;
 
        return listener;
    }

    static ChannelFeedListener& feeds()
    {
        static ChannelFeedListener listener;
 
        return listener;
    }

    static MarketDataListener& marketData()
    {
        static MarketDataListener listener;
 
        return listener;
    }

    static SecurityListener& security()
    {
        static SecurityListener listener;
 
        return listener;
    }
};

class ONIXS_CMEMDH_LTWT HandlerListeners : public SettingGroup
{
public:
    HandlerListeners(SettingChangeController* controller = ONIXS_CMEMDH_NULLPTR)
        : SettingGroup(controller)
        , handler_(&DefaultListeners::handler())
        , feeds_(&DefaultListeners::feeds())
        , marketData_(&DefaultListeners::marketData())
        , security_(&DefaultListeners::security())
    {
    }

    HandlerListeners(const HandlerListeners& other)
        : SettingGroup()
        , handler_(other.handler_)
        , feeds_(other.feeds_)
        , marketData_(other.marketData_)
        , security_(other.security_)
    {
    }

    ~HandlerListeners() {}

    HandlerListener* handler() const
    {
        return (handler_ != &DefaultListeners::handler() ? handler_ : ONIXS_CMEMDH_NULLPTR);
    }

    HandlerListener& handlerOrDefault() const
    {
        return *handler_;
    }

    HandlerListeners& handler(HandlerListener* listener)
    {
        controlAssignment("Handler Listener", handler_, listener ? listener : &DefaultListeners::handler());
 
        return *this;
    }

    ChannelFeedListener* feeds() const
    {
        return (feeds_ != &DefaultListeners::feeds() ? feeds_ : ONIXS_CMEMDH_NULLPTR);
    }

    ChannelFeedListener& feedsOrDefault() const
    {
        return *feeds_;
    }

    HandlerListeners& feeds(ChannelFeedListener* listener)
    {
        controlAssignment("ChannelFeed Listener", feeds_, listener ? listener : &DefaultListeners::feeds());
 
        return *this;
    }

    MarketDataListener* marketData() const
    {
        return (marketData_ != &DefaultListeners::marketData() ? marketData_ : ONIXS_CMEMDH_NULLPTR);
    }

    MarketDataListener& marketDataOrDefault() const
    {
        return *marketData_;
    }

    HandlerListeners& marketData(MarketDataListener* listener)
    {
        controlAssignment("MarketData Listener", marketData_, listener ? listener : &DefaultListeners::marketData());
 
        return *this;
    }

    SecurityListener* security() const
    {
        return (security_ != &DefaultListeners::security() ? security_ : ONIXS_CMEMDH_NULLPTR);
    }

    SecurityListener& securityOrDefault() const
    {
        return *security_;
    }

    HandlerListeners& security(SecurityListener* listener)
    {
        controlAssignment("Security Listener", security_, listener ? listener : &DefaultListeners::security());
 
        return *this;
    }

    HandlerListeners& operator=(const HandlerListeners& other)
    {
        controlChange("Handler Listeners", &HandlerListeners::assignNoControl, *this, other);
 
        return *this;
    }
 
private:
    // Lets grouping and value assignment control functioning.
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(HandlerSettings);
 
    //
 
    HandlerListener* handler_;
    ChannelFeedListener* feeds_;
    MarketDataListener* marketData_;
    SecurityListener* security_;
 
    // Re-initializes the instance as a copy of the
    // other one and bypassing assignment control.
    void assignNoControl(const HandlerListeners& other)
    {
        handler_ = other.handler_;
        feeds_ = other.feeds_;
 
        marketData_ = other.marketData_;
        security_ = other.security_;
    }
};

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

inline std::string toStr(const HandlerListeners& listeners)
{
    std::string str;
 
    toStr(str, listeners);
 
    return str;
}
 
ONIXS_CMEMDH_NAMESPACE_END