C:/Users/Pasha/_Dev/fixforge-cpp/fix/cppEngine/include/OnixS/FIX/Scheduling/SessionConnectionSettings.h

/*
* Copyright 2005-2011 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. 
*/

#if !defined(__ONIXS_FIXENGINE_SCHEDULING_SESSIONCONNECTIONSETTINGS_H__)
#define __ONIXS_FIXENGINE_SCHEDULING_SESSIONCONNECTIONSETTINGS_H__

#include <string>
#include <vector>

#include "OnixS/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();

                Session::Role role() const;
                
                unsigned heartBeatInterval() const;
                
                bool setResetSequenceNumbers() const;

                Message* logonMessage() const;

                const Counterparties& counterparties() const;

                SessionConnectionSettings& 
                operator =(const SessionConnectionSettings& other);

            protected:
                SessionConnectionSettings(Session::Role role);

                void heartBeatInterval(unsigned interval);

                void setResetSequenceNumbers(bool resetSeqNumbers);

                void logonMessage(const Message& message);

                Counterparties& counterparties();

            private:
                Session::Role role_;
                
                unsigned heartBeatInterval_;
                
                bool resetSeqNumbers_;

                Message* logonMessage_;

                Counterparties* counterparties_;
            };

            inline 
            Session::Role 
            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();
            };

            // Session connection settings for session as initiators.
            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 = NULL);

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

#endif // __ONIXS_FIXENGINE_SCHEDULING_SESSIONCONNECTIONSETTINGS_H__