~ubuntu-branches/ubuntu/oneiric/nux/oneiric

 * Copyright 2010 Inalogic® Inc.

//   int ObjectStats::_total_allocated_size = 0;

//   int ObjectStats::_number_of_objects = 0;

//   ObjectStats::AllocationList ObjectStats::_allocation_list;

 

  ObjectStats::AllocationList::AllocationList()

  {

 

  }

 

  ObjectStats::AllocationList::~AllocationList()

  {

 

  }

 

    _total_allocated_size = 0;

      LOG_DEBUG(logger) << _number_of_objects << " undeleted objects.";

#if defined(NUX_DEBUG)

    AllocationList::iterator it;

    for (it = _allocation_list.begin(); it != _allocation_list.end(); it++)

      Object* obj = NUX_STATIC_CAST (Object*, (*it));

      LOG_DEBUG(logger) << "Undeleted object: Type "

                        << obj->Type().m_Name << ", "

                        << obj->_allocation_file_name.GetTCharPtr()

                        << "line " << obj->_allocation_line_number;

    _allocation_file_name      = __Nux_FileName__;

    _allocation_line_number    = __Nux_LineNumber__;

 

    _reference_count      = new NThreadSafeCounter();

    _weak_reference_count = new NThreadSafeCounter();

    _objectptr_count     = new NThreadSafeCounter();

    _destroyed            = new bool(false);

 

    _reference_count->Set (1);

    _weak_reference_count->Set (1);

 

    SetOwnedReference (OwnTheReference);

    *_destroyed = true;

 

    if (IsHeapAllocated ())

    {

      // If the object has properly been UnReference, it should have gone through Destroy(). if that is the case then

      // _reference_count should be NULL or its value (returned by GetValue ()) should be equal to 0;

      // We can use this to detect when delete is called directly on an object.

      nuxAssertMsg((_reference_count == 0) || (_reference_count && (_reference_count->GetValue () == 0)),

                   TEXT("[Object::~Object] Invalid object destruction. Make sure to call UnReference or Dispose (if the object has never been referenced) on the object.\nObject allocated at: %s [%d]"),

                   _allocation_file_name.GetTCharPtr (),

                   _allocation_line_number);

      

      nuxAssertMsg((_weak_reference_count == 0) || (_weak_reference_count && (_weak_reference_count->GetValue () > 0)),

                   TEXT("[Object::~Object] Invalid value of the weak reference count pointer. Make sure to call UnReference or Dispose (if the object has never been referenced) on the object.\nObject allocated at: %s [%d]"),

                   _allocation_file_name.GetTCharPtr (),

                   _allocation_line_number);

 

      if ((_reference_count == 0) && (_weak_reference_count == 0))

      {

        delete _destroyed;

      }

      else

      {

        // There is a smart pointer holding a weak reference to this object. It is the responsibility

        // of the last smart pointer to delete '_destroyed'.

      }

    }

    else

    {

      delete _reference_count;

      delete _weak_reference_count;

      delete _objectptr_count;

      delete _destroyed;

    }

    if (!IsHeapAllocated ())

    {

      LOG_ERROR(logger) << "Trying to reference an object that was not heap allocated. "

                        << "\nObject allocated at: " << GetAllocationLoation();

      return false;

    }

 

    if (_reference_count->GetValue() == 0 || *_destroyed)

    {

      // If this happens, all bets are off, and this may crash.

      LOG_ERROR(logger) << "Trying to reference an object that has been deleted."

                        << "\nObject allocated at: " << GetAllocationLoation();

    _reference_count->Increment();

    _weak_reference_count->Increment();

      LOG_ERROR(logger) << "Trying to un-reference an object that was not heap allocated. "

                        << "\nObject allocated at: " << GetAllocationLoation();

    if (_objectptr_count->GetValue() == _reference_count->GetValue())

      LOG_ERROR(logger) << "There are ObjectPtr hosting this object. "

                        << "Release all of them to destroy this object. "

                        << "\nObject allocated at: " << GetAllocationLoation();

    _reference_count->Decrement();

    _weak_reference_count->Decrement();

    if (_reference_count->GetValue() == 0)

      LOG_ERROR(logger) << "Trying to sink an object that was not heap allocated. "

                        << "\nObject allocated at: " << GetAllocationLoation();

    // The intent of the Dispose call is to destroy objects with a float reference (reference count is equal to 1 and

    // the '_owns_the_reference' flag is set to false). In Nux, only widgets object can have a floating reference.

    // And widgets are only visible if added to the widget tree. 

    // When an object with a floating reference is added to the widget tree, it becomes "owned'. It looses it

    // floating reference status but it still has a reference count number of 1.

    // In practice, since widgets must be added to the widget tree, there should never be a need to call Dispose

    // Dispose() was designed to only destroy objects with floating references, while UnReference() destroys objects

    // that are "owned" . That is now relaxed. Dispose() calls UnReference().

 

    if (!IsHeapAllocated ())

    {

      LOG_ERROR(logger) << "Trying to destroy an object that was not heap allocated. "

                        << "\nObject allocated at: " << GetAllocationLoation();

      return;

    }

 

    nuxAssert (_reference_count->GetValue() == 0);

 

    if ((_reference_count->GetValue() == 0) && (_weak_reference_count->GetValue() == 0) && (_objectptr_count->GetValue() == 0))

    {

      delete _reference_count;

      delete _weak_reference_count;

      delete _objectptr_count;

      _reference_count = 0;

      _weak_reference_count = 0;

      _objectptr_count = 0;

    }

    else

    {

      if ((_weak_reference_count == NULL) && (_objectptr_count->GetValue() == 0))

      {

        nuxDebugMsg (TEXT ("[Object::Destroy] Error on object allocated at %s [%d]:")

        , _allocation_file_name.GetTCharPtr ()

        , _allocation_line_number);

        nuxAssertMsg (0, TEXT("[Object::Destroy] Invalid pointer for the weak reference count."));

      }

 

      if ((_weak_reference_count->GetValue() == 0) && (_objectptr_count->GetValue() == 0))

      {

        nuxDebugMsg (TEXT ("[Object::Destroy] Error on object allocated at %s [%d]:")

          , _allocation_file_name.GetTCharPtr ()

          , _allocation_line_number);

        nuxAssertMsg (0, TEXT("[Object::Destroy] Invalid value of the weak reference count."));

      }

    }

 

    std::string obj_type(this->Type().m_Name);

  void Object::IncrementWeakCounter()

  {

    if (!IsHeapAllocated ())

    {

      LOG_ERROR(logger) << "Trying to increment weak counter on an object that was not heap allocated. "

                        << "\nObject allocated at: " << GetAllocationLoation();

      return;

    }

 

    _weak_reference_count->Increment();

  }

 

  void Object::DecrementWeakCounter()

  {

    if (!IsHeapAllocated())

    {

      LOG_ERROR(logger) << "Trying to decrement weak counter on an object that was not heap allocated. "

                        << "\nObject allocated at: " << GetAllocationLoation();

      return;

    }

 

    _weak_reference_count->Decrement();

  }

 

    return _reference_count->GetValue();

  }

 

  int Object::GetWeakReferenceCount() const

  {

    return _weak_reference_count->GetValue();

  sout << _allocation_file_name.GetTCharPtr()

       << ":" << _allocation_line_number;