itkLightObject.cxx

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkLightObject.cxx,v $
  Language:  C++
  Date:      $Date: 2009-02-05 19:05:00 $
  Version:   $Revision: 1.41 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#include "itkLightObject.h"
#include "itkObjectFactory.h"
#include "itkFastMutexLock.h"

#include <list>
#include <memory>
#include <exception>

// Better name demanging for gcc
#if __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ > 0 )
#define GCC_USEDEMANGLE
#endif

#ifdef GCC_USEDEMANGLE
#include <cstdlib>
#include <cxxabi.h>
#endif

#if defined(__APPLE__)
  // OSAtomic.h optimizations only used in 10.5 and later
  #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
    #include <libkern/OSAtomic.h>
  #endif

#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
  #if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2))
  # include <ext/atomicity.h>
  #else
  # include <bits/atomicity.h>
  #endif

#endif


namespace itk
{

#if defined(__GLIBCXX__) // g++ 3.4+

using __gnu_cxx::__atomic_add;
using __gnu_cxx::__exchange_and_add;

#endif

LightObject::Pointer
LightObject::New()
{
  Pointer smartPtr;
  LightObject *rawPtr = ::itk::ObjectFactory<LightObject>::Create();
  if(rawPtr == NULL)
    {
    rawPtr = new LightObject;
    }
  smartPtr = rawPtr;
  rawPtr->UnRegister();
  return smartPtr;
}

LightObject::Pointer
LightObject::CreateAnother() const
{
  return LightObject::New();
}

void 
LightObject
::Delete() 
{
  this->UnRegister();
}


#ifdef _WIN32
void*
LightObject
::operator new(size_t n)
{
  return new char[n];
}

void*
LightObject
::operator new[](size_t n)
{
  return new char[n];
}

void
LightObject
::operator delete(void* m)
{
  delete [] (char*)m;
}

void
LightObject
::operator delete[](void* m, size_t)
{
  delete [] (char*)m;
}
#endif 


void 
LightObject
::Print(std::ostream& os, Indent indent) const
{
  this->PrintHeader(os, indent); 
  this->PrintSelf(os, indent.GetNextIndent());
  this->PrintTrailer(os, indent);
}


void 
LightObject
::BreakOnError()
{
  ;  
}


void 
LightObject
::Register() const
{
  // Windows optimization
#if (defined(WIN32) || defined(_WIN32))
  InterlockedIncrement(&m_ReferenceCount);

  // Mac optimization
#elif defined(__APPLE__) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
 #if defined (__LP64__) && __LP64__
  OSAtomicIncrement64Barrier(&m_ReferenceCount);
 #else
  OSAtomicIncrement32Barrier(&m_ReferenceCount);
 #endif

  // gcc optimization
#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
  __atomic_add(&m_ReferenceCount, 1);

  // General case
#else
  m_ReferenceCountLock.Lock();
  m_ReferenceCount++;
  m_ReferenceCountLock.Unlock();
#endif
}


void 
LightObject
::UnRegister() const
{
  // As ReferenceCount gets unlocked, we may have a race condition
  // to delete the object.
   
  // Windows optimization
#if (defined(WIN32) || defined(_WIN32))
  if ( InterlockedDecrement(&m_ReferenceCount) <= 0 )
    {
    delete this;
    }

// Mac optimization
#elif defined(__APPLE__) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
 #if defined (__LP64__) && __LP64__
  if ( OSAtomicDecrement64Barrier(&m_ReferenceCount) <= 0 )
    {
    delete this;
    }
 #else
  if ( OSAtomicDecrement32Barrier(&m_ReferenceCount) <= 0 )
    {
    delete this;
    }
 #endif

// gcc optimization
#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
  if ( __exchange_and_add(&m_ReferenceCount, -1) <= 1 )
    {
    delete this;
    }

// General case
#else
  m_ReferenceCountLock.Lock();
  InternalReferenceCountType tmpReferenceCount = --m_ReferenceCount;
  m_ReferenceCountLock.Unlock();
  
  if ( tmpReferenceCount <= 0)
    {
    delete this;
    }
#endif
}


void
LightObject
::SetReferenceCount(int ref)
{
  m_ReferenceCountLock.Lock();
  m_ReferenceCount = static_cast<InternalReferenceCountType>(ref);
  m_ReferenceCountLock.Unlock();

  if ( ref <= 0)
    {
    delete this;
    }
}

LightObject
::~LightObject()
{
  if(m_ReferenceCount > 0 && !std::uncaught_exception())
    {
    // A general exception safety rule is that destructors should
    // never throw.  Something is wrong with a program that reaches
    // this point anyway.  Also this is the least-derived class so the
    // whole object has been destroyed by this point anyway.  Just
    // issue a warning.
    // itkExceptionMacro(<< "Trying to delete object with non-zero reference count.");
    itkWarningMacro("Trying to delete object with non-zero reference count.");
    }
}


void
LightObject
::PrintSelf(std::ostream& os, Indent indent) const
{
#ifdef GCC_USEDEMANGLE
  char const * mangledName = typeid(*this).name();
  int status;
  char* unmangled = abi::__cxa_demangle(mangledName, 0, 0, &status);

  os << indent << "RTTI typeinfo:   ";

  if(status == 0)
    {
    os << unmangled;
    free(unmangled);
    }
  else
    {
    os << mangledName;
    }

  os << std::endl;
#else
  os << indent << "RTTI typeinfo:   " << typeid( *this ).name() << std::endl;
#endif
  os << indent << "Reference Count: " << m_ReferenceCount << std::endl;
}


void
LightObject
::PrintHeader(std::ostream& os, Indent indent) const
{
  os << indent << this->GetNameOfClass() << " (" << this << ")\n";
}


void
LightObject
::PrintTrailer(std::ostream& itkNotUsed(os), Indent itkNotUsed(indent)) const
{
}


std::ostream&
operator<<(std::ostream& os, const LightObject& o)
{
  o.Print(os);
  return os;
}


} // end namespace itk