carray_adaptors.hpp

新版本TR1的stl

    /// Constructs an instance with the given number of elements
    ///
    /// \param n The number of elements
    /// \param value The value of each element
    CArray_cadaptor(size_type n, value_type const& value)
    {
        parent_class_type::assign(n, value);
    }
    /// Copy constructor
    CArray_cadaptor(class_type const& rhs)
    {
        parent_class_type::assign(rhs.begin(), rhs.end());
    }
    /// Copy constructs an instance from the given underlying array
    CArray_cadaptor(array_type const& rhs)
    {
        parent_class_type::assign(rhs.GetData(), rhs.GetData() + rhs.GetSize());
    }
    /// Constructs an instance from the given range
    template <ss_typename_param_k I2>
    CArray_cadaptor(I2 first, I2 last)
    {
        // Precondition checks
        MFCSTL_ASSERT(parent_class_type::is_valid_source_range_(first, last));

        parent_class_type::assign(first, last);
    }
    ~CArray_cadaptor() stlsoft_throw_0()
    {
        STLSOFT_STATIC_ASSERT(sizeof(A) == sizeof(ss_typename_type_k T::array_type));
    }
/// @}

/// \name Assignment
/// @{
public:
    class_type& operator =(class_type const& rhs)
    {
#ifdef MFCSTL_CARRAY_SWAP_MEMBERS_SUPPORT
        class_type t(rhs);
        t.swap(*this);
#else /* ? MFCSTL_CARRAY_SWAP_MEMBERS_SUPPORT */
        parent_class_type::assign(rhs.begin(), rhs.end());
#endif /* MFCSTL_CARRAY_SWAP_MEMBERS_SUPPORT */

        return *this;
    }
/// @}

/// \name Element Access
/// @{
public:
#if defined(STLSOFT_COMPILER_IS_DMC)
    reference operator [](size_type index)
    {
        return parent_class_type::operator [](index);
    }
    const_reference operator [](size_type index) const
    {
        return parent_class_type::operator [](index);
    }
#else /* ? compiler */
    using parent_class_type::operator [];
#endif /* compiler */
/// @}
};


#ifdef STLSOFT_DOCUMENTATION_SKIP_SECTION
/** \brief Adaptor class, representing an Instance Adaptor over the CArray
 *    family of MFC containers
 *
 * \ingroup group__library__collections
 *
 * It is used as follows:
 *
\code
  CStringArray                          ar;
  mfcstl::CArray_iadaptor<CStringArray> arp(ar);

  // As an MFC CStringArray:
  ar.Add("String 1");
  ar.InsertAt(0, "String 0");

  // As an STL container
  arp.push_back("String 2");
  std::list<CString>  l;
  l.push_back("String 3");
  l.push_back("String 4");
  arp.insert(arp.begin() + 2, l.begin(), l.end());
  std::sort(arp.begin(), arp.end());
\endcode
 *
 * \param A The array class, e.g. CObArray, CArray<long>, etc.
 *
 * \note The elements in an adapted array are moved, during insertion / erasure, rather than copied. This
 *   means that if the elements in the container maintain pointers to their elements, or their peers, then
 *   they are not suitable for use.
 */
#endif /* STLSOFT_DOCUMENTATION_SKIP_SECTION */
template<   ss_typename_param_k A
        ,   ss_typename_param_k T = CArray_traits<A>
        >
