source: xplra/src/plugin/src/xplra/RequestQueue.h@ 92:e3a0abb22ef4

// Copyright (c) 2013 by István Váradi

// This file is part of XPLRA, a remote-access plugin for X-Plane

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:

// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// The views and conclusions contained in the software and documentation are those
// of the authors and should not be interpreted as representing official policies,
// either expressed or implied, of the FreeBSD Project.

#ifndef XPLRA_REQUESTQUEUE_H
#define XPLRA_REQUESTQUEUE_H
//------------------------------------------------------------------------------

#include <hu/varadiistvan/scpl/Mutex.h>
#include <hu/varadiistvan/scpl/CondVar.h>

#include <XPLMProcessing.h>

#include <vector>

//------------------------------------------------------------------------------

// Define to 1, if the new XPLMScheduleFlightLoop function should be
// used to schedule the flight loop only on-demand
#define USE_SCHEDULE_FLIGHTLOOP 0

//------------------------------------------------------------------------------

namespace xplra {

//------------------------------------------------------------------------------

class Request;

//------------------------------------------------------------------------------

/**
 * The queue of the requests. Client serving threads can add requests
 * to the queue. The queue provides a flight loop callback, which it
 * automatically schedules if a request is added to it, unless we are
 * already disabled.
 *
 * An instance of the queue should be created in the plugin enable
 * callback. The disable callback should disable the queue, so that it
 * will not accept any further requests.
 */
class RequestQueue
{
private:
    /**
     * Type for the collection of the queued requests.
     */
    typedef std::vector<Request*> requests_t;

#if !USE_SCHEDULE_FLIGHTLOOP
    /**
     * The interval of the flight loop.
     */
    static constexpr float flightLoopInterval = 0.1;
#endif

    /**
     * The flight loop function.
     */
    static float flightLoop(float inElapsedSinceLastCall,
                            float inElapsedTimeSinceLastFlightLoop,
                            int inCounter, void* inRefCon);

#if USE_SCHEDULE_FLIGHTLOOP
    /**
     * The ID of the flight loop running the queue.
     */
    XPLMFlightLoopID flightLoopID;
#endif

    /**
     * The mutex protecting the queue.
     */
    hu::varadiistvan::scpl::Mutex mutex;

    /**
     * A conditional variable to notify the threads waiting for their
     * request to be executed.
     */
    hu::varadiistvan::scpl::CondVar requestsDone;

    /**
     * Indicate if the queue is enabled or not.
     */
    volatile bool enabled;

    /**
     * The vector of the queued requests.
     */
    requests_t requests;

public:
    /**
     * Construct the queue. It creates the flight loop, so it should
     * be called from a plugin callback.
     */
    RequestQueue();

    /**
     * Execute the given request. It will be enqueued, and then this
     * function will wait until the request is executed or the request
     * queue is disabled.
     *
     * If the queue is already disabled when calling this function, it
     * returns immediately with false.
     *
     * @return if the request was executed
     */
    bool execute(Request* request);

    /**
     * Disable the queue. It sets the flag indicating that the queue
     * is disabled, and wakes up all waiters waiting on the
     * conditional variable. It should be called from a plugin
     * callback, as it also destroys the flight loop.
     */
    void disable();

private:
    /**
     * Run the queue.
     *
     * It locks the mutex, swaps the vector of requests with an empty
     * one, unlocks the mutex and runs the requests one by one. When
     * all requests are executed, it wakes up all waiters waiting on
     * the conditional variable.
     *
     * It is called from the flight loop function.
     */
    void run();
};

//------------------------------------------------------------------------------

} /* namespace xplra */

//------------------------------------------------------------------------------
#endif // XPLRA_REQUESTQUEUE_H

// Local Variables:
// mode: C++
// c-basic-offset: 4
// indent-tabs-mode: nil
// End: