MNPCList.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef OS_MNPCLIST_H
#define OS_MNPCLIST_H

#include "MNList.h"
#include "MNMutex.h"
#include "MNSem.h"
#include "MNProtectedVar.h"

#define PCLIST_NORMALMODE

/*************************************************************
 * MNPCList
 *************************************************************/

template <class T> class MNPCList : private MNList<T>
{
    bool    _locked;
    MNMutex _lock;
#ifdef PCLIST_NORMALMODE
    MNSem   _sem;
#else
    MNSemDebug _sem;
#endif

public:
    MNPCList ( const MNPCList<T>& orig )
        : MNList<T>(orig)
        , _locked(false)
#ifndef PCLIST_NORMALMODE
        , _sem( "MNPCList<T>" )
#endif
    {
    }

    MNPCList ( )
        : _locked(false)
#ifndef PCLIST_NORMALMODE
        , _sem( "MNPCList<T>" )
#endif
    {
    }

    ~MNPCList ( )
    {
    }

    MNPCList<T>& operator=( const MNPCList<T>& orig )
    {
        lock();
        MNList<T>::operator=(orig);
        unlock();
        return *this;
    }

    inline bool  empty()
    {
        lock();
        bool ret = MNList<T>::empty();
        unlock();
        return ret;
    }
    inline int   length()
    {
        lock();
        int ret = MNList<T>::length();
        unlock();
        return ret;
    }

    /*
     * T& peek_front(), T& peek_back and T& peek_here can not be
     * implemented with producer-consumer lists
     */
    inline T peek_front()
    {
        lock();
        T ret = MNList<T>::peek_front();
        unlock();
        return ret;
    }
    inline T peek_back()
    {
        lock();
        T ret = MNList<T>::peek_back();
        unlock();
        return ret;
    }

    /*
     * T& inf() can not be
     * implemented with producer-consumer lists
     */
    inline T inf(void* r)
    {
        lock();
        T ret = MNList<T>::inf(r);
        unlock();
        return ret;
    }

    inline void del_front()
    {
        lock();
        MNList<T>::del_front();
        unlock();
    }
    inline void del_back()
    {
        lock();
        MNList<T>::del_back();
        unlock();
    }
    inline void clear()
    {
        lock();
        MNList<T>::clear();
        unlock();
    }

    inline T pop()
    {
        lock();
        T ret = MNList<T>::pop();
        unlock();
        return ret;
    }

    inline void push_front( T x )
    {
        lock();
        MNList<T>::push_front(x);
        unlock();
    }
    inline void prepend( T x )
    {
        lock();
        MNList<T>::prepend(x);
        unlock();
    }
    inline void push_back( T x )
    {
        lock();
        MNList<T>::push_back(x);
        unlock();
    }
    inline void append( T x )
    {
        lock();
        MNList<T>::append(x);
        unlock();
    }

    /*
     * These are special functions for consumers and produders.
     * They manipulate the semaphore as well as the lock.
     */

    inline void signal()
    {
        _sem.signal();
    }

    inline void wait()
    {
        assert ( _locked == true );
        _locked = false;
        _sem.wait(_lock);
        _locked = true;
    }

    inline T consumer_pop()
    {
        lock();
        while ( locked_empty() ) wait();
        T ret = MNList<T>::pop();
        unlock();
        return ret;
    }

    inline bool consumer_pop( T& ret, ProtectedBool& terminate )
    {
        lock();
        do
        {
            if ( locked_empty() ) wait();
            if ( !locked_empty() && terminate==false )
            {
                ret = MNList<T>::pop();
                unlock();
                return true;
            }
        }
        while ( terminate==false );
        unlock();
        return false;
    }

    inline void producer_push_front( T x )
    {
        lock();
        MNList<T>::push_front(x);
        signal();
        unlock();
    }
    inline void producer_prepend( T x )
    {
        lock();
        MNList<T>::prepend(x);
        signal();
        unlock();
    }
    inline void producer_push_back( T x )
    {
        lock();
        MNList<T>::push_back(x);
        signal();
        unlock();
    }
    inline void producer_append( T x )
    {
        lock();
        MNList<T>::append(x);
        signal();
        unlock();
    }

    /*
     * Special functions that are used with manual locking.
     * This makes certainly sense when you look something up in a
     * list, and want to perform an operation based on the item
     * pointer.
     */

    inline void lock()
    {
        _lock.lock();
        assert ( _locked == false );
        _locked = true;  // this is obviously not safe, should be the TID
                         // but this is much cheaper for testing
    }

    inline void unlock()
    {
        assert ( _locked == true );
        _locked = false;
        _lock.unlock();
    }

    inline void* locked_first() const
    {
        assert ( _locked == true );
        return MNList<T>::first();
    }
    inline void* locked_last() const
    {
        assert ( _locked == true );
        return MNList<T>::last();
    }
    inline void* locked_pred(void* item) const
    {
        assert ( _locked == true );
        return MNList<T>::pred(item);
    }
    inline void* locked_succ(void* item) const
    {
        assert ( _locked == true );
        return MNList<T>::succ(item);
    }
    inline bool locked_empty() const
    {
        assert ( _locked == true );
        return MNList<T>::empty();
    }

    inline T locked_pop()
    {
        T ret = MNList<T>::pop();
        return ret;
    }

    inline void locked_append( T x )
    {
        assert ( _locked == true );
        MNList<T>::append(x);
    }

    inline T locked_inf(void* r)
    {
        assert ( _locked == true );
        return MNList<T>::inf(r);
    }

    inline void locked_del_item(void* item)
    {
        assert ( _locked == true );
        MNList<T>::del_item(item);
    }

    inline void locked_ins_before(  void* x, T y )
    {
        assert ( _locked == true );
        MNList<T>::ins_before(x,y);
    }

    inline void ins_after(  void* x, T y )
    {
        assert ( _locked == true );
        MNList<T>::ins_after(x,y);
    }
};

#endif /* OS_MNPCLIST_H */

---