class CArray_iadaptor
        : public CArray_adaptor_base<A, CArray_iadaptor<A, T>, T>
{
/// \name Member Types
/// @{
private:
    typedef CArray_adaptor_base<A, CArray_iadaptor<A, T>, T>        parent_class_type;
public:
    /// The type of the underlying MFC array
    typedef ss_typename_type_k parent_class_type::array_type        array_type;
    /// The value type
    typedef ss_typename_type_k parent_class_type::value_type        value_type;
    /// The allocator type
    typedef ss_typename_type_k parent_class_type::allocator_type    allocator_type;
    /// The mutating (non-const) reference type
    typedef ss_typename_type_k parent_class_type::reference         reference;
    /// The non-mutating (const) reference type
    typedef ss_typename_type_k parent_class_type::const_reference   const_reference;
    /// The mutating (non-const) pointer type
    typedef ss_typename_type_k parent_class_type::pointer           pointer;
    /// The non-mutating (const) pointer type
    typedef ss_typename_type_k parent_class_type::const_pointer     const_pointer;
    /// The mutating (non-const) iterator type
    typedef ss_typename_type_k parent_class_type::iterator          iterator;
    /// The non-mutating (const) iterator type
    typedef ss_typename_type_k parent_class_type::const_iterator    const_iterator;
    /// The size type
    typedef ss_typename_type_k parent_class_type::size_type         size_type;
    /// The difference type
    typedef ss_typename_type_k parent_class_type::difference_type   difference_type;
    /// The instantiation of the current type
    typedef CArray_iadaptor<A, T>                                   class_type;
/// @}

/// \name Identity
/// @{
private:
    friend class CArray_adaptor_base<A, CArray_iadaptor<A, T>, T>;

    array_type          &get_actual_array()
    {
        MFCSTL_ASSERT(NULL != m_pArray);
        return *m_pArray;
    }
    array_type const    &get_actual_array() const
    {
        MFCSTL_ASSERT(NULL != m_pArray);
        return *m_pArray;
    }
/// @}

/// \name Construction
/// @{
public:
    template <ss_typename_param_k A2>
    CArray_iadaptor(A2 &array)
         : m_pArray(&array)
    {
        STLSOFT_STATIC_ASSERT(sizeof(array_type) == sizeof(A2));
#ifdef STLSOFT_META_HAS_IS_SAME_TYPE
        STLSOFT_STATIC_ASSERT((stlsoft::is_same_type<array_type, A2>::value));
#else /* ? STLSOFT_META_HAS_IS_SAME_TYPE */
        ASSERT(0 == ::strcmp(array.GetRuntimeClass()->m_lpszClassName, array_type().GetRuntimeClass()->m_lpszClassName));
# ifdef _CPPRTTI
        ASSERT(0 == ::strcmp(typeid(A2).name(), typeid(array_type).name()));
# endif /* _CPPRTTI */
#endif /* STLSOFT_META_HAS_IS_SAME_TYPE */
    }
    template <ss_typename_param_k A2>
    CArray_iadaptor(A2 *pArray)
         : m_pArray(pArray)
    {
        MFCSTL_MESSAGE_ASSERT("Cannot initialise a CArray_iadaptor with a NULL pointer", NULL != pArray);

        STLSOFT_STATIC_ASSERT(sizeof(array_type) == sizeof(A2));
#ifdef STLSOFT_META_HAS_IS_SAME_TYPE
        STLSOFT_STATIC_ASSERT((stlsoft::is_same_type<array_type, A2>::value));
#else /* ? STLSOFT_META_HAS_IS_SAME_TYPE */
        ASSERT(0 == ::strcmp(pArray->GetRuntimeClass()->m_lpszClassName, array_type().GetRuntimeClass()->m_lpszClassName));
# ifdef _CPPRTTI
        ASSERT(0 == ::strcmp(typeid(A2).name(), typeid(array_type).name()));
# endif /* _CPPRTTI */
#endif /* STLSOFT_META_HAS_IS_SAME_TYPE */
    }
/// @}

/// \name Members
/// @{
private:
    array_type  *m_pArray;
/// @}

/// \name Not to be implemented
/// @{
private:
    CArray_iadaptor(class_type const& rhs);            // Only possible semantics for copy-ctor are share underlying array
    class_type& operator =(class_type const& rhs);  // Could either repoint, or could do deep copy.
/// @}
};

/* /////////////////////////////////////////////////////////////////////////
 * Comparison
 */

template<   ss_typename_param_k A1
        ,   ss_typename_param_k A2
        ,   ss_typename_param_k I1
        ,   ss_typename_param_k I2
        ,   ss_typename_param_k T1
        ,   ss_typename_param_k T2
        >
inline ms_bool_t operator ==(CArray_adaptor_base<A1, I1, T1> const& lhs, CArray_adaptor_base<A2, I2, T2> const& rhs)
{
    return lhs.equal(rhs);
}

template<   ss_typename_param_k A1
        ,   ss_typename_param_k A2
        ,   ss_typename_param_k I1
        ,   ss_typename_param_k I2
        ,   ss_typename_param_k T1
        ,   ss_typename_param_k T2
        >
