semafore.cpp

/*
  Copyright (c) 2009 by Jakob Schroeter <js@camaya.net>
  This file is part of the glooxd library. http://camaya.net/glooxd

  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.

  This software is distributed without any warranty.
*/


#include "semafore.h"

#if !defined( _WIN32 ) && !defined( _WIN32_WCE )
# include "config.h"
#endif

#ifdef _WIN32
# include <windows.h>
#endif

#ifdef _WIN32_WCE
# include <winbase.h>
#endif

#if defined(__APPLE__) && defined(__MACH__)
  // NOTE: On Mac OS, unnamed semaphores are not implemented,
  // even though the headers are all there.
  // So, we'll use the native Mach type.
# include <mach/mach_init.h>
# include <mach/semaphore.h>
# include <mach/task.h>
#elif defined(HAVE_PTHREAD)
# include <semaphore.h>
#endif

#include <stdio.h>

namespace glooxd
{

  namespace util
  {

    class Semaphore::SemaphoreImpl
    {
      public:
        SemaphoreImpl( int value );
        ~SemaphoreImpl();
        void wait();
        bool trywait();
        void post();
      private:
        SemaphoreImpl( const SemaphoreImpl& );
        SemaphoreImpl& operator=( const SemaphoreImpl& );

#ifdef _WIN32
        HANDLE m_semaphore;
#elif defined(__APPLE__) && defined(__MACH__)
        semaphore_t m_semaphore;
#elif defined( HAVE_PTHREAD )
        sem_t m_semaphore;
#endif

    };

    Semaphore::SemaphoreImpl::SemaphoreImpl( int value )
    {
#ifdef _WIN32
      m_semaphore = CreateSemaphore( 0, 0, 123456, 0 );
#elif defined(__APPLE__) && defined(__MACH__)
      kern_return_t result = semaphore_create( mach_task_self(), &m_semaphore, SYNC_POLICY_FIFO, value );
      if( result != KERN_SUCCESS )
      {
#ifdef DEBUG
        printf( "Semaphore::SemaphoreImpl() call to semaphore_create failed: %d\n", result );
#endif
      }
#elif defined( HAVE_PTHREAD )
      int result = sem_init( &m_semaphore, 0, value );
      if( result == -1 )
      {
#ifdef DEBUG
        printf( "Semaphore::SemaphoreImpl() call to sem_init failed: %d\n", errno );
#endif
      } 
#endif
    }

    Semaphore::SemaphoreImpl::~SemaphoreImpl()
    {
#ifdef _WIN32
      CloseHandle( m_semaphore );
#elif defined(__APPLE__) && defined(__MACH__)
      semaphore_destroy( mach_task_self(), m_semaphore );
#elif defined( HAVE_PTHREAD )
      sem_destroy( &m_semaphore );
#endif
    }

    void Semaphore::SemaphoreImpl::wait()
    {
#ifdef _WIN32
      WaitForSingleObject( m_semaphore, INFINITE );
#elif defined(__APPLE__) && defined(__MACH__)
      semaphore_wait( m_semaphore );
#elif defined( HAVE_PTHREAD )
      sem_wait( &m_semaphore );
#endif
    }

    bool Semaphore::SemaphoreImpl::trywait()
    {
#ifdef _WIN32
      return ( WaitForSingleObject( m_semaphore, 0 ) == WAIT_OBJECT_0 );
#elif defined(__APPLE__) && defined(__MACH__)
      mach_timespec_t timeout = { 0, 0 };
      return ( semaphore_timedwait( m_semaphore, timeout ) == KERN_SUCCESS );
#elif defined( HAVE_PTHREAD )
      return !sem_trywait( &m_semaphore );
#endif
      return true;
    }

    void Semaphore::SemaphoreImpl::post()
    {
#ifdef _WIN32
      ReleaseSemaphore( m_semaphore, 1, 0 );
#elif defined(__APPLE__) && defined(__MACH__)
      semaphore_signal( m_semaphore );
#elif defined( HAVE_PTHREAD )
      sem_post( &m_semaphore );
#endif
    }

    Semaphore::Semaphore( int value )
      : m_semaphore( new SemaphoreImpl( value ) )
    {
    }

    Semaphore::~Semaphore()
    {
      delete m_semaphore;
    }

    void Semaphore::wait()
    {
      m_semaphore->wait();
    }

    bool Semaphore::trywait()
    {
      return m_semaphore->trywait();
    }

    void Semaphore::post()
    {
      m_semaphore->post();
    }

  }

}