string_view.hpp

用STL的方式封装了WindowsAPI、COM调用、ACE、ATL、MFC、WTL等多种组件

    STLSOFT_ASSERT(is_valid());

    return (index == size()) ? *empty_string_() : m_base[index];
}

#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::const_reference basic_string_view<C, T, A>::at(ss_typename_type_k basic_string_view<C, T, A>::size_type index) const
{
    STLSOFT_ASSERT(is_valid());

    if(!(index < size()))
    {
        stlsoft_ns_qual_std(out_of_range)   x("index out of range");

# ifdef STLSOFT_COMPILER_IS_MSVC
        if(1) // This is needed to avoid Visual C++ warning 4702: 'unreachable code'
# endif /* compiler */
        {
            throw_x(x);
        }
    }

    STLSOFT_ASSERT(is_valid());

    return m_base[index];
}
#endif /* !STLSOFT_CF_EXCEPTION_SUPPORT */

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::value_type const *basic_string_view<C, T, A>::c_str() const
{
    STLSOFT_ASSERT(is_valid());

    if(NULL != m_cstr)
    {
        // Already allocated, so return; if underlying
        return m_cstr;
    }
    else
    {
        if(0 == m_length)
        {
            return empty_string_();
        }
        else
        {
            // Must allocate the m_cstr member
            allocator_type  &ator   =   const_cast<class_type&>(*this);
            char_type       *s      =   ator.allocate(1 + length(), NULL);

            STLSOFT_SUPPRESS_UNUSED(ator);  // Need this for silly old Borland

            // Because the class might be parameterised with a no-throw allocator,
            // we'll check the result. This is really hokey, of course, since we're
            // returning a NULL string in the circumstances where memory has
            // failed to allocate. In such cases we can only hope that the memory
            // exhaustion is non-local and that the callee is going to suffer and die
            // anyway, irrespective of the fact that we've returned an invalid value
            // to it.
            if(NULL != s)
            {
                traits_type::copy(s, m_base, m_length);
                s[m_length] = '\0';

                remove_const(m_cstr) = s;

                STLSOFT_ASSERT(is_valid());
            }

            return m_cstr;
        }
    }
}

#if 0
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::value_type const *basic_string_view<C, T, A>::c_str(ss_bool_t bRefresh) const
{
    if(bRefresh)
    {
        const_cast<class_type*>(this)->refresh();
    }

    return c_str();
}
#endif /* 0 */

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::value_type const *basic_string_view<C, T, A>::data() const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    return (0 == m_length) ? empty_string_() : m_base;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::value_type const *basic_string_view<C, T, A>::base() const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    return m_base;
}

#if 0
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::reference basic_string_view<C, T, A>::front()
{
    STLSOFT_ASSERT(is_valid());

    return (*this)[0];
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::reference basic_string_view<C, T, A>::back()
{
    STLSOFT_ASSERT(is_valid());

    return (*this)[length() - 1];
}
#endif /* 0 */

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::const_reference basic_string_view<C, T, A>::front() const
{
    STLSOFT_ASSERT(is_valid());

    return (*this)[0];
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::const_reference basic_string_view<C, T, A>::back() const
{
    STLSOFT_ASSERT(is_valid());

    return (*this)[length() - 1];
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::size_type basic_string_view<C, T, A>::copy(   ss_typename_type_k basic_string_view<C, T, A>::value_type     *dest
                                                                                                ,   ss_typename_type_k basic_string_view<C, T, A>::size_type      cch
                                                                                                ,   ss_typename_type_k basic_string_view<C, T, A>::size_type      pos /* = 0 */) const
{
    STLSOFT_ASSERT(is_valid());

    size_type   len =   length();

    if(pos < len)
    {
        if(len < pos + cch)
        {
            cch = len - pos;
        }

        traits_type::copy(dest, data() + pos, cch);
    }
    else
    {
        cch = 0;
    }

    STLSOFT_ASSERT(is_valid());

    return cch;
}


// Iteration

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::const_iterator basic_string_view<C, T, A>::begin() const
{
    STLSOFT_ASSERT(is_valid());

    return m_base;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::const_iterator basic_string_view<C, T, A>::end() const
{
    STLSOFT_ASSERT(is_valid());

    return begin() + m_length;
}

#if 0
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::iterator basic_string_view<C, T, A>::begin()
{
    STLSOFT_ASSERT(is_valid());

    return m_base;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::iterator basic_string_view<C, T, A>::end()
{
    STLSOFT_ASSERT(is_valid());

    return begin() + m_length;
}
#endif /* 0 */

#if defined(STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT)
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::const_reverse_iterator basic_string_view<C, T, A>::rbegin() const
{
    STLSOFT_ASSERT(is_valid());

    return const_reverse_iterator(end());
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::const_reverse_iterator basic_string_view<C, T, A>::rend() const
{
    STLSOFT_ASSERT(is_valid());

    return const_reverse_iterator(begin());
}

#if 0
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::reverse_iterator basic_string_view<C, T, A>::rbegin()
{
    STLSOFT_ASSERT(is_valid());

    return reverse_iterator(end());
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_type_k basic_string_view<C, T, A>::reverse_iterator basic_string_view<C, T, A>::rend()
{
    STLSOFT_ASSERT(is_valid());

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

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

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline void swap(basic_string_view<C, T, A> &lhs, basic_string_view<C, T, A> &rhs)
{
    lhs.swap(rhs);
}

/* /////////////////////////////////////////////////////////////////////////
 * String access shims
 */

/* c_str_ptr_null */

/// \brief Returns the corresponding C-string pointer of \c s, or a null pointer
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline C const *c_str_ptr_null(basic_string_view<C, T, A> const &s)
{
    return (s.length() == 0) ? 0 : s.c_str();
}

/* c_str_ptr */

/// \brief Returns the corresponding C-string pointer of \c s
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline C const *c_str_ptr(basic_string_view<C, T, A> const &s)
{
    return s.c_str();
}

/* c_str_data */

/// \brief Returns the corresponding C-string pointer of \c s
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline C const *c_str_data(basic_string_view<C, T, A> const &s)
{
    return s.data();
}

/// \brief Returns the corresponding C-string pointer of \c s
template<   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_char_a_t const *c_str_ptr_a(basic_string_view<ss_char_a_t, T, A> const &s)
{
    return s.c_str();
}

/// \brief Returns the corresponding C-string pointer of \c s
template<   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_char_w_t const *c_str_ptr_w(basic_string_view<ss_char_w_t, T, A> const &s)
{
    return s.c_str();
}

/* c_str_ptr_len */

/// \brief Returns the length (in characters) of \c s, <b><i>not</i></b> including the null-terminating character
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_size_t c_str_len(basic_string_view<C, T, A> const &s)
{
    return s.length();
}

/* c_str_ptr_size */

#if 0
/// \brief Returns the size (in bytes) of the contents of \c s, <b><i>not</i></b> including the null-terminating character
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_size_t c_str_size(basic_string_view<C, T, A> const &s)
{
    return c_str_len(s) * sizeof(C);
}
#endif /* 0 */

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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

#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 C
            ,   ss_typename_param_k T
            ,   ss_typename_param_k A
            >
    inline void swap(stlsoft_ns_qual(basic_string_view)<C, T, A> &lhs, stlsoft_ns_qual(basic_string_view)<C, T, A> &rhs)
    {
        lhs.swap(rhs);
    }
} // namespace std
# endif /* INTEL && _MSC_VER < 1310 */
#endif /* STLSOFT_CF_std_NAMESPACE */

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

#endif /* !STLSOFT_INCL_STLSOFT_STRING_HPP_STRING_VIEW */

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