string_view.hpp

新版本TR1的stl

}

#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 */

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////
 * 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_data

/** \brief \ref group__concept__shim__string_access__c_str_data for stlsoft::basic_string_view
 *
 * \ingroup group__concept__shim__string_access
 */
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline C const* c_str_data(stlsoft_ns_qual(basic_string_view)<C, T, A> const& s)
{
    return s.data();
}

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T, ss_typename_param_k A>
inline ss_char_a_t const* c_str_data_a(stlsoft_ns_qual(basic_string_view)<ss_char_a_t, T, A> const& s)
{
    return s.data();
}
template <ss_typename_param_k T, ss_typename_param_k A>
inline ss_char_w_t const* c_str_data_w(stlsoft_ns_qual(basic_string_view)<ss_char_w_t, T, A> const& s)
{
    return s.data();
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

// c_str_len

/** \brief \ref group__concept__shim__string_access__c_str_len for stlsoft::basic_string_view
 *
 * \ingroup group__concept__shim__string_access
 */
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_size_t c_str_len(stlsoft_ns_qual(basic_string_view)<C, T, A> const& s)
{
    return s.length();
}

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T, ss_typename_param_k A>
inline ss_size_t c_str_len_a(stlsoft_ns_qual(basic_string_view)<ss_char_a_t, T, A> const& s)
{
    return s.length();
}
template <ss_typename_param_k T, ss_typename_param_k A>
inline ss_size_t c_str_len_w(stlsoft_ns_qual(basic_string_view)<ss_char_w_t, T, A> const& s)
{
    return s.length();
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

// c_str_ptr

/** \brief \ref group__concept__shim__string_access__c_str_ptr for stlsoft::basic_string_view
 *
 * \ingroup group__concept__shim__string_access
 */
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline C const* c_str_ptr(stlsoft_ns_qual(basic_string_view)<C, T, A> const& s)
{
    return s.c_str();
}

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T, ss_typename_param_k A>
inline ss_char_a_t const* c_str_ptr_a(stlsoft_ns_qual(basic_string_view)<ss_char_a_t, T, A> const& s)
{
    return s.c_str();
}
template <ss_typename_param_k T, ss_typename_param_k A>
inline ss_char_w_t const* c_str_ptr_w(stlsoft_ns_qual(basic_string_view)<ss_char_w_t, T, A> const& s)
{
    return s.c_str();
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

// c_str_ptr_null

/** \brief \ref group__concept__shim__string_access__c_str_ptr_null for stlsoft::basic_string_view
 *
 * \ingroup group__concept__shim__string_access
 */
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline C const* c_str_ptr_null(stlsoft_ns_qual(basic_string_view)<C, T, A> const& s)
{
    return (0 != s.length()) ? s.c_str() : NULL;
}

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T, ss_typename_param_k A>
inline ss_char_a_t const* c_str_ptr_null_a(stlsoft_ns_qual(basic_string_view)<ss_char_a_t, T, A> const& s)
{
    return (0 != s.length()) ? s.c_str() : NULL;
}
template <ss_typename_param_k T, ss_typename_param_k A>
inline ss_char_w_t const* c_str_ptr_null_w(stlsoft_ns_qual(basic_string_view)<ss_char_w_t, T, A> const& s)
{
    return (0 != s.length()) ? s.c_str() : NULL;
}

#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);
    }
}