GlimpseService.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 <boost/function.hpp>
#include <boost/scoped_ptr.hpp>

#include <OnixS/ItchCore/Types.h>
#include <OnixS/ItchCore/SoupBinTCP/ReconnectableSession.h>

#include "NamespaceHelper.h"

namespace OnixS {
namespace HandlerCore { 
namespace Common {
    class HandlerLogger;
}}}
    
ONIXS_HANDLER_NAMESPACE_BEGIN

struct HandlerSettings;

class GlimpseService : public Logging::LogFacility, private OnixS::ItchCore::SoupBinTCP::ReconnectableSessionListener
{
public:
    typedef boost::function<void(const std::string&)> OnFailureCallback;
    typedef boost::function<void(const std::string&)> OnWarningCallback;

    typedef boost::function<void(const DataSource&, const IncomingMessage*)> OnMessageCallback;
    typedef boost::function<void()> OnRestartedCallback;

    GlimpseService(
            const HandlerSettings& settings,
            const Logging::LogFacility* parent,
            HandlerCore::Common::HandlerLogger* logger);

    virtual ~GlimpseService();

    void request(const OnixS::ItchCore::SessionType& session, SequenceNumber requestedSequence);

    void stop(bool wait);

    bool inProgress() const;

    void subscribeOnFailure(OnFailureCallback callback);
    void subscribeOnWarning(OnWarningCallback callback);
    void subscribeOnMessage(OnMessageCallback callback);
    void subscribeOnRestarted(OnRestartedCallback callback);



private:
    template<typename TMsg>
    void log (const TMsg & msg) { if(logger_) logger_->log (msg); }

    void processData(OnixS::ItchCore::SoupBinTCP::ReconnectableSession& session, const void* data, UInt16 size);

    void invokeOnFailure(const std::string&);
    void invokeOnWarning(const std::string&);

    void invokeOnMessage(const DataSource&, const IncomingMessage&);
    void invokeOnRestarted();


    void onError(OnixS::ItchCore::SoupBinTCP::ReconnectableSession&, const std::string&) override;
    void onWarning(OnixS::ItchCore::SoupBinTCP::ReconnectableSession&, const std::string&) override;
    void onStateChange(OnixS::ItchCore::SoupBinTCP::ReconnectableSession&,
                               OnixS::ItchCore::SoupBinTCP::ReconnectableSessionState::Enum oldState,
                               OnixS::ItchCore::SoupBinTCP::ReconnectableSessionState::Enum newState) override;
    void onData(OnixS::ItchCore::SoupBinTCP::ReconnectableSession&, const void* data, UInt16 size) override;

private:
    const HandlerSettings& settings_;
    const OnixS::ItchCore::SoupBinTCP::ReconnectableSessionSettings sessionSettings_;
    OnixS::ItchCore::SoupBinTCP::ConnectivitySettings sessionConnectivitySettings_;
    HandlerCore::Common::HandlerLogger* logger_;
    
    boost::scoped_ptr<OnixS::ItchCore::SoupBinTCP::ReconnectableSession> session_;

    boost::atomic_bool inProgress_;

    OnFailureCallback onFailureCallback_;
    OnWarningCallback onWarningCallback_;
    OnMessageCallback onMessageCallback_;
    OnRestartedCallback onRestartedCallback_;
    
    typedef OnixS::Concurrency::RecursiveMutex Mutex;
    typedef OnixS::Concurrency::Guard<OnixS::Concurrency::Mutex> Guard;

    mutable Mutex sessionLock_;
    std::string sessionId_;
};


ONIXS_HANDLER_NAMESPACE_END