SessionConnectionSettings.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 <vector>
 
#include <OnixS/FIXEngine/FIX/Session.h>
 
namespace OnixS {
namespace FIX {
namespace Scheduling {
typedef std::string Host;

typedef unsigned Port;

class ONIXS_FIXENGINE_API Counterparty
{
public:
    Counterparty();

    Counterparty(const Host & host, Port port);

    Counterparty(const Counterparty & other);

    ~Counterparty();

    const Host & host() const;

    Port port() const;

    Counterparty & operator = (const Counterparty & other);
 
private:
    Host * host_;
    Port port_;
};
 

typedef std::vector<Counterparty> Counterparties;
 

class ONIXS_FIXENGINE_API SessionConnectionSettings
{
public:
    SessionConnectionSettings(
        const SessionConnectionSettings & other);

    virtual ~SessionConnectionSettings();

    SessionRole::Enum role() const;

    unsigned heartBeatInterval() const;

    bool setResetSequenceNumbers() const;

    Message * logonMessage() const;

    const Counterparties & counterparties() const;

    SessionConnectionSettings &
    operator = (const SessionConnectionSettings & other);
 
protected:
    SessionConnectionSettings(SessionRole::Enum role);

    void heartBeatInterval(unsigned interval);

    void setResetSequenceNumbers(bool resetSeqNumbers);

    void logonMessage(const Message & message);

    Counterparties & counterparties();
 
private:
    SessionRole::Enum role_;
 
    unsigned heartBeatInterval_;
 
    bool resetSeqNumbers_;
 
    Message * logonMessage_;
 
    Counterparties * counterparties_;
};
 
inline
SessionRole::Enum
SessionConnectionSettings::role() const
{
    return role_;
}
 
inline
unsigned
SessionConnectionSettings::heartBeatInterval() const
{
    return heartBeatInterval_;
}
 
inline
bool
SessionConnectionSettings::setResetSequenceNumbers() const
{
    return resetSeqNumbers_;
}
 
inline
Message *
SessionConnectionSettings::logonMessage() const
{
    return logonMessage_;
}
 
inline
const Counterparties &
SessionConnectionSettings::counterparties() const
{
    return *counterparties_;
}

class
    ONIXS_FIXENGINE_API
    AcceptorConnectionSettings
    : public SessionConnectionSettings
{
public:
    AcceptorConnectionSettings();
};

class
    ONIXS_FIXENGINE_API
    InitiatorConnectionSettings
    : public SessionConnectionSettings
{
public:
    InitiatorConnectionSettings(
        const Host & host, Port port);

    InitiatorConnectionSettings(
        const Host & host, Port port,
        bool resetSessionSequenceNumbers);

    InitiatorConnectionSettings(
        const Host & host, Port port,
        unsigned heartbeatInterval);

    InitiatorConnectionSettings(
        const Host & host, Port port,
        const Message & customLogonMessage);

    InitiatorConnectionSettings(
        const Host & host,
        Port port,
        unsigned heartbeatInterval,
        bool resetSessionSequenceNumbers,
        const Message * customLogonMessage = nullptr);

    void addCounterparty(const Host & host, Port port);
};
}
}
}