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

/// Default listeners used by the Handler
/// if no user-defined instances are provided.
struct ONIXS_CMEMDH_EXPORTED 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.
class ONIXS_CMEMDH_LTWT HandlerListeners : public SettingGroup
{
public:
    /// Initializes listeners with default values.
    HandlerListeners(SettingChangeController* controller = ONIXS_CMEMDH_NULLPTR)
        : 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_ : ONIXS_CMEMDH_NULLPTR);
    }

    /// 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.
    HandlerListeners& handler(HandlerListener* listener)
    {
        controlAssignment("Handler Listener", handler_, listener ? listener : &DefaultListeners::handler());

        return *this;
    }

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

    /// 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.
    HandlerListeners& feeds(ChannelFeedListener* listener)
    {
        controlAssignment("ChannelFeed Listener", feeds_, listener ? listener : &DefaultListeners::feeds());

        return *this;
    }

    /// 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_ : ONIXS_CMEMDH_NULLPTR);
    }

    /// 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.
    HandlerListeners& marketData(MarketDataListener* listener)
    {
        controlAssignment("MarketData Listener", marketData_, listener ? listener : &DefaultListeners::marketData());

        return *this;
    }

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

    /// 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.
    HandlerListeners& security(SecurityListener* listener)
    {
        controlAssignment("Security Listener", security_, listener ? listener : &DefaultListeners::security());

        return *this;
    }

    /// Copies listeners from the given instance.
    ///
    /// Attributes controlling value assignment are
    /// not cloned and thus only listeners are copied.
    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_;
    }
};

/// Serializes information on associated listeners.
ONIXS_CMEMDH_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_CMEMDH_NAMESPACE_END