static_string.hpp

新版本TR1的stl

        >
inline ss_bool_t operator >=(basic_static_string<C, CCH, T> const& lhs, basic_static_string<C, CCH, T> const& rhs)
{
    return lhs.compare(rhs) >= 0;
}
template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
#ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
inline ss_bool_t operator >=(basic_static_string<C, CCH, T> const& lhs, ss_typename_type_k basic_static_string<C, CCH, T>::char_type const* rhs)
#else /* ? STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */
inline ss_bool_t operator >=(basic_static_string<C, CCH, T> const& lhs, C const* rhs)
#endif /* STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */
{
    return lhs.compare(rhs) >= 0;
}
template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
#ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
inline ss_bool_t operator >=(ss_typename_type_k basic_static_string<C, CCH, T>::char_type const* lhs, basic_static_string<C, CCH, T> const& rhs)
#else /* ? STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */
inline ss_bool_t operator >=(C const* lhs, basic_static_string<C, CCH, T> const& rhs)
#endif /* STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */
{
    return rhs.compare(lhs) <= 0;
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline void swap(basic_static_string<C, CCH, T>& lhs, basic_static_string<C, CCH, T>& rhs)
{
    lhs.swap(rhs);
}

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

#ifndef STLSOFT_CF_TEMPLATE_SHIMS_NOT_SUPPORTED

// c_str_ptr_null

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
template <ss_size_t CCH, ss_typename_param_k T >
inline ss_char_a_t const* c_str_ptr_null_a(stlsoft_ns_qual(basic_static_string)<ss_char_a_t, CCH, T> const& s)
{
    return (0 != s.length()) ? s.c_str() : NULL;
}
template <ss_size_t CCH, ss_typename_param_k T >
inline ss_char_w_t const* c_str_ptr_null_w(stlsoft_ns_qual(basic_static_string)<ss_char_w_t, CCH, T> const& s)
{
    return (0 != s.length()) ? s.c_str() : NULL;
}
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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

// c_str_ptr

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
template <ss_size_t CCH, ss_typename_param_k T >
inline ss_char_a_t const* c_str_ptr_a(stlsoft_ns_qual(basic_static_string)<ss_char_a_t, CCH, T> const& s)
{
    return s.c_str();
}
template <ss_size_t CCH, ss_typename_param_k T >
inline ss_char_w_t const* c_str_ptr_w(stlsoft_ns_qual(basic_static_string)<ss_char_w_t, CCH, T> const& s)
{
    return s.c_str();
}
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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

// c_str_data

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
template <ss_size_t CCH, ss_typename_param_k T >
inline ss_char_a_t const* c_str_data_a(stlsoft_ns_qual(basic_static_string)<ss_char_a_t, CCH, T> const& s)
{
    return s.data();
}
template <ss_size_t CCH, ss_typename_param_k T >
inline ss_char_w_t const* c_str_data_w(stlsoft_ns_qual(basic_static_string)<ss_char_w_t, CCH, T> const& s)
{
    return s.data();
}
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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

// c_str_len

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

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

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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

#endif /* !STLSOFT_CF_TEMPLATE_SHIMS_NOT_SUPPORTED */



/** \brief \ref group__concept__shim__stream_insertion "stream insertion shim" for stlsoft::basic_static_string
 *
 * \ingroup group__concept__shim__stream_insertion
 */
template<   ss_typename_param_k     S
        ,   ss_typename_param_k     C
        ,   ss_size_t               CCH
        ,   ss_typename_param_k     T
        >
inline S& operator <<(S& s, stlsoft_ns_qual(basic_static_string)<C, CCH, T> const& str)
{
    s << str.c_str();

    return s;
}

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

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

/* /////////////////////////////////////////////////////////////////////////
 * Implementation
 */

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline ss_typename_type_k basic_static_string<C, CCH, T>::size_type basic_static_string<C, CCH, T>::length_() const
{
    if(m_length == static_cast<ss_size_t>(-1))
    {
        ss_size_t   &_m_length  =   const_cast<class_type *>(this)->m_length;

        _m_length = traits_type::length(m_buffer);
    }

    return m_length;
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline ss_bool_t basic_static_string<C, CCH, T>::is_valid() const
{
    char_type const*        b  =   &m_buffer[0];
    char_type const* const  e  =   &m_buffer[STLSOFT_NUM_ELEMENTS(m_buffer) - 1];

    for(; b != e && '\0' != *b; ++b)
    {}

    if(b == e)
    {
#ifdef STLSOFT_UNITTEST
        printf("%08x: string contents have been overwritten! Contents=[%*s]\n", static_cast<unsigned>(reinterpret_cast<ss_size_t>(this)), static_cast<int>(max_size()), &m_buffer[0]);
#endif /* STLSOFT_UNITTEST */

        return false;
    }
    else if(m_length != static_cast<ss_size_t>(-1) &&
            m_length > max_size())
    {
#ifdef STLSOFT_UNITTEST
        printf("%08x: length (%ld) greater than maximum allowed (%ld)\n", static_cast<unsigned>(reinterpret_cast<ss_size_t>(this)), static_cast<long>(m_length), static_cast<long>(max_size()));
#endif /* STLSOFT_UNITTEST */

        return false;
    }
    else if(m_length != static_cast<ss_size_t>(-1) &&
            '\0' != m_buffer[m_length])
    {
#ifdef STLSOFT_UNITTEST
        printf("%08x: string not nul-terminated at index (%ld); maximum allowed (%ld)\n", static_cast<unsigned>(reinterpret_cast<ss_size_t>(this)), static_cast<long>(m_length), static_cast<long>(max_size()));
#endif /* STLSOFT_UNITTEST */

        return false;
    }

    return true;
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline basic_static_string<C, CCH, T>::basic_static_string()
    : m_length(static_cast<ss_size_t>(-1))
{
    m_buffer[0]             =   '\0';
    m_buffer[max_size()]    =   '\0';

    STLSOFT_ASSERT(is_valid());
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline basic_static_string<C, CCH, T>::basic_static_string(class_type const& rhs)
    : m_length(rhs.length())
{
    traits_type::copy(m_buffer, rhs.m_buffer, rhs.length());

    m_buffer[m_length]      =   '\0';
    m_buffer[max_size()]    =   '\0';

    STLSOFT_ASSERT(is_valid());

#ifdef _DEBUG
//printf("*this(%s, %d)\n", &m_buffer[0], m_length);
#endif /* _DEBUG */
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline basic_static_string<C, CCH, T>::basic_static_string(class_type const& rhs, size_type pos)
    : m_length(rhs.length() - pos)
{
    traits_type::copy(m_buffer, rhs.m_buffer + pos, m_length);

    m_buffer[m_length]      =   '\0';
    m_buffer[max_size()]    =   '\0';

    STLSOFT_ASSERT(is_valid());
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline basic_static_string<C, CCH, T>::basic_static_string(class_type const& rhs, size_type pos, size_type n)
    : m_length(n)
{
    STLSOFT_MESSAGE_ASSERT("incident string too large for static_string construction", !(max_size() < n));

//printf("ctor(%s, %d, %d = %.*s)\n", rhs.c_str(), pos, n, n, rhs.c_str() + pos);
    traits_type::copy(m_buffer, rhs.m_buffer + pos, n);

    m_buffer[m_length]      =   '\0';
    m_buffer[max_size()]    =   '\0';

    STLSOFT_ASSERT(is_valid());
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline basic_static_string<C, CCH, T>::basic_static_string(char_type const* s)
    : m_length((NULL != s) ? traits_type::length(s) : 0)
{
    STLSOFT_MESSAGE_ASSERT("incident string too large for static_string construction", !(max_size() < m_length));

//printf("Length: %u\n", m_length);

    traits_type::copy(m_buffer, s, m_length);

    m_buffer[m_length]      =   '\0';
    m_buffer[max_size()]    =   '\0';

    STLSOFT_ASSERT(is_valid());
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline basic_static_string<C, CCH, T>::basic_static_string(char_type const* s, size_type n)
    : m_length(n)
{
    STLSOFT_MESSAGE_ASSERT("incident string too large for static_string construction", !(max_size() < n));

    traits_type::copy(m_buffer, s, n);

    m_buffer[m_length]      =   '\0';
    m_buffer[max_size()]    =   '\0';

    STLSOFT_ASSERT(is_valid());
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline basic_static_string<C, CCH, T>::basic_static_string(size_type n, char_type c)
    : m_length(n)
{
    traits_type::assign(m_buffer, n, c);

    m_buffer[m_length]      =   '\0';
    m_buffer[max_size()]    =   '\0';

    STLSOFT_ASSERT(is_valid());
}

#if !defined(STLSOFT_CF_MEMBER_TEMPLATE_RANGE_METHOD_SUPPORT)
template<   ss_typename_param_k C
        ,   ss_size_t           CCH