FeedEngineThreads.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/CME/ConflatedUDP/String.h>
#include <OnixS/CME/ConflatedUDP/ThreadPool.h>

ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

// A bit of forward declarations. 

ONIXS_CONFLATEDUDP_EXPORTED_CLASS_DECL
(
    FeedEngineThreads
);

/// Listener for thread-related events.
/// 
/// Members of this classes are invoked to reflect 
/// various life-time events of threads spawned and 
/// used by feed engines while processing market data. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT 
FeedEngineThreadListener
{
    /// Invoked by a feed engine when a 
    /// new processing thread is spawned. 
    /// 
    /// @note Invocation is performed by the newly 
    /// started thread thus making possible application 
    /// of any thread-specific turn-up. 
    virtual 
    void 
    onFeedEngineThreadBegin
    (
        const FeedEngineThreads&
    )
    {
    }

    /// Invoked by a feed engine when a 
    /// processing thread is about to end. 
    /// 
    /// @note Invocation is performed by the thread 
    /// thus making possible thread-specific cleanup. 
    virtual
    void
    onFeedEngineThreadEnd
    (
        const FeedEngineThreads&
    )
    {
    }

    /// Invoked when a thread reaches the idle state. 
    ///
    /// Invocation of the given member depends on the 
    /// returned value of a particular implementation of 
    /// the NetFeedEngine::process member. 
    /// 
    /// The returned value indicates whether the given event 
    /// was handled. The FeedEngineThreads makes a decision
    /// whether the processing is to be suspended depending
    /// on the returned value. 
    virtual 
    bool
    onFeedEngineThreadIdle
    (
        const FeedEngineThreads&
    )
    {
        return false;
    }

    /// Invoked if working thread experiences an issue 
    /// while processing its tasks. Once invoked, working 
    /// thread continues performing its tasks. 
    virtual
    void
    onFeedEngineThreadIssue
    (
        const FeedEngineThreads&,
        const Char*
    )
    {
    }
};

//

/// The collection of parameters affecting behavior 
/// of a thread pool carring out feed engine tasks.
ONIXS_CONFLATEDUDP_LTWT_CLASS 
FeedEngineThreadSettings
{
    ThreadPoolSettings pool_;
    UInt32 loopBeforeIdle_;

public:
    /// Assigns the default values for the given 
    /// instance of the thread pool settings. 
    FeedEngineThreadSettings()
      : loopBeforeIdle_(1)
    {
    }

    /// Settings related to the thread pool. 
    ThreadPoolSettings& 
    pool()
    {
        return pool_;
    }

    /// Settings related to the thread pool. 
    const 
    ThreadPoolSettings& 
    pool() const
    {
        return pool_;
    }

    /// Number of working threads in the pool.
    UInt32 
    loopBeforeIdle() const
    {
        return loopBeforeIdle_;
    }

    /// Defines the number of working threads in the pool.
    void 
    loopBeforeIdle(UInt32 value)
    {
        loopBeforeIdle_ = value;
    }
};

/// Serializes settings defining behavior 
/// of feed engine threads into a string. 
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&,
    const 
    FeedEngineThreadSettings&);

/// Serializes settings defining behavior 
/// of feed engine threads into a string. 
inline 
std::string
toStr(
    const 
    FeedEngineThreadSettings& settings)
{
    std::string str;

    toStr(str, settings);

    return str;
}

//

ONIXS_CONFLATEDUDP_EXPORTED_CLASS_DECL
(
    NetFeedEngine
);

/// The given class represents a pool of 
/// threads carring out feed engine tasks. 
ONIXS_CONFLATEDUDP_EXPORTED_CLASS 
FeedEngineThreads
{
    // The workhorse for the class. 
    class Workhorse;

    Workhorse* workhorse_;

public:
    /// Initializes working threads and spawns 
    /// feed engine process() routine invocation. 
    FeedEngineThreads(
        NetFeedEngine&, 
        const FeedEngineThreadSettings&, 
        FeedEngineThreadListener* = NULL);

    /// Stops carring out all tasks and 
    /// destructs the working threads.     
    ~FeedEngineThreads();
};

ONIXS_CONFLATEDUDP_NAMESPACE_END