vtkContainersAllocator.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * $Id: vtkContainersAllocator.h,v 1.1 2005/07/04 06:29:44 xpxqx Exp $
 *
 * Copyright (c) 2005 Sean McInerney
 * All rights reserved.
 *
 * See Copyright.txt or http://vtkcontainers.sourceforge.net/Copyright.html
 * 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 notice for more information.
 *
 */
#ifndef VTK_CONTAINERS_ALLOCATOR_H_
#  define VTK_CONTAINERS_ALLOCATOR_H_
#  include <limits>
#  ifdef VTK_CONTAINERS_SMALL_OBJECT_ALLOCATOR
#    include "vtkContainersAllocatorBase.h"
#  endif

template <class T>
class vtkContainersAllocator
#  ifdef VTK_CONTAINERS_SMALL_OBJECT_ALLOCATOR
  : public vtkContainersAllocatorBase
#  endif
{
public:
  // type definitions
  typedef size_t        size_type;
  typedef ptrdiff_t     difference_type;
  typedef T*            pointer;
  typedef const T*      const_pointer;
  typedef T&            reference;
  typedef const T&      const_reference;
  typedef T             value_type;

  // rebind allocator to type U
  template <class U>
  struct rebind
  {
    typedef vtkContainersAllocator<U> other;
  };

  // return address of values
  pointer address (reference value) const
    { return &value; }
  const_pointer address (const_reference value) const
    { return &value; }

  /* Constructors and destructor
   * -nothing to do because allocator has no state
   */
  vtkContainersAllocator (void) throw() {}
  vtkContainersAllocator (const vtkContainersAllocator&) throw() {}
  template <class U>
  vtkContainersAllocator (const vtkContainersAllocator<U>&) throw() {}
  ~vtkContainersAllocator() throw() {}

  // return maximum number of elements that can be allocated
  size_type max_size (void) const throw()
    { return std::numeric_limits<size_t>::max() / sizeof(T); }

  // allocate but don't initialize num elements of type T
  pointer allocate (size_type num, const void* = 0)
    {
#  ifdef VTK_CONTAINERS_SMALL_OBJECT_ALLOCATOR
      return (pointer)_allocate(num*sizeof(T));
#  else
      return (pointer)(::operator new(num*sizeof(T)));
#  endif
    }

  // initialize elements of allocated storage p with value
  //   (initialize memory with placement new)
  void construct (pointer p, const T& value)
    { new((void *)p)T(value); }

  // destroy elements of initialized storage p
  //   (destroy objects by calling their destructor)
  void destroy (pointer p)
    { p->~T(); }

  // deallocate storage p of deleted items
  void deallocate (pointer p, size_type num)
    {
#  ifdef VTK_CONTAINERS_SMALL_OBJECT_ALLOCATOR
      _deallocate((void*)p, num*sizeof(T));
#  else
      ::operator delete((void*)p);
#  endif
    }
};

// return that all specializations of this allocator are interchangable
template <class T1, class T2>
bool operator== (const vtkContainersAllocator<T1>&,
                 const vtkContainersAllocator<T2>&) throw()
{ return true; }

template <class T1, class T2>
bool operator!= (const vtkContainersAllocator<T1>&,
                 const vtkContainersAllocator<T2>&) throw()
{ return false; }

#endif /* VTK_CONTAINERS_ALLOCATOR_H_ */
/* 
 * End of: $Id: vtkContainersAllocator.h,v 1.1 2005/07/04 06:29:44 xpxqx Exp $.
 * 
 */

---