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 <OnixS/B3/BOE/ABI.h>
#include <OnixS/B3/BOE/Session.h>
#include <OnixS/B3/BOE/scheduling/SessionConnectionSettings.h>
#include <OnixS/B3/BOE/scheduling/SessionSchedule.h>
#include <OnixS/B3/BOE/threading/Thread.h>
 
#include <set>
#include <string>
 
namespace OnixS {
namespace B3 {
namespace BOE {
namespace Scheduling {
 
class SessionScheduler;
 
typedef std::string SessionScheduleId;
typedef std::string SessionConnectionSettingsId;

class ONIXS_B3_BOE_EXPORTED 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() ONIXS_B3_BOE_DEFAULT;
};

struct SchedulerThreadingModel
{
    enum Enum
    {
        Dedicated,

        External
    };

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

class ONIXS_B3_BOE_EXPORTED SessionSchedulerOptions
{
public:
    SessionSchedulerOptions();
 
    ~SessionSchedulerOptions();

    const std::string & configurationFile() const ONIXS_B3_BOE_NOTHROW;

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

    SessionSchedulerListener * eventListener() const ONIXS_B3_BOE_NOTHROW;

    SessionSchedulerOptions &eventListener(SessionSchedulerListener *listener) ONIXS_B3_BOE_NOTHROW;

    SchedulerThreadingModel::Enum threadingModel() const ONIXS_B3_BOE_NOTHROW;

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

class ONIXS_B3_BOE_EXPORTED SessionScheduler
{
public:
    static const size_t TimeResolutionMs = 10;
 
    SessionScheduler(const SessionSchedulerOptions & options);

    ~SessionScheduler();

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

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

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

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

    SessionScheduler &remove(Session *session);

    void dispatchEvents();

    SessionScheduler &serviceThreadAffinity(const OnixS::B3::BOE::CpuIndexes &cpuIndexes);

    const OnixS::B3::BOE::CpuIndexes &serviceThreadAffinity() const ONIXS_B3_BOE_NOTHROW;

    SessionScheduler &reconnectAttempts(int value);

    int reconnectAttempts() const;

    SessionScheduler &reconnectInterval(int value);

    int reconnectInterval() const;

    SessionScheduler &utcTimeUsage(bool value);

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