[boost] [Concept Check] - Extending the BCCL with AllocatorConcept

From: Michael Fawcett (michael.fawcett_at_[hidden])
Date: 2008-03-26 10:53:18

I recently had the need to code up an AllocatorConcept, and it
occurred to me that it might fit well within the BCCL.  I noticed that
Intrusive also had an allocator concept and wondered if other
libraries did too (perhaps under a different name).

Would this be of interest as an extension to BCCL?  A quick Google
search of boost.org shows that dynamic_bitset, multi_index, function,
regex, shared_ptr (and I'm sure more) all have Allocator template
parameters where it might make sense.

For very generic concepts such as Allocator, do they belong in BCCL
rather than coded in each library?

I've pasted the code below.

--Michael Fawcett

-- code --

namespace boost {

template <typename T>
struct AllocatorConcept {
        typedef typename T::const_pointer const_pointer;
        typedef typename T::const_reference const_reference;
        typedef typename T::difference_type difference_type;
        typedef typename T::pointer pointer;
        typedef typename T::reference reference;
        typedef typename T::size_type size_type;
        typedef typename T::value_type value_type;
        // TODO: Do we need to do more here, e.g.
char_allocator_type::rebind<value_type>::other == T?
        typedef typename T::template rebind<char>::other char_allocator_type;

        BOOST_CLASS_REQUIRE(T, boost, DefaultConstructibleConcept);
        BOOST_CLASS_REQUIRE(T, boost, CopyConstructibleConcept);
        BOOST_CLASS_REQUIRE(T, boost, EqualityComparableConcept);

        void constraints() {
                pointer p = 0;
                reference ref = *p;
                const_reference cref = *p;

                p = value.address(ref);
                const_pointer cp = value.address(cref);

                p = value.allocate(1);
                p = value.allocate(1, 0);

                value.construct(p, *p);

                value.deallocate(p, 1);

                value.destroy(p);

                size_type s = value.max_size();
        }

private:
        T value;
};
}