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

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT 
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;
    }
};

ONIXS_CONFLATEDUDP_LTWT_CLASS 
HandlerListeners
    : public SettingGroup
{
    // Lets grouping and value assignment control functioning. 
    friend 
    ONIXS_CONFLATEDUDP_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_;
    }
 
public:
    HandlerListeners(
        SettingAssignController* 
        controller = NULL)
        : 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_
                : NULL
        );
    }

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

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

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

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

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

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

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

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

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

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

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

    HandlerListeners&
    operator =(
        const HandlerListeners& other)
    {
        controlAssignment
        (
            "Handler Listeners",
            &HandlerListeners::assignNoControl,
            *this,
            other
        );
 
        return *this;
    }
};

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

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