string_view.hpp

新版本TR1的stl

    STLSOFT_ASSERT(is_valid());

    close_set_null_();

    STLSOFT_ASSERT(is_valid());
}

// Attributes

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>::size() const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    return m_length;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline /* static */ ss_typename_type_k basic_string_view<C, T, A>::size_type basic_string_view<C, T, A>::max_size() stlsoft_throw_0()
{
    return static_cast<size_type>(-1) / sizeof(char_type);
}

//  size_type max_size() const;

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>::length() const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    return m_length;
}

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>::capacity() const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    return m_length;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_bool_t basic_string_view<C, T, A>::empty() const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    return 0 == size();
}

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>::allocator_type basic_string_view<C, T, A>::get_allocator() const
{
    return *this;
}

// Comparison

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_bool_t basic_string_view<C, T, A>::equal(ss_typename_type_k basic_string_view<C, T, A>::class_type const& rhs) const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    return (m_length == rhs.m_length) && ((m_base == rhs.m_base) || 0 == compare(rhs));
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_bool_t basic_string_view<C, T, A>::equal(ss_typename_type_k basic_string_view<C, T, A>::value_type const* rhs, ss_typename_type_k basic_string_view<C, T, A>::size_type cchRhs) const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    return (m_length == cchRhs) && ((m_base == rhs) || 0 == compare_(m_base, m_length, rhs, cchRhs));
}


template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_sint_t basic_string_view<C, T, A>::compare(   ss_typename_type_k basic_string_view<C, T, A>::size_type          pos
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::size_type          cch
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::value_type const   *rhs
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::size_type          cchRhs) const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    size_type   lhs_len =   length();

    if(!(pos < lhs_len))
    {
        pos = lhs_len;
    }
    else
    {
        lhs_len -= pos;
    }

    if(cch < lhs_len)
    {
        lhs_len = cch;
    }

    size_type   rhs_len =   (NULL == rhs) ? 0 : traits_type::length(rhs);

    if(cchRhs < rhs_len)
    {
        rhs_len = cchRhs;
    }

    STLSOFT_ASSERT(is_valid());

    return compare_(m_base + pos, lhs_len, rhs, rhs_len);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_sint_t basic_string_view<C, T, A>::compare(   ss_typename_type_k basic_string_view<C, T, A>::size_type          pos
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::size_type          cch
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::value_type const*  rhs) const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    size_type   lhs_len =   length();

    if(!(pos < lhs_len))
    {
        pos = lhs_len;
    }
    else
    {
        lhs_len -= pos;
    }

    if(cch < lhs_len)
    {
        lhs_len = cch;
    }

    size_type   rhs_len =   (NULL == rhs) ? 0 : traits_type::length(rhs);

    STLSOFT_ASSERT(is_valid());

    return compare_(m_base + pos, lhs_len, rhs, rhs_len);
}

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

    size_type   lhs_len =   length();
    size_type   rhs_len =   (NULL == rhs) ? 0 : traits_type::length(rhs);

    return compare_(m_base, lhs_len, rhs, rhs_len);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_sint_t basic_string_view<C, T, A>::compare(   ss_typename_type_k basic_string_view<C, T, A>::size_type          pos
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::size_type          cch
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::class_type const&  rhs
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::size_type          posRhs
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::size_type          cchRhs) const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    size_type   lhs_len =   length();

    if(!(pos < lhs_len))
    {
        pos = lhs_len;
    }
    else
    {
        lhs_len -= pos;
    }

    if(cch < lhs_len)
    {
        lhs_len = cch;
    }

    size_type   rhs_len =   rhs.length();

    if(!(posRhs < rhs_len))
    {
        posRhs = rhs_len;
    }
    else
    {
        rhs_len -= posRhs;
    }

    if(cchRhs < rhs_len)
    {
        rhs_len = cchRhs;
    }

    STLSOFT_ASSERT(is_valid());

    return compare_(m_base + pos, lhs_len, rhs.m_base + posRhs, rhs_len);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_sint_t basic_string_view<C, T, A>::compare(   ss_typename_type_k basic_string_view<C, T, A>::size_type          pos
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::size_type          cch
                                                    ,   ss_typename_type_k basic_string_view<C, T, A>::class_type const&  rhs) const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    size_type   lhs_len =   length();

    if(!(pos < lhs_len))
    {
        pos = lhs_len;
    }
    else
    {
        lhs_len -= pos;
    }

    if(cch < lhs_len)
    {
        lhs_len = cch;
    }

    size_type   rhs_len =   rhs.length();

    STLSOFT_ASSERT(is_valid());

    return compare_(m_base + pos, lhs_len, rhs.m_base, rhs_len);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_sint_t basic_string_view<C, T, A>::compare(ss_typename_type_k basic_string_view<C, T, A>::class_type const& rhs) const stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());

    size_type   lhs_len =   length();
    size_type   rhs_len =   rhs.length();

    STLSOFT_ASSERT(is_valid());

    return compare_(m_base, lhs_len, rhs.m_base, rhs_len);
}

// Accessors

#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>::operator [](ss_typename_type_k basic_string_view<C, T, A>::size_type index)
{
    STLSOFT_ASSERT(is_valid());

    return m_base[index];
}
#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>::operator [](ss_typename_type_k basic_string_view<C, T, A>::size_type index) const
{
    STLSOFT_MESSAGE_ASSERT("string_view index out of bounds", index <= size());

    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_THROW_X(stlsoft_ns_qual_std(out_of_range)("index out of range"));
    }

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