K2Allocator.h

//========================================================================================
// 
// $File$
// 
// Owner: Mat Marcus
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __K2Allocator__
#define __K2Allocator__

#include "K2STLUtilities.h"
#include "K2Assert.h"


template <class T>
class K2Allocator {
public:
 typedef uint32 size_type;
 typedef std::ptrdiff_t difference_type;
 typedef T* pointer;
 typedef const T* const_pointer;
 typedef T& reference;
 typedef const T& const_reference;
 typedef T value_type;

 template <class U> struct rebind { typedef K2Allocator<U> other; };

 K2Allocator() {}

 template <class U>
 K2Allocator(const K2Allocator<U>&)
 {
 }

 pointer address(reference x) const {return &x;}
 const_pointer address(const_reference x) const {return &x;}

 pointer allocate(size_type n, const void* hint = nil);

 void deallocate(pointer p, size_type) {operator delete(p);}

 size_type max_size() const {return kMaxUInt32 / sizeof(T);}

 void construct(pointer p, const T& val) {new(p) T(val);}

 void destroy(pointer p) {p->~T();}
};


// ===================================================================================
// K2Allocator<void>
// specialization for void
// ===================================================================================
template <>
class K2Allocator<void> {
public:
 typedef std::size_t size_type;
 typedef std::ptrdiff_t difference_type;
 typedef void* pointer;
 typedef const void* const_pointer;
 typedef void value_type;
};


// ===================================================================================
// Inlines
// ===================================================================================
template <class T>
inline typename K2Allocator<T>::pointer
K2Allocator<T>::allocate(size_type n, const void*)
{
 pointer p = static_cast<pointer>(operator new(n * sizeof(T)));
 ASSERT_MSG(p != nil, "Memory allocation failure");
 return p;
}

template <class T, class U>
inline bool16
operator==(const K2Allocator<T>&, const K2Allocator<U>&)
{
 return true;
}

template <class T, class U>
inline bool16
operator!=(const K2Allocator<T>&, const K2Allocator<U>&)
{
 return false;
}


#endif