inline ms_bool_t operator !=(CArray_adaptor_base<A1, I1, T1> const& lhs, CArray_adaptor_base<A2, I2, T2> const& rhs)
{
    return !lhs.equal(rhs);
}

template<   ss_typename_param_k A1
        ,   ss_typename_param_k A2
        ,   ss_typename_param_k I1
        ,   ss_typename_param_k I2
        ,   ss_typename_param_k T1
        ,   ss_typename_param_k T2
        >
inline ms_bool_t operator <(CArray_adaptor_base<A1, I1, T1> const& lhs, CArray_adaptor_base<A2, I2, T2> const& rhs)
{
    return lhs.less_than(rhs);
}

template<   ss_typename_param_k A1
        ,   ss_typename_param_k A2
        ,   ss_typename_param_k I1
        ,   ss_typename_param_k I2
        ,   ss_typename_param_k T1
        ,   ss_typename_param_k T2
        >
inline ms_bool_t operator <=(CArray_adaptor_base<A1, I1, T1> const& lhs, CArray_adaptor_base<A2, I2, T2> const& rhs)
{
    return !lhs.greater_than(rhs);
}

template<   ss_typename_param_k A1
        ,   ss_typename_param_k A2
        ,   ss_typename_param_k I1
        ,   ss_typename_param_k I2
        ,   ss_typename_param_k T1
        ,   ss_typename_param_k T2
        >
inline ms_bool_t operator >(CArray_adaptor_base<A1, I1, T1> const& lhs, CArray_adaptor_base<A2, I2, T2> const& rhs)
{
    return lhs.greater_than(rhs);
}

template<   ss_typename_param_k A1
        ,   ss_typename_param_k A2
        ,   ss_typename_param_k I1
        ,   ss_typename_param_k I2
        ,   ss_typename_param_k T1
        ,   ss_typename_param_k T2
        >
inline ms_bool_t operator >=(CArray_adaptor_base<A1, I1, T1> const& lhs, CArray_adaptor_base<A2, I2, T2> const& rhs)
{
    return !lhs.less_than(rhs);
}



template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator ==(CArray_adaptor_base<A, I, T> const& lhs, A const& rhs)
{
    return lhs.equal(rhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator !=(CArray_adaptor_base<A, I, T> const& lhs, A const& rhs)
{
    return !lhs.equal(rhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator <(CArray_adaptor_base<A, I, T> const& lhs, A const& rhs)
{
    return lhs.less_than(rhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator <=(CArray_adaptor_base<A, I, T> const& lhs, A const& rhs)
{
    return !lhs.greater_than(rhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator >(CArray_adaptor_base<A, I, T> const& lhs, A const& rhs)
{
    return lhs.greater_than(rhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator >=(CArray_adaptor_base<A, I, T> const& lhs, A const& rhs)
{
    return !lhs.less_than(rhs);
}




template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator ==(A const& lhs, CArray_adaptor_base<A, I, T> const& rhs)
{
    return rhs.equal(lhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator !=(A const& lhs, CArray_adaptor_base<A, I, T> const& rhs)
{
    return !rhs.equal(lhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator <(A const& lhs, CArray_adaptor_base<A, I, T> const& rhs)
{
    return !(rhs.greater_than(lhs) || rhs == lhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator <=(A const& lhs, CArray_adaptor_base<A, I, T> const& rhs)
{
    return !rhs.less_than(lhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator >(A const& lhs, CArray_adaptor_base<A, I, T> const& rhs)
{
    return !(rhs.less_than(lhs) || rhs == lhs);
}

template<   ss_typename_param_k A
        ,   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
inline ms_bool_t operator >=(A const& lhs, CArray_adaptor_base<A, I, T> const& rhs)
{
    return !rhs.greater_than(lhs);
}

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

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

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

#ifndef _MFCSTL_NO_NAMESPACE
# if defined(_STLSOFT_NO_NAMESPACE) || \
     defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
} // namespace mfcstl
# else
} // namespace mfcstl_project
} // namespace stlsoft
# endif /* _STLSOFT_NO_NAMESPACE */
#endif /* !_MFCSTL_NO_NAMESPACE */

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

#endif /* !MFCSTL_INCL_MFCSTL_COLLECTIONS_HPP_CARRAY_ADAPTORS */

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