ListenerHolder.cpp

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.
*/
#include <OnixS/HandlerCore/HandlerLogger.h>
#include <OnixS/HandlerCore/Compiler.h>

#include <OnixS/SgxTitan/Trading/OUCH/ErrorListener.h>
#include <OnixS/SgxTitan/Trading/OUCH/WarningListener.h>
#include <OnixS/SgxTitan/Trading/OUCH/HandlerStateListener.h>
#include <OnixS/SgxTitan/Trading/OUCH/SessionListener.h>
#include <OnixS/SgxTitan/Trading/OUCH/MessageListener.h>

#include "Utils.h"
#include "ListenerHolder.h"

using namespace OnixS::SgxTitan::Trading::Ouch;
using namespace OnixS::SgxTitan::Trading::Ouch::Implementation;

/*
ListenerHolder
*/

ListenerHolder::ListenerHolder (const OnixS::Logging::LogFacility* parent,
                                OnixS::HandlerCore::Common::HandlerLogger& logger)
    : base("ListenerHolder", parent, OnixS::Logging::LOG_LEVEL_DEBUG)
    , logger_ (logger)
    , errorListener_ (nullptr)
    , warningListener_ (nullptr)
    , handlerStateListener_(nullptr)
    , sessionListener_(nullptr)
    , messageListener_(nullptr)
{
}

/*
User callback's
*/

void ListenerHolder::invokeError (OnixS::SgxTitan::Trading::Ouch::ErrorCode::Enum code, const std::string& description)
{
    if (ErrorListener* listener = errorListener_)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(listener->onError(code, description), "onError");
    }
}

void ListenerHolder::invokeWarning (const std::string& description)
{
    if (WarningListener* listener = warningListener_)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(listener->onWarning(description), "onWarning");
    }
}

void ListenerHolder::invokeStateChanged (HandlerState::Enum newState)
{
    if (HandlerStateListener* listener = handlerStateListener_)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(listener->onStateChanged(newState), "onStateChanged");
    }
}

void ListenerHolder::invokeReceivedBytes(const char* bytes, size_t size)
{
    if (SessionListener* listener = sessionListener_)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(listener->onReceivedBytes(bytes, size), "onReceivedBytes");
    }
}


#define DEFINE_MESSAGE_CALLBACK(MsgType) \
void ListenerHolder::invoke(const MsgType& msg)\
{\
    if (MessageListener* listener = messageListener_)\
    {\
        ONIXS_EXCEPTION_TRACED_CALLBACK(listener->on##MsgType(msg), "on"#MsgType);\
    }\
}\

DEFINE_MESSAGE_CALLBACK(OrderAccepted)
DEFINE_MESSAGE_CALLBACK(OrderRejected)
DEFINE_MESSAGE_CALLBACK(OrderReplaced)
DEFINE_MESSAGE_CALLBACK(OrderCancelled)
DEFINE_MESSAGE_CALLBACK(OrderExecuted)