first commit

extern/stdcxx/4.2.1/tests/include/rw_allocator.h

@@ -0,0 +1,292 @@
+/**************************************************************************
+ *
+ * rw_allocator.h - user-defined allocator type
+ *
+ * $Id: rw_allocator.h 550991 2007-06-26 23:58:07Z sebor $
+ *
+ ***************************************************************************
+ *
+ * Licensed to the Apache Software  Foundation (ASF) under one or more
+ * contributor  license agreements.  See  the NOTICE  file distributed
+ * with  this  work  for  additional information  regarding  copyright
+ * ownership.   The ASF  licenses this  file to  you under  the Apache
+ * License, Version  2.0 (the  "License"); you may  not use  this file
+ * except in  compliance with the License.   You may obtain  a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the  License is distributed on an  "AS IS" BASIS,
+ * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
+ * implied.   See  the License  for  the  specific language  governing
+ * permissions and limitations under the License.
+ *
+ * Copyright 2006 Rogue Wave Software.
+ * 
+ **************************************************************************/
+
+#ifndef RW_ALLOCATOR_INCLUDED
+#define RW_ALLOCATOR_INCLUDED
+
+
+#include <testdefs.h>
+
+
+_RWSTD_NAMESPACE (std) {
+
+// declare to avoid dragging in all of <memory>
+// (yes, it is undefined for programs to do that)
+template <class T>
+class allocator;
+
+}   // namespace std
+
+
+struct _TEST_EXPORT SharedAlloc
+{
+    // identifies each member function of a standard allocator class
+    enum MemFun {
+        m_ctor,         // ordinary constructor
+        m_cpy_ctor,     // copy constructor
+        m_cvt_ctor,     // converting (template) constructor
+        m_cpy_assign,   // ordinary assignment operator
+        m_cvt_assign,   // converting (template) assignment operator
+        m_dtor,         // destructor
+        m_allocate, m_deallocate,
+        m_construct, m_destroy,
+        m_address, m_max_size,
+        n_funs
+    };
+
+    // constructs an allocator object managing a memory pool
+    // of the specified size (bytes and blocks)
+    SharedAlloc (_RWSTD_SIZE_T /* max_bytes  */ = _RWSTD_SIZE_MAX,
+                 _RWSTD_SIZE_T /* max_blocks */ = _RWSTD_SIZE_MAX);
+
+    virtual ~SharedAlloc ();
+
+    // attempts to allocate storage for nelems objects of elemsize
+    // bytes each and returns a pointer to the allocated storage
+    // on success; throws std::bad_alloc on failure
+    virtual void*
+    allocate (_RWSTD_SIZE_T /* nelems */,
+              _RWSTD_SIZE_T /* elemsize */,
+              const void*   /* hint */);
+
+    // deallocates storage at ptr allocated by a call to allocate
+    // for nelems objects of elemsize bytes each
+    virtual void
+    deallocate (void*         /* ptr */,
+                _RWSTD_SIZE_T /* nelems */,
+                _RWSTD_SIZE_T /* elemsize */);
+
+    // returns the maximum number of objects of elemsize each
+    // that can be allocated from the pool managed by *this
+    virtual _RWSTD_SIZE_T
+    max_size (_RWSTD_SIZE_T /* elemsize */ = 1);
+
+    // records a call to the allocator member function fun and
+    // throws an exception derived from std::bad_alloc if the
+    // number of calls to the member function reaches the limit
+    // specified by throw_at_calls_
+    virtual void
+    funcall (MemFun /* fun */, const SharedAlloc* = 0);
+
+    // gets or sets a pointer to the global allocator object
+    static SharedAlloc*
+    instance (SharedAlloc* = 0);
+
+    // returns a unique id of this allocator object
+    int id () const { return id_; }
+
+    // resets the n_calls_ array to all zeros
+    void reset_call_counters ();
+
+    // returns the name of the member function
+    static const char* func_name (MemFun);
+
+    _RWSTD_SIZE_T max_bytes_;    // memory pool size in bytes
+    _RWSTD_SIZE_T max_blocks_;   // memory pool size in blocks
+
+    _RWSTD_SIZE_T n_bytes_;      // number of allocated bytes
+    _RWSTD_SIZE_T n_blocks_;     // number of allocated blocks
+
+    _RWSTD_SIZE_T n_refs_;       // number of references
+
+    // counter of the number of calls to each allocator member function
+    // made throughout the lifetime of this object
+    _RWSTD_SIZE_T n_calls_ [n_funs];
+
+    // counter of the number of exceptions thrown by each member function
+    // throughout the lifetime of this object
+    _RWSTD_SIZE_T n_throws_ [n_funs];
+
+    // member function counter value that, when reached, will cause
+    // an exception derived from std::bad_alloc to be thrown
+    _RWSTD_SIZE_T throw_at_calls_ [n_funs];
+
+private:
+    int id_;
+};
+
+
+// allocator types for easy specialization
+template <class T>
+struct AllocTypes
+{
+    typedef _RWSTD_SIZE_T    size_type;
+    typedef _RWSTD_PTRDIFF_T difference_type;
+    typedef T*               pointer;
+    typedef const T*         const_pointer;
+    typedef T&               reference;
+    typedef const T&         const_reference;
+};
+
+
+template <class T, class Types = AllocTypes<T> >
+struct UserAlloc
+{
+// private:
+    SharedAlloc* pal_;
+
+public:
+    typedef T                               value_type;
+    typedef typename Types::size_type       size_type;
+    typedef typename Types::difference_type difference_type;
+    typedef typename Types::pointer         pointer;
+    typedef typename Types::const_pointer   const_pointer;
+    typedef typename Types::reference       reference;
+    typedef typename Types::const_reference const_reference;
+
+    UserAlloc (SharedAlloc *pal = 0) _THROWS (())
+        : pal_ (pal ? pal : SharedAlloc::instance ()) {
+        RW_ASSERT (0 != pal_);
+        pal_->funcall (pal_->m_ctor);
+    }
+
+    UserAlloc (const UserAlloc &rhs) _THROWS (())
+        : pal_ (rhs.pal_) {
+        RW_ASSERT (0 != pal_);
+        pal_->funcall (pal_->m_cpy_ctor);
+    }
+
+    template <class U>
+    UserAlloc (const UserAlloc<U> &rhs) _THROWS (())
+        : pal_ (rhs.pal_) {
+        RW_ASSERT (0 != pal_);
+        pal_->funcall (pal_->m_cvt_ctor);
+    }
+
+    template <class U>
+    void operator= (const UserAlloc<U> &rhs) {
+        pal_->funcall (pal_->m_cvt_assign, rhs.pal_);
+        pal_ = rhs.pal_;
+    }
+
+    template <class U>
+    struct rebind { typedef UserAlloc<U> other; };
+
+    void operator= (const UserAlloc &rhs) {
+        pal_->funcall (pal_->m_cpy_assign, rhs.pal_);
+        pal_ = rhs.pal_;
+    }
+
+    ~UserAlloc () {
+        pal_->funcall (pal_->m_dtor);
+    }
+
+    pointer allocate (size_type nelems, const void *hint = 0) {
+        void* const ptr = pal_->allocate (nelems, sizeof (value_type), hint);
+        return _RWSTD_STATIC_CAST (pointer, ptr);
+    }
+
+    void deallocate (pointer ptr, size_type nelems) {
+        pal_->deallocate (ptr, nelems, sizeof (value_type));
+    }
+
+    void construct (pointer ptr, const_reference val) {
+        pal_->funcall (pal_->m_construct);
+        new (ptr) value_type (val);
+    }
+
+    void destroy (pointer ptr) { 
+        pal_->funcall (pal_->m_destroy);
+        ptr->~T ();
+    }
+
+    pointer address (reference ref) const {
+        pal_->funcall (pal_->m_address);
+        return &ref;
+    }
+
+    const_pointer address (const_reference ref) const {
+        pal_->funcall (pal_->m_address);
+        return &ref;
+    }
+
+    size_type max_size () const _THROWS (()) {
+        return pal_->max_size (sizeof (value_type));
+    }
+
+    bool operator== (const UserAlloc &rhs) const {
+        return pal_->id () == rhs.pal_->id ();
+    }
+
+    bool operator!= (const UserAlloc &rhs) const {
+        return !operator== (rhs);
+    }
+};
+
+
+// when (line <= 0) establishes a new check point for memory leaks
+// by storing the number and size of blocks of storage currently
+// allocated by operator new and by the SharedAlloc object pointed
+// to by palloc (when non-zero)
+// when (line > 0) reports the difference between the the number
+// and size of blocks of storage allocated at the last checkpoint
+// and the values specified by expect_blocks and expect_bytes
+_TEST_EXPORT void
+rw_check_leaks (const SharedAlloc* /* palloc        */ = 0,
+                int                /* line          */ = 0,
+                _RWSTD_SIZE_T      /* expect_blocks */ = 0,
+                _RWSTD_SIZE_T      /* expect_bytes  */ = _RWSTD_SIZE_MAX);
+
+
+// when (line <= 0) establishes a new check point for memory leaks
+// by storing the number and size of blocks of storage currently
+// allocated by operator new
+// when (line > 0) reports the difference between the the number
+// and size of blocks of storage allocated at the last checkpoint
+// and the values specified by expect_blocks and expect_bytes
+template <class charT>
+inline void
+rw_check_leaks (const std::allocator<charT>& /* unused */,
+                int                          line          = 0,
+                _RWSTD_SIZE_T                expect_blocks = 0,
+                _RWSTD_SIZE_T                expect_bytes  = _RWSTD_SIZE_MAX)
+{
+    // can't track memory leaks here
+    rw_check_leaks ((SharedAlloc*)0, line, expect_blocks, expect_bytes);
+}
+
+
+// when (line <= 0) establishes a new check point for memory leaks
+// by storing the number and size of blocks of storage currently
+// allocated by operator new and by the user-defined allocator
+// specified by the first argument
+// when (line > 0) reports the difference between the the number
+// and size of blocks of storage allocated at the last checkpoint
+// and the values specified by expect_blocks and expect_bytes
+template <class charT, class Types>
+inline void
+rw_check_leaks (const UserAlloc<charT, Types> &alloc,
+                int                            line          = 0,
+                _RWSTD_SIZE_T                  expect_blocks = 0,
+                _RWSTD_SIZE_T                  expect_bytes  = _RWSTD_SIZE_MAX)
+{
+    // track memory leaks via SharedAlloc
+    rw_check_leaks (alloc.pal_, line, expect_blocks, expect_bytes);
+}
+
+#endif   // RW_ALLOCATOR_INCLUDED