auto_buffer.hpp

新版本TR1的stl

        STLSOFT_ASSERT(is_valid());

        return reverse_iterator(end());
    }
    /// Ends the reverse iteration
    ///
    /// \return An iterator representing the end of the reverse sequence
    reverse_iterator  rend()
    {
        STLSOFT_ASSERT(is_valid());

        return reverse_iterator(begin());
    }
#endif /* STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT */

/// @}

/// \name Attributes
/// @{
public:
    /// \brief Returns the number of elements in the auto_buffer
    ///
    /// \note In the case where memory allocation has failed in the context
    /// where exceptions are not thrown for allocation failure in the
    /// constructor, this method will return 0. Hence, operations on the
    /// <i>empty</i> auto_buffer<> instance will be safe if made in respect of
    /// the value returned by this method.
    size_type size() const
    {
        STLSOFT_ASSERT(is_valid());

        return m_cItems;
    }

    /// \brief Returns the number of elements in the auto_buffer's internal buffer
    static size_type internal_size()
    {
        return space;
    }

    /// \brief Indicates whether the buffer has any contents
    ///
    /// \note This will only ever be true when an allocation above the number
    /// of elements in the internal array has been requested, and failed.
    ss_bool_t empty() const
    {
        STLSOFT_ASSERT(is_valid());

        return 0 == m_cItems;
    }

#if defined(STLSOFT_CF_ALLOCATOR_BASE_EXPENSIVEx)
    /// \brief Returns an instance of the allocator used to specialise the
    ///  instance.
    static allocator_type &get_allocator()
    {
# if !defined(STLSOFT_STRICT) && \
     defined(STLSOFT_COMPILER_IS_MSVC) && \
     _MSC_VER >= 1310
#  pragma warning(push)
#  pragma warning(disable : 4640)   /* "construction of local static object is not thread-safe" - since it is here! (As long as one uses a 'conformant' allocator) - maybe use a spin_mutex in future */
# endif /* compiler */

        static allocator_type   s_allocator;

        return s_allocator;

# if !defined(STLSOFT_STRICT) && \
     defined(STLSOFT_COMPILER_IS_MSVC) && \
     _MSC_VER >= 1310
#  pragma warning(pop)
# endif /* compiler */
    }
#else /* ? STLSOFT_CF_ALLOCATOR_BASE_EXPENSIVE */
    /// \brief Returns an instance of the allocator used to specialise the
    ///  instance.
    allocator_type get_allocator() const
    {
# if defined(STLSOFT_CF_ALLOCATOR_BASE_EXPENSIVE)
        return allocator_type();
# else /* ? STLSOFT_CF_ALLOCATOR_BASE_EXPENSIVE */
        return *this;
# endif /* STLSOFT_CF_ALLOCATOR_BASE_EXPENSIVE */
    }
#endif /* STLSOFT_CF_ALLOCATOR_BASE_EXPENSIVE */
/// @}

/// \name Implementation
/// @{
private:
    ss_bool_t   is_valid() const
    {
        ss_bool_t   bRet    =   true;

#if defined(STLSOFT_AUTO_BUFFER_AGGRESSIVE_SHRINK)
        if( space < m_cItems &&
            !m_bExternal)
        {
# ifdef STLSOFT_UNITTEST
            printf("auto_buffer is in external domain, but think's it isn't\n");
# endif /* STLSOFT_UNITTEST */

            bRet = false;
        }
        if( !(space < m_cItems) &&
            m_bExternal)
        {
# ifdef STLSOFT_UNITTEST
            printf("auto_buffer is in internal domain, but think's it isn't\n");
# endif /* STLSOFT_UNITTEST */

            bRet = false;
        }
#else /* ? STLSOFT_AUTO_BUFFER_AGGRESSIVE_SHRINK */

        if( space < m_cItems &&
            !m_bExternal)
        {
# ifdef STLSOFT_UNITTEST
            printf("auto_buffer is in external domain, but think's it isn't\n");
# endif /* STLSOFT_UNITTEST */

            bRet = false;
        }
#endif /* STLSOFT_AUTO_BUFFER_AGGRESSIVE_SHRINK */

        if(m_bExternal)
        {
            if(m_buffer == &m_internal[0])
            {
# ifdef STLSOFT_UNITTEST
                printf("auto_buffer is in external domain, but buffer refers to internal array\n");
# endif /* STLSOFT_UNITTEST */

                bRet = false;
            }
        }
        else
        {
            if(m_buffer != &m_internal[0])
            {
# ifdef STLSOFT_UNITTEST
                printf("auto_buffer is in internal domain, but buffer does not refer to internal array\n");
# endif /* STLSOFT_UNITTEST */

                bRet = false;
            }
        }

        return bRet;
    }
