C:/Users/Pasha/_Dev/fixforge-cpp/fix/cppEngine/include/OnixS/FIX/Scheduling/SessionScheduler.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_SESSIONSCHEDULER_H__)
#define __ONIXS_FIXENGINE_SCHEDULING_SESSIONSCHEDULER_H__

#include <string>

#include "OnixS/FIX/ABI.h"

namespace OnixS
{
    namespace FIX
    {
        ONIXS_FIXENGINE_API_DECL(class, Session);

        namespace Scheduling
        {
            ONIXS_FIXENGINE_API_DECL(class, SessionScheduler);

            ONIXS_FIXENGINE_API_DECL(class, SessionSchedule);
            ONIXS_FIXENGINE_API_DECL(class, SessionConnectionSettings);

            typedef std::string SessionScheduleId;
            typedef std::string SessionConnectionSettingsId;

            class 
            ONIXS_FIXENGINE_API 
            SessionSchedulerListener
            {
            public:
                virtual void onLoggingOut(
                    const SessionScheduler& scheduler,
                    Session* session,
                    bool* allowLogout) = 0;

                virtual void onWarning(
                    const SessionScheduler& scheduler, 
                    Session* session, 
                    const std::string& warningReason) = 0;

                virtual void onError(
                    const SessionScheduler& scheduler, 
                    Session* session, 
                    const std::string& errorReason) = 0;

            protected:
                virtual ~SessionSchedulerListener();
            };

            class 
            ONIXS_FIXENGINE_API 
            SessionSchedulerOptions
            {
            public:
                SessionSchedulerOptions();

                SessionSchedulerOptions(const SessionSchedulerOptions&);

                ~SessionSchedulerOptions();

                const std::string& configurationFile() const;

                void configurationFile(const std::string& file);

                SessionSchedulerListener* eventListener() const;

                void eventListener(SessionSchedulerListener* listener);

                SessionSchedulerOptions&
                operator =(const SessionSchedulerOptions& other);

            private:
                std::string* configurationFile_;
                SessionSchedulerListener* eventListener_;
            };

            class ONIXS_FIXENGINE_API SessionScheduler
            {
            public:
                SessionScheduler(const SessionSchedulerOptions& options);

                ~SessionScheduler();

                const SessionSchedule* 
                findSchedule(const SessionScheduleId& id) const;

                const SessionConnectionSettings* 
                findConnectionSettings(const SessionConnectionSettingsId& id) const;

                void add(
                    Session* session, 
                    const SessionSchedule& schedule,
                    const SessionConnectionSettings& connection);

                void add(
                    Session* session,
                    const SessionScheduleId& scheduleId,
                    const SessionConnectionSettingsId& connectionId);

                void remove(Session* session);

            private:
                class Impl;
                Impl* impl_;
            };
        }
    }
}

#endif // __ONIXS_FIXENGINE_SCHEDULING_SESSIONSCHEDULER_H__