---

NativeLock.cpp

/*
 * NOTE: "zlib/libpng" style License
 *
 *                 ----=== s t d n e t ===----
 *
 * Copyright (c) 2002 Warwick Molloy   w-molloy@users.sf.net
 *
 * Copyright (c) 2002 Stdnet Community
 * HTTP://Sourceforge.net/projects/stdnet
 *
 * All references to "software" refer to the stdnet.
 *
 * This software is provided 'as-is', without any express or
 * implied warranty. In no event will the authors be held liable
 * for any damages arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any
 * purpose, including commercial applications, and to alter it
 * and redistribute it freely, subject to the following
 * restrictions:
 *
 * 1.  The origin of this software must not be misrepresented;
 *     you must not claim that you wrote the original software.
 *     If you use this software in a product, an acknowledgment
 *     in the product documentation would be appreciated but
 *     is not required.
 *
 * 2.  Altered source versions must be plainly marked as such,
 *     and must not be misrepresented as being the original
 *     software.
 *
 * 3.  This notice may not be removed or altered from any source
 *     distribution.
 */

#define __USE_GNU
#include <pthread.h>
#include <time.h>

#include <stdnet/system/platform/posix/NativeLock>

namespace stdbase {
    namespace system {
        namespace platform {

Lock::
    Lock()
    :   mutex(),
        condition()
{
    pthread_mutex_init( & mutex, NULL );
    pthread_cond_init( & condition, NULL );
    locked = false;
}

Lock::
    ~Lock()
{
    pthread_cond_destroy( & condition );
    pthread_mutex_destroy( & mutex );
}

void Lock::
    seize()
{
    int val = pthread_mutex_lock( & mutex );
    locked = true;
}

bool Lock::
    trySeize()
{
    int val = pthread_mutex_trylock( & mutex );
    return val == 0;
}

void Lock::
    release()
{
    int val;
    
    locked = false;
    val = pthread_mutex_unlock( & mutex );
}

void Lock::
    waitSignal()
{
    int result = pthread_cond_wait( & condition, &mutex );
}

bool Lock::
    timedWaitSignal( int millisec )
{
    bool    retval;
    int     result;
    struct timespec stop_time;

    stop_time.tv_sec = time( NULL ) + (millisec / 1000);
    stop_time.tv_nsec = (millisec % 1000) * 1000;

    result = pthread_cond_timedwait( &condition, &mutex, &stop_time);
    return retval == 0;
}

void Lock::
    signal()
{
    int result;
    result = pthread_cond_signal( & condition );
}

void Lock::
    signalAll()
{
    int result;
    result = pthread_cond_broadcast( & condition );
}

        } // -- end platform --
    } // -- end system --
} // -- end stdbase --

---