/// @}

/// \name Members
/// @{
private:
    pointer     m_buffer;           // Pointer to used buffer
    size_type   m_cItems;           // Number of items in buffer
    ss_bool_t   m_bExternal;        // This is required, since not allowed to compare m_buffer with &m_internal[0] - can't remember why; // NOTE: Check std
    value_type  m_internal[space];  // Internal storage
/// @}

// Not to be implemented
private:
    auto_buffer(class_type const& rhs);
    auto_buffer const& operator =(class_type const& rhs);
};


#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template<   ss_typename_param_k T
#ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
        ,   ss_typename_param_k A = ss_typename_type_def_k allocator_selector<T>::allocator_type
#else /* ? STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT */
        ,   ss_typename_param_k A
#endif /* STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT */
#ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_FUNDAMENTAL_ARGUMENT_SUPPORT
#  if !defined(STLSOFT_COMPILER_IS_BORLAND) && \
      !defined(STLSOFT_COMPILER_IS_DMC)
        ,   ss_size_t           SPACE   =   auto_buffer_internal_size_calculator<T>::value
# else /* ? compiler */
        ,   ss_size_t           SPACE   =   256
# endif /* compiler */
#else /* ? STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_FUNDAMENTAL_ARGUMENT_SUPPORT */
        ,   ss_size_t           SPACE /* = auto_buffer_internal_size_calculator<T>::value */
#endif /* STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_FUNDAMENTAL_ARGUMENT_SUPPORT */
        >
class auto_buffer_old
#if defined(STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS)
    : public auto_buffer<T, A, SPACE>
#else /* ? STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
    : public auto_buffer<T, SPACE, A>
