Subject: [Boost-commit] svn:boost r53993 - sandbox/monotonic/boost/monotonic
From: christian.schladetsch_at_[hidden]
Date: 2009-06-17 00:03:05
Author: cschladetsch
Date: 2009-06-17 00:03:04 EDT (Wed, 17 Jun 2009)
New Revision: 53993
URL: http://svn.boost.org/trac/boost/changeset/53993
Log:
reformatting, comments, simplified allocator ctors
Text files modified:
sandbox/monotonic/boost/monotonic/allocator.h | 75 +++++++++++++++++++--------------------
sandbox/monotonic/boost/monotonic/static_storage.h | 4 +
2 files changed, 40 insertions(+), 39 deletions(-)
Modified: sandbox/monotonic/boost/monotonic/allocator.h
==============================================================================
--- sandbox/monotonic/boost/monotonic/allocator.h (original)
+++ sandbox/monotonic/boost/monotonic/allocator.h 2009-06-17 00:03:04 EDT (Wed, 17 Jun 2009)
@@ -16,15 +16,13 @@
{
namespace monotonic
{
- /// forward declaration
+ /// a monotonic allocator always increases in size
template <class>
- class allocator;
+ struct allocator;
- /// specialization for void
template <>
- class allocator<void>
+ struct allocator<void>
{
- public:
typedef void* pointer;
typedef const void* const_pointer;
@@ -36,11 +34,10 @@
};
};
- /// a monotonic allocator always increases in size
template <class T>
- class allocator
+ struct allocator
{
- public:
+ BOOST_STATIC_CONSTANT(size_t, alignment = boost::aligned_storage<sizeof(T)>::alignment);
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T *pointer;
@@ -48,8 +45,6 @@
typedef T &reference;
typedef const T &const_reference;
typedef T value_type;
-
- /// rebind storage to a another type
template <class U>
struct rebind
{
@@ -57,7 +52,6 @@
};
private:
- /// the storage used by the allocator
storage_base *storage;
public:
@@ -66,22 +60,20 @@
{
}
- allocator(storage_base &P) throw()
- : storage(&P)
+ allocator(storage_base &store) throw()
+ : storage(&store)
{
}
- allocator(const allocator& Q) throw()
- : storage(Q.storage)
+ allocator(const allocator& alloc) throw()
+ : storage(alloc.get_storage())
{
}
template <class U>
- allocator(const allocator<U> &Q) throw()
+ allocator(const allocator<U> &alloc) throw()
+ : storage(alloc.get_storage())
{
- typedef BOOST_DEDUCED_TYPENAME allocator<T>::template rebind<U> Other;
- typedef BOOST_DEDUCED_TYPENAME Other::other OtherStorage;
- storage = OtherStorage(*Q.get_storage()).get_storage();
}
~allocator() throw()
@@ -98,16 +90,14 @@
return &x;
}
- BOOST_STATIC_CONSTANT(size_t, alignment = boost::aligned_storage<sizeof(T)>::alignment);
-
pointer allocate(size_type num, allocator<void>::const_pointer /*hint*/ = 0)
{
BOOST_ASSERT(num > 0);
BOOST_ASSERT(storage != 0);
- return static_cast<T *>(storage->allocate(num*sizeof(T), alignment));
+ return static_cast<pointer>(storage->allocate(num*sizeof(value_type), alignment));
}
- void deallocate(pointer p, size_type n)
+ void deallocate(pointer, size_type)
{
// do nothing
}
@@ -117,36 +107,36 @@
if (!storage)
return 0;
//return storage->max_size()/(sizeof(T) + alignment);
- return storage->max_size()/sizeof(T);
+ return storage->max_size()/sizeof(value_type);
}
- void construct(pointer p)
+ void construct(pointer ptr)
{
- new (p) T();
+ new (ptr) value_type();
}
- void construct(pointer p, const T& val)
+ void construct(pointer ptr, const T& val)
{
- new (p) T(val);
+ new (ptr) value_type(val);
}
- void destroy(pointer p)
+ void destroy(pointer ptr)
{
- if (!p)
+ if (!ptr)
return;
- destroy(p, boost::has_trivial_destructor<T>());
+ destroy(ptr, boost::has_trivial_destructor<value_type>());
}
- void destroy(pointer p, const boost::false_type& )
+ void destroy(pointer ptr, const boost::false_type& )
{
- (*p).~T();
+ (*ptr).~value_type();
}
void destroy(pointer, const boost::true_type& )
{
}
- void swap(allocator<T> &other)
+ void swap(allocator<value_type> &other)
{
std::swap(storage, other.storage);
}
@@ -156,10 +146,19 @@
return storage;
}
- friend bool operator==(allocator<T> const &A, allocator<T> const &B) { return A.storage == B.storage; }
- friend bool operator!=(allocator<T> const &A, allocator<T> const &B) { return A.storage != B.storage; }
+ friend bool operator==(allocator<T> const &A, allocator<T> const &B)
+ {
+ return A.storage == B.storage;
+ }
+
+ friend bool operator!=(allocator<T> const &A, allocator<T> const &B)
+ {
+ return A.storage != B.storage;
+ }
};
- }
-}
+
+ } // namespace monotonic
+
+} // namespace boost
//EOF
Modified: sandbox/monotonic/boost/monotonic/static_storage.h
==============================================================================
--- sandbox/monotonic/boost/monotonic/static_storage.h (original)
+++ sandbox/monotonic/boost/monotonic/static_storage.h 2009-06-17 00:03:04 EDT (Wed, 17 Jun 2009)
@@ -23,7 +23,9 @@
template <size_t InlineSize, size_t MinHeapIncrement, class Al, template <size_t, size_t, class> class Storage>
struct static_storage_base : storage_base
{
- typedef Storage<InlineSize, MinHeapIncrement, Al> StorageType;
+ typedef Al HeapAllocator;
+ typedef Storage<InlineSize, MinHeapIncrement, HeapAllocator> StorageType;
+
private:
StorageType global;