• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMPointer_impl.h

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


 //
 // Constructors & destructor
 //

template < typename T, class Lock > inline Pointer < T, Lock >::Pointer()
  // You have to initialize the following attributes:
  // - mMeta
{
  mMeta = new Meta();
  mMeta->ptr = 0;
  mMeta->dead = true;
  mMeta->usage = 1;
  mMeta->ownMemory = false;
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline Pointer < T, Lock >::Pointer(const T * pointer,
                                                                        const bool & takeOwnership)
  // You have to initialize the following attributes:
  // - mMeta
{
  _assignCPointer((T * &)pointer, takeOwnership);
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline Pointer < T, Lock >::Pointer(Pointer < T, Lock > &pointer)
  // You have to initialize the following attributes:
  // - mMeta
{
  _assignPointer(pointer);
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline Pointer < T, Lock >::Pointer(const Pointer < T, Lock > &pointer)
  // You have to initialize the following attributes:
  // - mMeta
{
  Pointer < T, Lock > &_pointer = (Pointer < T, Lock > &)pointer;
  _assignPointer(_pointer);
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > Pointer < T, Lock >::~Pointer()
{
  _deletePointer();
}

 /*----------------------------------------------------------------------*/

 //
 // Operators
 //

template < typename T, class Lock > inline const Pointer < T, Lock > &Pointer < T,
  Lock >::operator=(const T * pointer)
  // Implementation of operator =
{
  if(!_equalsCPointer(pointer))
  {
        // Changing reference under continous lock
        _deletePointer(false, true);
        Meta *oldMeta = mMeta;

        _assignCPointer(pointer);

        // Release the previous and the current meta
        oldMeta->lock.unlock();
        unlock();
  }

  return *this;
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline const Pointer < T, Lock > &Pointer < T, Lock >::operator=(Pointer < T,
                                                                                                         Lock >
                                                                                                         &pointer)
  // Implementation of operator =
{
  if(!_equalsPointer(pointer))
        // Changing reference under continous lock
        _switchPointer(pointer, false);

  return *this;
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline const Pointer < T, Lock > &Pointer < T,
  Lock >::operator=(const Pointer < T, Lock > &pointer)
  // Implementation of operator =
{
  Pointer < T, Lock > &_pointer = (Pointer < T, Lock > &)pointer;

  if(!_equalsPointer(_pointer))
        // Changing reference under continous lock
        _switchPointer(_pointer, false);

  return *this;
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline T * Pointer < T, Lock >::operator->()
  // Implementation of operator ->
{
  Assert(this->isNotNull(), NULL_POINTER_ERROR, "Pointer::operator->");
  return mMeta->ptr;
}

 /*----------------------------------------------------------------------*/

 /*----------------------------------------------------------------------*/

 /*----------------------------------------------------------------------*/

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline bool Pointer < T, Lock >::operator==(const T * pointer)
  // Implementation of operator ==
{
  return _equalsCPointer(pointer);
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline bool Pointer < T, Lock >::operator==(Pointer < T, Lock > &pointer)
  // Implementation of operator ==
{
  return _equalsPointer(pointer);
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline bool Pointer < T, Lock >::operator!=(const T * pointer)
  // Implementation of operator !=
{
  return !_equalsCPointer(pointer);
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline bool Pointer < T, Lock >::operator!=(Pointer < T, Lock > &pointer)
  // Implementation of operator !=
{
  return !_equalsPointer(pointer);
}

 /*----------------------------------------------------------------------*/

 //
 // Methods
 //

template < typename T, class Lock > inline bool Pointer < T, Lock >::isNull()const
{
  return mMeta->ptr == 0;
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline bool Pointer < T, Lock >::isNotNull()const
{
  return mMeta->ptr != 0;
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::assignWithLock(Pointer < T, Lock > &pointer)
{
  // TODO: this method does not work correctly
  // deadlock between _deletePointer and _assingPointer

  if(!_equalsPointer(pointer))
        _switchPointer(pointer, true);

  else
        // Nothing to assing simply lock
        lock();
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::reference(const T * pointer)
{
  if(!_equalsCPointer(pointer))
  {
        _deletePointer();
        _assignCPointer(pointer, false);
  }
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline T * Pointer < T, Lock >::getPtr()
{
  return mMeta->ptr;
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::kill(const bool & force)
{
  // Null reference can not be 
  Assert(isNotNull() && mMeta->ownMemory, NULL_POINTER_ERROR, "Pointer::kill()");

  // Note: zero reference indicates error, positive is proper after null checking
  _deletePointer(force);
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::setNull(const bool & force)
{
  lock();
  mMeta->ptr = 0;
  unlock();
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::lock()
{
  mMeta->lock.lock();
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline bool Pointer < T, Lock >::trylock()
{
  return mMeta->lock.trylock();
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::unlock()
{
  mMeta->lock.unlock();
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline bool Pointer < T, Lock >::getLocked()const
{
  return mMeta->lock.getLocked();
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::_deletePointer(const bool & force, const bool & keepLock)
{
  // Always lock before deleting
  lock();

  // Decrement usage counter
  if(mMeta->usage)
        mMeta->usage--;

  // Abadoned object will be killed (or force killing)
  if(!mMeta->usage || force)
        mMeta->dead = true;

  // Deallocate memory
  if(mMeta->dead && mMeta->ownMemory && mMeta->ptr)
  {
        delete mMeta->ptr;

        mMeta->ptr = 0;
  }
  // Unlock if no further locking is needed
  if(!keepLock)
        unlock();
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::_assignCPointer(const T * pointer, const bool & takeOwnership)
{
  // Possibly take ownership
  mMeta = new Meta();
  mMeta->ptr = (T *) pointer;
  mMeta->dead = !pointer;
  mMeta->usage = 1;
  mMeta->ownMemory = takeOwnership && pointer;
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::_assignPointer(Pointer < T, Lock > &pointer, const bool & keepLock)
{
  pointer.lock();
  mMeta = pointer.mMeta;
  mMeta->usage++;

  // Unlock if no further locking is needed
  if(!keepLock)
        pointer.unlock();
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline void Pointer < T,
 Lock >::_switchPointer(Pointer < T, Lock > &pointer, const bool & keepLock)
{
  // Delete pointer keeping continous lock
  _deletePointer(false, true);
  Meta *oldMeta = mMeta;

  _assignPointer(pointer, true);

  // Release the previous meta
  oldMeta->lock.unlock();

  // Release new meta
  if(!keepLock)
        unlock();
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline bool Pointer < T,
  Lock >::_equalsCPointer(const T * pointer) const
{
  return mMeta->ptr == pointer;
}

 /*----------------------------------------------------------------------*/

template < typename T, class Lock > inline bool Pointer < T, Lock >::_equalsPointer(Pointer < T,
                                                                                 Lock > &pointer) const
{
  return mMeta->ptr == pointer.mMeta->ptr;
}

 /*----------------------------------------------------------------------*/

© Copyright - 2006 (IT)² ParCompMark Dev. Team