/home/vlg/develop/libASSA/libassa/assa/Semaphore.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
// $Id: Semaphore.h,v 1.4 2006/07/20 02:30:54 vlg Exp $
//------------------------------------------------------------------------------
//                               Semaphore.h
//------------------------------------------------------------------------------
//  Copyright (c) 2000 by Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------

#ifndef SEMAPHORE_H
#define SEMAPHORE_H

#if !defined(WIN32)

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#include "assa/Assure.h"    // trace() & Assert family

namespace ASSA {

class Semaphore
{
public:
    Semaphore ();

    virtual ~Semaphore ();

    int create (key_t key_, int initval_ = 1);

    int open (key_t key_);

    void close ();

    void remove ();

    void wait ();

    void signal ();

    void op (int val_);

    key_t key () const { return m_key; }

    int id () const { return m_id; }

    void dump (void) const;

protected:
    void init ();

protected:
    key_t   m_key;

    int     m_id;

protected:
    static const int BIGCOUNT;

    static sembuf m_op_lock      [2];

    static sembuf m_op_endcreate [2];

    static sembuf m_op_open      [2];

    static sembuf m_op_close     [3];

    static sembuf m_op_unlock    [1];

    static sembuf m_op_op        [1];
};

inline 
Semaphore::
Semaphore ()
{
    trace_with_mask("Semaphore::Semaphore", SEM);

    init ();
}

inline
Semaphore::
~Semaphore ()
{
    trace_with_mask("Semaphore::~Semaphore", SEM);
    
    if (m_id > 0) {
        this->close ();
    }
}

inline void
Semaphore::
init ()
{
    m_key = (key_t) -1;
    m_id  = -1;
}   

inline void
Semaphore::
wait ()
{
    trace_with_mask("Semaphore::wait", SEM);
    op (-1);
}

inline void
Semaphore::
signal ()
{
    trace_with_mask("Semaphore::signal", SEM);
    op (1);
}

} // end namespace ASSA

#endif /* !defined(WIN32) */

#endif /* SEMAPHORE_H */  

---