Gateway.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 <OnixS/CboeCFE/Trading/BOE/Compiler.h>
 
#if ONIXS_BATS_BOE_HAS_GATEWAY_EMULATOR
 
#include <OnixS/CboeCFE/Trading/BOE/Testing/MessagePtr.h>
#include <OnixS/CboeCFE/Trading/BOE/Testing/ClientMessageListener.h>
 
#include <chrono>
 
namespace OnixS {
namespace CboeCFE {
namespace Trading {
namespace BOE {
namespace Testing {
 
 
class ONIXS_CBOE_CFE_BOE_API Gateway
{
public:
    explicit Gateway(int port, const char* host = "127.0.0.1", const std::chrono::seconds& acceptTimeout = std::chrono::seconds(10),
        const std::chrono::seconds& sendReceiveTimeout = std::chrono::seconds(10));

    virtual ~Gateway();

    Gateway(const Gateway&) = delete;
    Gateway& operator=(const Gateway&) = delete;

    Gateway(Gateway&&) noexcept;
    Gateway& operator=(Gateway&&) noexcept;

    void swap(Gateway&) noexcept;

    const char * host() const noexcept;

    int port() const noexcept;

    Gateway& acceptConnection(const std::chrono::seconds& acceptTimeout = std::chrono::seconds(0));

    Gateway& sendApplicationMessage(const OutgoingMessage& msg, SeqNumber seqNumber = SeqNumberTraits::InvalidValue);

    template <BOE::MessageType::Enum Type>
    MessagePtr<typename MessageTypeTraits<Type>::MessageType> receiveTypedMessage() const;

    void sendHeartbeat();

    LogoutRequestPtr waitUntilLogoutRequested(
        ClientMessageListener* listener = nullptr, ClientSessionMessageListener* sessionMessageListener = nullptr);

    Gateway& run(ClientMessageListener& listener);

    Gateway& run(ClientMessageListener& appMsgListener, ClientSessionMessageListener& sessionMsgListener);
 
protected:
    bool isConnectionClosed(const std::chrono::seconds& timeout) const;

    bool isConnectionClosed() const;

    Gateway& close();

    Gateway& disconnect();

    MessageBasePtr receive() const;

    MessageBasePtr receive(PacketContainer && container, MessageSize containerSize);

    Gateway& sendData(const void* data, size_t size);

    Gateway& sendSessionMessage(const OutgoingMessage& msg);

    LoginRequestPtr receiveLoginRequest();

    LogoutRequestPtr receiveLogoutRequest();

    ClientHeartbeatPtr receiveClientHeartbeat();

    LoginRequestPtr acceptLogin(SeqNumber clientSequence = 1);

    LoginRequestPtr rejectLogin();

    LogoutRequestPtr acceptLogout();

    LoginRequestPtr acceptSession(SeqNumber clientSequence = 1);

    void sendLogout(LogoutResponseReason::Enum reason);

    void sendReplayComplete();
 
private:
    class Impl;
    Impl* impl_;
};
 
template <BOE::MessageType::Enum Type>
MessagePtr<typename MessageTypeTraits<Type>::MessageType> Gateway::receiveTypedMessage() const
{
    return cast<Type>(receive());
}
 
 
}}}}}
 
#endif