Handler.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/SgxTitan/MarketData/Itch/Handler.h>
#include <OnixS/SgxTitan/MarketData/Itch/Exception.h>

#include <OnixS/SgxTitan/MarketData/Itch/MessageListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/OrderBookListener.h>

#include "HandlerImpl.h"
#include "ListenerHolder.h"
#include "Version.h"

#include "NamespaceHelper.h"

ONIXS_HANDLER_NAMESPACE_BEGIN


Handler::Handler(const HandlerSettings & settings)
    : impl_(new Impl(settings))
{
}

Handler::~Handler()
{
    delete impl_;
}

void Handler::registerErrorListener (ErrorListener* listener)
{
    if (HandlerState::Stopped == state()) 
        impl_->listenerHolder().set (listener);
    else                                       
        throw OperationException (__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerWarningListener (WarningListener* listener)
{
    if (HandlerState::Stopped == state()) 
        impl_->listenerHolder().set (listener);
    else                                       
        throw OperationException (__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerHandlerStateListener (HandlerStateListener* listener)
{
    if (HandlerState::Stopped == state()) 
        impl_->listenerHolder().set (listener);
    else                                       
        throw OperationException (__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerTimeMessageListener(TimeListener* listener)
{
    if (HandlerState::Stopped == state())
        impl_->listenerHolder().set(listener);
    else
        throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerEventAndStateListener(EventAndStateChangeListener* listener)
{
    if (HandlerState::Stopped == state())
        impl_->listenerHolder().set(listener);
    else
        throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerReferenceDataListener(ReferenceDataListener* listener)
{
    if (HandlerState::Stopped == state())
        impl_->listenerHolder().set(listener);
    else
        throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerOrderListener(MarketByOrderListener* listener)
{
    if (HandlerState::Stopped == state())
        impl_->listenerHolder().set(listener);
    else
        throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerTradeListener(TradeListener* listener)
{
    if (HandlerState::Stopped == state())
        impl_->listenerHolder().set(listener);
    else
        throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerAuctionListener(AuctionListener* listener)
{
    if (HandlerState::Stopped == state())
        impl_->listenerHolder().set(listener);
    else
        throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerMessageListener(MessageListener* listener)
{
    if (HandlerState::Stopped == state())
        impl_->listenerHolder().set(listener);
    else
        throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::registerOrderBookListener(OrderBookListener* listener)
{
    if (HandlerState::Stopped == state())
        impl_->listenerHolder().set(listener);
    else
        throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::setOrderBookIdFilter(const std::set<OrderBookId>& orderBookIdFilter)
{
    if (HandlerState::Stopped == state())
        impl_->setOrderBookIdFilter(orderBookIdFilter);
    else
        throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}
    
void Handler::bindFeedEngine(FeedEngine& feedEngine)
{
    if (HandlerState::Stopped == state()) impl_->bindFeedEngine(feedEngine);
    else                                       throw OperationException(__FUNCTION__, "Unable to change listener while handler connected");
}

void Handler::start()
{
    impl_->start();
}

void Handler::start(const ReplayOptions& options)
{
    if (HandlerState::Stopped != state()) 
        throw OperationException (__FUNCTION__, "Handler already started");

    impl_->start(options);
}

void Handler::stop(bool wait)
{
    impl_->stop(wait);
}

HandlerState::Enum Handler::state () const
{
    return HandlerState::Enum(impl_->getState());
}

/*
Logging
*/

void Handler::log (LogLevel::Enum logLevel, const char * logMessage, size_t length)
{
    impl_->commonLog (int (logLevel), logMessage, length);
}

void Handler::log (LogLevel::Enum logLevel, const char * logMessage)
{
    impl_->commonLog (int (logLevel), logMessage, strlen (logMessage));
}

void Handler::log (LogLevel::Enum logLevel, const std::string& str)
{
    impl_->commonLog (int (logLevel), str.c_str(), str.length());
}

/*
Information requests
*/

std::string Handler::licenseExpirationDate () const
{
    return impl_->licenseExpirationDate();
}

const char* Handler::version() 
{
    return Itch::version();
}

ONIXS_HANDLER_NAMESPACE_END