#endif /* STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
{
/// \name Member Types
/// @{
private:
#if defined(STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS)
    typedef auto_buffer<T, A, SPACE>                                        parent_class_type;
#else /* ? STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
    typedef auto_buffer<T, SPACE, A>                                        parent_class_type;
#endif /* STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
    typedef auto_buffer_old<T, A, SPACE>                                    class_type;

public:
    typedef ss_typename_type_k parent_class_type::value_type                value_type;
    typedef ss_typename_type_k parent_class_type::allocator_type            allocator_type;
    typedef ss_typename_type_k parent_class_type::reference                 reference;
    typedef ss_typename_type_k parent_class_type::const_reference           const_reference;
    typedef ss_typename_type_k parent_class_type::pointer                   pointer;
    typedef ss_typename_type_k parent_class_type::const_pointer             const_pointer;
    typedef ss_typename_type_k parent_class_type::size_type                 size_type;
    typedef ss_typename_type_k parent_class_type::difference_type           difference_type;
    typedef ss_typename_type_k parent_class_type::iterator                  iterator;
    typedef ss_typename_type_k parent_class_type::const_iterator            const_iterator;
#if defined(STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT)
    typedef ss_typename_type_k parent_class_type::reverse_iterator          reverse_iterator;
    typedef ss_typename_type_k parent_class_type::const_reverse_iterator    const_reverse_iterator;
#endif /* STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT */
/// @}

/// \name Construction
/// @{
public:
    ss_explicit_k auto_buffer_old(size_type cItems)
        : parent_class_type(cItems)
    {}
/// @}

// Not to be implemented
private:
    auto_buffer_old(class_type const& rhs);
    class_type& operator =(class_type const& rhs);
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////
 * swapping
 */

#if !defined(STLSOFT_COMPILER_IS_WATCOM)
template<   ss_typename_param_k T
# ifdef STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS
        ,   ss_typename_param_k A
        ,   ss_size_t           SPACE
# else /* ? STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
        ,   ss_size_t           SPACE
        ,   ss_typename_param_k A
# endif /* STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
        >
# ifdef STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS
inline void swap(auto_buffer<T, A, SPACE>& lhs, auto_buffer<T, A, SPACE>& rhs)
# else /* ? STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
inline void swap(auto_buffer<T, SPACE, A>& lhs, auto_buffer<T, SPACE, A>& rhs)
# endif /* STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
{
    lhs.swap(rhs);
}
#endif /* compiler */

/* /////////////////////////////////////////////////////////////////////////
 * Shims
 */

#ifndef STLSOFT_CF_TEMPLATE_SHIMS_NOT_SUPPORTED

template<   ss_typename_param_k T
# ifdef STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS
        ,   ss_typename_param_k A
        ,   ss_size_t           SPACE
# else /* ? STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
        ,   ss_size_t           SPACE
        ,   ss_typename_param_k A
# endif /* STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
        >
# ifdef STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS
inline ss_bool_t is_empty(auto_buffer<T, A, SPACE> const& b)
# else /* ? STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
inline ss_bool_t is_empty(auto_buffer<T, SPACE, A> const& b)
# endif /* STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
{
    return b.empty();
}

#endif /* !STLSOFT_CF_TEMPLATE_SHIMS_NOT_SUPPORTED */

////////////////////////////////////////////////////////////////////////////
// Unit-testing

#ifdef STLSOFT_UNITTEST
# include "./unittest/auto_buffer_unittest_.h"
#endif /* STLSOFT_UNITTEST */

/* ////////////////////////////////////////////////////////////////////// */

#ifndef _STLSOFT_NO_NAMESPACE
} // namespace stlsoft
#endif /* _STLSOFT_NO_NAMESPACE */

/* In the special case of Intel behaving as VC++ 7.0 or earlier on Win32, we
 * illegally insert into the std namespace.
 */
#if defined(STLSOFT_CF_std_NAMESPACE)
# if ( ( defined(STLSOFT_COMPILER_IS_INTEL) && \
         defined(_MSC_VER))) && \
     _MSC_VER < 1310
namespace std
{
    template<   ss_typename_param_k         T
#  ifdef STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS
            ,   ss_typename_param_k         A
            ,   stlsoft_ns_qual(ss_size_t)  SPACE
#  else /* ? STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
            ,   stlsoft_ns_qual(ss_size_t)  SPACE
            ,   ss_typename_param_k         A
#  endif /* STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
            >
#  ifdef STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS
    inline void swap(stlsoft_ns_qual(auto_buffer)<T, A, SPACE>& lhs, stlsoft_ns_qual(auto_buffer)<T, A, SPACE>& rhs)
#  else /* ? STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
    inline void swap(stlsoft_ns_qual(auto_buffer)<T, SPACE, A>& lhs, stlsoft_ns_qual(auto_buffer)<T, SPACE, A>& rhs)
#  endif /* STLSOFT_AUTO_BUFFER_USE_PRE_1_9_CHARACTERISTICS */
    {
        lhs.swap(rhs);
    }
} // namespace std
# endif /* INTEL && _MSC_VER < 1310 */
#endif /* STLSOFT_CF_std_NAMESPACE */

/* ////////////////////////////////////////////////////////////////////// */

#endif /* !STLSOFT_INCL_STLSOFT_MEMORY_HPP_AUTO_BUFFER */

/* ////////////////////////////////////////////////////////////////////// */