Search  

---

C:/temp/src/j2k/Deprecated/Posix.old/Handle.cpp

Go to the documentation of this file.

#ifndef __J2K__PThread_Handle_CPP__
#define __J2K__PThread_Handle_CPP__

#include <j2k/Fred/PThread/Handle.hpp>

inline void Handle::addRef() {
  if ( object != NULL ) {
    pthread_mutex_lock(mutex);
    ++(*refCount);
    pthread_mutex_unlock(mutex);
  }
}

void Handle::removeRef() {
  if ( object != NULL ) {
    pthread_mutex_lock(mutex);

    if ( --(*refCount) == 0 ) {
      pthread_mutex_unlock(mutex);
      pthread_mutex_destroy(mutex);
      pthread_mutexattr_destroy(mutexAttr);

      if ( mutex != NULL ) {
        delete mutex;
        mutex = NULL;
      }

      if ( mutexAttr != NULL ) {
        delete mutexAttr;
        mutexAttr = NULL;
      }

      if ( refCount != NULL ) {
        delete refCount;
        refCount = NULL;
      }

      if ( object != NULL ) {
        delete object;
        object = NULL;
      }

    } else {
      pthread_mutex_unlock(mutex);
    }

  }
}

// Create a new Handle for a free-store object.
Handle::Handle() : object( NULL ), refCount(  NULL ),
                   mutex(  NULL ), mutexAttr( NULL ) { }

// Create a new Handle for a free-store object.
Handle::Handle( JObject* obj )
  : object( obj )
{

  if ( object != NULL ) {
    refCount  = new ULONG(1);
    mutexAttr = new pthread_mutexattr_t;
    mutex     = new pthread_mutex_t;
    pthread_mutexattr_init(mutexAttr);
    pthread_mutex_init(mutex, mutexAttr);
  } else {
    refCount  = NULL;
    mutexAttr = NULL;
    mutex     = NULL;
  }
}

Handle::Handle( const Handle& right )
  : object( right.object ), refCount(  right.refCount  ),
    mutex(  right.mutex  ), mutexAttr( right.mutexAttr )
{
  addRef();
}

Handle::Handle( JObject* obj, ULONG* rc,
                pthread_mutexattr_t* a, pthread_mutex_t* m )
  : object( obj ), refCount( rc ), mutexAttr( a ), mutex( m )
{
  addRef();
}

virtual Handle::~Handle() {
  removeRef();
}

Handle&  Handle::operator=( const Handle& right ) {
  if (object != right.object) {
    removeRef();
    object    = right.object;
    mutexAttr = right.mutexAttr;
    mutex     = right.mutex;
    refCount  = right.refCount;

    addRef();
  }

  return *this;
}

// Dereferences the Handle to access a member of the object pointed to.
JObject*  Handle::operator->() const {
  return object;
}

// Returns the object pointed to.
JObject&  Handle::operator*() const {
  return *object;
}

// Return TRUE, if the underlying pointer is non-null.
Handle::operator BOOL() const {
  return ( object != NULL );
}

#endif

---