SessionScheduler.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 <set>
 
#include <OnixS/FIXEngine/ABI.h>
 
#include <OnixS/FIXEngine/Threading/Thread.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);
ONIXS_FIXENGINE_API_DECL(class, Counterparty);
 
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
    onInitiatorConnecting(
        const SessionScheduler &,
        Session *,
        const Counterparty &) {}

    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() ONIXS_FIXENGINE_DEFAULT;
};

struct SchedulerThreadingModel
{
    enum Enum
    {
        DedicatedThreads,

        ExternalThread
    };

    ONIXS_FIXENGINE_API static const char * toString(SchedulerThreadingModel::Enum value);
};

class
    ONIXS_FIXENGINE_API
    SessionSchedulerOptions
{
public:
    SessionSchedulerOptions();

    ~SessionSchedulerOptions();

    const std::string & configurationFile() const;

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

    SessionSchedulerListener * eventListener() const;

    void eventListener(SessionSchedulerListener * listener);

    SchedulerThreadingModel::Enum threadingModel() const;

    void threadingModel(SchedulerThreadingModel::Enum threadingModel);
 
private:
    std::string * configurationFile_;
    SessionSchedulerListener * eventListener_;
    SchedulerThreadingModel::Enum threadingModel_;
};

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);

    bool isScheduled(Session * session);

    void dispatchEvents();

    void serviceThreadAffinity(const OnixS::Threading::CpuIndexes & cpuIndexes);

    const OnixS::Threading::CpuIndexes & serviceThreadAffinity() const;

    void reconnectAttempts(int value);

    int reconnectAttempts() const;

    void reconnectInterval(int value);

    int reconnectInterval() const;

    void utcTimeUsage(bool value);

    bool utcTimeUsage() const;
 
private:
    class Impl;
    Impl * impl_;
};
}
}
}