Beesnest/DcEnginesSet.h

Go to the documentation of this file.

/*
Copyright 2007 Erez Bibi (erezbibi@users.sourceforge.net)
This file is part of Beesnest.

Beesnest is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Beesnest is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Beesnest; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

/* DcEnginesSet.h: interface for the CdcEnginesSet class. */

#ifndef __CDC_ENGINES_LIST
#define __CDC_ENGINES_LIST


#include "DcGlobals.h"
#include "DcHttpTime.h"
#include "DcParameters.h"
#include "Interfaces/DcEngine.h"
#include _GET_INCLUDE_PATH (DcMutex.h)
#include _GET_INCLUDE_PATH (DcThread.h)

/**
 * This class works very similar to <b>AdaptersSet</b>, just a little simpler.
 * In this case the <b>EnginesBank</b> is the client and this class is the server.
 * EnginesBank can put an engine here for storage, and can take an engine out.
 * When the EnginesBank takes an engine out, the class delete the place for this
 * engine, but the engine of course is still alive. When EnginesBank puts an
 * engine in, the class allocates a space for it, and set the idle Start Time to
 * Now. The only cases when this class delete an engine itself, is if it was
 * stored over the time limit, or if it was stored when the user logged out
 * (in the Destructor). Otherwise the Engines Bank is the one that deletes the
 * engines. It simply take them out and doesn't put them back in.
 *
 * <p>
 * This class is thread safe, as user can have more then one thread going in
 * the same time. An engine however, can be in use of just one thread at a time.
 *
 * <p>
 * @author Erez Bibi
 * @version 1.0
 */


class CdcEnginesSet
{
private:

    /**
     * Class of one node in the engines list.
     */
    class CdcEngineNode
    {
    public:
        IdcEngine* pEngine; /** Pointer to the engine itself. */
        CdcHttpTime tStartIdle; /** Time of saving an engine (idle) */

        /** Constructor - Save an engine pointer and init the time to now. */
        CdcEngineNode (IdcEngine* peng)
        :pEngine (peng) {}
    };

    typedef map <CdcString, CdcEngineNode*> t_engines_map;

    /** Map of engines and names. */
    t_engines_map mEngines;

    /** Mutex for this object. */
    CdcMutex oMutex;

    /** True when this set is in a logged in state. */
    bool isLoggedIn;

    /** The "auto release" thread object. */
    CdcThread oReleaseThread;

    /** Flag for signaling the ReLease thread to exit
    (dynamically allocated by the class and delete by the Release thread).
    It works this way so the thread will still have something to look at
    even when the class object is deallocated. */
    volatile bool* isReleseThreadGo;

    /** Dynamically allocated Mutex to prevent Release Thread clash with other
    threads. */
    CdcMutex* poLimitMutex;

    /** The time limit for all engines. */
    int nEngineTimeLimit;

public:

    /**
     * Constructor - Does nothing.
     */
    CdcEnginesSet ()
    :isReleseThreadGo (NULL), poLimitMutex (NULL)
    { nEngineTimeLimit =
    CdcParameters::ToInt (CdcParameters::GetParam ("Server->Engine-Time-Limit")); }

    /**
     * The Destructor - Does nothing.
     */
     virtual ~CdcEnginesSet() {}

    /**
     * start the release thread.
     */
    void Login ();

    /**
     * close all engines, and close the release thread.
     */
    void Logout ();

    /**
     * If this object has an engine of the name 'name' it returns it and removes
     * it from its map.
     * <p>
     * @param name The desired engine name.
     * @return (IdcEngine*) The engine pointer or NULL.
     */
    IdcEngine* GetEngine (const CdcString& name);

    /**
     * This function adds an engine to the set. If an engine with this name is
     * already in the set, it will not replace it and return false.
     * <p>
     * @param name The engine name.
     * @param peng A pointer to this engine.
     * @return (bool) True on success, or False if an engine with this name
     *  is already in the set.
     */
    bool PutEngine (const CdcString& name, IdcEngine* peng);

    /**
     * This is a global friend function. This function runs in a separate thread,
     * has access to all private members of the class and in charge of releasing
     * engines that have not been used for sometime. The time is defined in the
     * parameters file for all the engines. This time limit can be zero (so
     * engines will not be released). The release thread get created just if the
     * time limit for the engines exists and its more then 0.
     */
    friend int DcReleaseEngine (void* pParam);
};

#endif /* __CDC_ENGINES_LIST */