Public API Reference

csutil/blockallocator.h

Go to the documentation of this file.

/*
  Crystal Space Generic Object Block Allocator
  Copyright (C) 2005 by Eric Sunshine <[email protected]>
            (C) 2006 by Frank Richter

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  This library 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
  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __CSUTIL_BLOCKALLOCATOR_H__
#define __CSUTIL_BLOCKALLOCATOR_H__

#include "csutil/fixedsizeallocator.h"

#include "csutil/custom_new_disable.h"

template<typename T>
class csBlockAllocatorDisposeDelete
{
public:
  template<typename BA>
  csBlockAllocatorDisposeDelete (const BA&, bool legit)
  { (void)legit; }
  void Dispose (void* p) 
  {
    ((T*)p)->~T();
  }
};

template<typename T>
class csBlockAllocatorDisposeLeaky
{
  bool doWarn;
#ifdef CS_DEBUG
  const char* parentClass;
  const void* parent;
  size_t count;
#endif
public:
#ifdef CS_DEBUG

  template<typename BA>
  csBlockAllocatorDisposeLeaky (const BA& ba, bool legit) :
    doWarn (!legit), parentClass (typeid(BA).name()), parent (&ba),
    count (0)
  { 
  }
#else
  template<typename BA>
  csBlockAllocatorDisposeLeaky (const BA&, bool legit) : doWarn (!legit)
  { }
#endif
  ~csBlockAllocatorDisposeLeaky()
  {
#ifdef CS_DEBUG
    if ((count > 0) && doWarn)
    {
      csPrintfErr("%s %p leaked %zu objects.\n", parentClass, (void*)this, 
        count);
    }
#endif
  }
  void Dispose (void* p) 
  {
    if (!doWarn) ((T*)p)->~T();
#ifdef CS_DEBUG
    count++;
#endif
  }
};

template <class T,
  class Allocator = CS::Memory::AllocatorMalloc, 
  class ObjectDispose = csBlockAllocatorDisposeDelete<T> >
class csBlockAllocator : public csFixedSizeAllocator<sizeof (T), Allocator>
{
public:
  typedef csBlockAllocator<T, Allocator> ThisType;
  typedef T ValueType;
  typedef Allocator AllocatorType;

protected:
  typedef csFixedSizeAllocator<sizeof (T), Allocator> superclass;
private:
  void* Alloc (size_t /*n*/) { return 0; }                       // Illegal
  void* Alloc (void* /*p*/, size_t /*newSize*/) { return 0; }   // Illegal
  void SetMemTrackerInfo (const char* /*info*/) { }             // Illegal
public:
  csBlockAllocator(size_t nelem = 32) : superclass (nelem)
  {
  }

  ~csBlockAllocator()
  {
    ObjectDispose dispose (*this, false);
    DisposeAll (dispose);
  }

  void Empty()
  {
    ObjectDispose dispose (*this, true);
    DisposeAll (dispose);
  }

  T* Alloc ()
  {
    return new (superclass::Alloc()) T;
  }

  void Free (T* p)
  {
    ObjectDispose dispose (*this, true);
    superclass::Free (dispose, p);
  }
  bool TryFree (T* p)
  {
    ObjectDispose dispose (*this, true);
    return superclass::TryFree (dispose, p);
  }
};

#include "csutil/custom_new_enable.h"

#endif // __CSUTIL_BLOCKALLOCATOR_H__

---