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

/// Default listeners used by the Handler 
/// if no user-defined instances are provided. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT 
DefaultListeners
{
    /// Default listener for Handler-related events. 
    static 
    HandlerListener& 
    handler()
    {
        static 
        HandlerListener 
        listener;

        return listener;
    }

    /// Default listener for feed-related events. 
    static 
    ChannelFeedListener& 
    feeds()
    {
        static 
        ChannelFeedListener 
        listener;

        return listener;
    }

    /// Default listener for market data -related events. 
    static 
    MarketDataListener& 
    marketData()
    {
        static 
        MarketDataListener 
        listener;

        return listener;
    }

    /// Default listener for security-related events. 
    static 
    SecurityListener& 
    security()
    {
        static 
        SecurityListener 
        listener;

        return listener;
    }
};

/// Set of listeners to be used by the Handler to 
/// reflect various aspects of market data processing.
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:
    /// Initializes listeners with default values.
    HandlerListeners(
        SettingAssignController* 
        controller = NULL)
        : SettingGroup(controller) 
        , handler_(
            &DefaultListeners::
            handler())
        , feeds_(
            &DefaultListeners::
            feeds())
        , marketData_(
            &DefaultListeners::
            marketData())
        , security_(
            &DefaultListeners::
            security())
    {
    }

    /// Re-initializes settings as copies of 
    /// the other ones omitting group belonging.
    HandlerListeners(
        const HandlerListeners& other)
        : SettingGroup()
        , handler_(other.handler_)
        , feeds_(other.feeds_)
        , marketData_(other.marketData_)
        , security_(other.security_)
    {
    }

    /// Finalizes the instance. 
    ~HandlerListeners()
    {
    }

    /// Returns an instance of HandlerListener to be used 
    /// by the Handler while raising Handler related events. 
    HandlerListener* 
    handler() const
    {
        return 
        (
            handler_ != 
            &DefaultListeners::
            handler()
                ? handler_
                : NULL
        );
    }

    /// Returns an instance of HandlerListener to be used 
    /// by the Handler while raising Handler related events. 
    ///
    /// If no or a null instance was previously associated, 
    /// the given member returns default listener. 
    HandlerListener& 
    handlerOrDefault() const
    {
        return *handler_;
    }

    /// Assigns listener for Handler related events. 
    /// 
    /// Assigning a null instance tells the Handler
    /// to omit invoking corresponding events. 
    void
    handler(
        HandlerListener* listener)
    {
        controlAssignment
        (
            "Handler Listener",
            handler_,
            listener 
                ? listener 
                : &DefaultListeners::handler()
        );
    }

    /// Returns an instance of ChannelFeedListener to be used 
    /// by the Handler while raising feed related events. 
    ChannelFeedListener* 
    feeds() const
    {
        return 
        (
            feeds_ != 
            &DefaultListeners::
            feeds()
                ? feeds_
                : NULL
        );
    }

    /// Returns an instance of ChannelFeedListener to be used 
    /// by the Handler while raising feed related events. 
    /// 
    /// If no or a null instance was previously associated, 
    /// the given member returns default listener. 
    ChannelFeedListener& 
    feedsOrDefault() const
    {
        return *feeds_;
    }

    /// Assigns listener for feed related events. 
    /// 
    /// Assigning a null instance tells the Handler
    /// to omit invoking corresponding events. 
    void
    feeds(
        ChannelFeedListener* listener)
    {
        controlAssignment
        (
            "ChannelFeed Listener",
            feeds_,
            listener 
                ? listener 
                : &DefaultListeners::feeds()
        );
    }

    /// Returns an instance of MarketDataListener to be used 
    /// by the Handler while raising market data related events. 
    MarketDataListener* 
    marketData() const
    {
        return 
        (
            marketData_ != 
            &DefaultListeners::
            marketData()
                ? marketData_
                : NULL
        );
    }

    /// Returns an instance of MarketDataListener to be used 
    /// by the Handler while raising market data related events. 
    /// 
    /// If no or a null instance was previously associated, 
    /// the given member returns default listener. 
    MarketDataListener& 
    marketDataOrDefault() const
    {
        return *marketData_;
    }

    /// Assigns listener for market data related events. 
    /// 
    /// Assigning a null instance tells the Handler
    /// to omit invoking corresponding events. 
    void
    marketData(
        MarketDataListener* listener)
    {
        controlAssignment
        (
            "MarketData Listener",
            marketData_,
            listener 
                ? listener 
                : &DefaultListeners::marketData()
        );
    }

    /// Returns an instance of SecurityListener to be used 
    /// by the Handler while raising security-related events. 
    SecurityListener* 
    security() const
    {
        return 
        (
            security_ != 
            &DefaultListeners::
            security()
                ? security_
                : NULL
        );
    }

    /// Returns an instance of SecurityListener to be used 
    /// by the Handler while raising security-related events. 
    /// 
    /// If no or a null instance was previously associated, 
    /// the given member returns default listener. 
    SecurityListener& 
    securityOrDefault() const
    {
        return *security_;
    }

    /// Assigns listener for security related events. 
    /// 
    /// Assigning a null instance tells the Handler
    /// to omit invoking corresponding events. 
    void
    security(
        SecurityListener* listener)
    {
        controlAssignment
        (
            "Security Listener",
            security_,
            listener 
                ? listener 
                : &DefaultListeners::security()
        );
    }

    /// Copies listeners from the given instance. 
    /// 
    /// Attributes controlling value assignment are
    /// not cloned and thus only listeners are copied. 
    HandlerListeners&
    operator =(
        const HandlerListeners& other)
    {
        controlAssignment
        (
            "Handler Listeners",
            &HandlerListeners::assignNoControl,
            *this,
            other
        );

        return *this;
    }
};

/// Serializes information on associated listeners. 
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&, 
    const HandlerListeners&);

/// Serializes information on associated listeners. 
inline
std::string
toStr(
    const HandlerListeners& listeners)
{
    std::string str;
    
    toStr(str, listeners);

    return str;
}

ONIXS_CONFLATEDUDP_NAMESPACE_END