📄 static_string.hpp

📁 新版本TR1的stl
💻 HPP
📖 第 1 页 / 共 5 页
字号:
        ,   ss_typename_param_k T
        >
inline basic_static_string<C, CCH, T>::basic_static_string(char_type const* f, char_type const* t)
    : m_length(t - f)
{
    STLSOFT_MESSAGE_ASSERT("incident string too large for static_string construction", !(max_size() < m_length));

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

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

    STLSOFT_ASSERT(is_valid());
}
#endif /* STLSOFT_CF_MEMBER_TEMPLATE_RANGE_METHOD_SUPPORT */

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() stlsoft_throw_0()
{
    STLSOFT_ASSERT(is_valid());
}


// Assignment

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>::class_type &basic_static_string<C, CCH, T>::assign(const ss_typename_type_k basic_static_string<C, CCH, T>::char_type *s)
{
    STLSOFT_ASSERT(is_valid());

#if 0
    m_length = static_cast<ss_size_t>(-1);
    traits_type::copy(m_buffer, s, CCH);
    m_buffer[max_size()]    =   '\0';
#else /* ? 0 */
    class_type  t(s);
    t.swap(*this);
#endif /* 0 */

    STLSOFT_ASSERT(is_valid());

    return *this;
}

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>::class_type &basic_static_string<C, CCH, T>::assign(const ss_typename_type_k basic_static_string<C, CCH, T>::char_type *s, ss_typename_type_k basic_static_string<C, CCH, T>::size_type n)
{
    STLSOFT_MESSAGE_ASSERT("incident string too large for static_string assignment", !(max_size() < n));

    STLSOFT_ASSERT(is_valid());

#if 0
    traits_type::copy(m_buffer, s, n);

    m_length = n;
    m_buffer[m_length]      =   '\0';
    m_buffer[max_size()]    =   '\0';
#else /* ? 0 */
    class_type  t(s, n);
    t.swap(*this);
#endif /* 0 */

    STLSOFT_ASSERT(is_valid());

    return *this;
}

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>::class_type &basic_static_string<C, CCH, T>::assign(   ss_typename_type_k basic_static_string<C, CCH, T>::class_type const& rhs
                                                                                                            ,   ss_typename_type_k basic_static_string<C, CCH, T>::size_type        pos
                                                                                                            ,   ss_typename_type_k basic_static_string<C, CCH, T>::size_type        n)
{
    STLSOFT_MESSAGE_ASSERT("incident string too large for static_string assignment", !(max_size() < n));

    STLSOFT_ASSERT(is_valid());

#if 0
    traits_type::copy(m_buffer, rhs.m_buffer + pos, n);

    m_length = n;
    m_buffer[m_length]      =   '\0';
    m_buffer[max_size()]    =   '\0';
#else /* ? 0 */
    class_type  t(rhs, pos, n);
    t.swap(*this);
#endif /* 0 */

    STLSOFT_ASSERT(is_valid());

    return *this;
}

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>::class_type &basic_static_string<C, CCH, T>::assign(ss_typename_type_k basic_static_string<C, CCH, T>::class_type const& rhs)
{
    STLSOFT_ASSERT(is_valid());

//printf("1\n");

#ifdef _DEBUG
    const class_type    result(rhs);
#endif /* _DEBUG */

//printf("2\n");

//printf("assign(%s, %d)\n", rhs.c_str(), rhs.length());

    class_type  t(rhs);

//printf("3\n");

    t.swap(*this);

//printf("4\n");


//printf("5\n");

#ifdef _DEBUG
//printf("result(%s, %d); rhs(%s, %d); t(%s, %d), *this(%s, %d)\n", result.c_str(), result.length(), rhs.c_str(), rhs.length(), t.c_str(), t.length(), c_str(), length());
    STLSOFT_ASSERT(result == *this);
#endif /* _DEBUG */

//printf("6\n");

    STLSOFT_ASSERT(is_valid());

//printf("7\n");

    return *this;
}

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>::class_type &basic_static_string<C, CCH, T>::assign(   ss_typename_type_k basic_static_string<C, CCH, T>::size_type n
                                                                                                            ,   ss_typename_type_k basic_static_string<C, CCH, T>::char_type c)
{
    STLSOFT_MESSAGE_ASSERT("incident string too large for static_string assignment", !(max_size() < n));

    STLSOFT_ASSERT(is_valid());

#if 0
    traits_type::assign(m_buffer, n, c);

    m_length = n;
    m_buffer[m_length]      =   '\0';
    m_buffer[max_size()]    =   '\0';
#else /* ? 0 */
    class_type  t(n, c);
    t.swap(*this);
#endif /* 0 */

    STLSOFT_ASSERT(is_valid());

    return *this;
}

#if !defined(STLSOFT_CF_MEMBER_TEMPLATE_RANGE_METHOD_SUPPORT)
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>::class_type &basic_static_string<C, CCH, T>::assign(ss_typename_type_k basic_static_string<C, CCH, T>::const_iterator first, ss_typename_type_k basic_static_string<C, CCH, T>::const_iterator last)
{
    STLSOFT_ASSERT(is_valid());

    // We have to use this strange appearing this, because of Visual C++ .NET's
    // disgusting STL swill. Sigh!
    return assign(&(*first), last - first);
}
#endif /* STLSOFT_CF_MEMBER_TEMPLATE_RANGE_METHOD_SUPPORT */

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>::class_type const& basic_static_string<C, CCH, T>::operator =(ss_typename_type_k basic_static_string<C, CCH, T>::class_type const& rhs)
{
    STLSOFT_ASSERT(is_valid());

    return assign(rhs);
}

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>::class_type const& basic_static_string<C, CCH, T>::operator =(ss_typename_type_k basic_static_string<C, CCH, T>::char_type const* s)
{
    STLSOFT_ASSERT(is_valid());

    return assign(s);
}

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>::class_type const& basic_static_string<C, CCH, T>::operator =(ss_typename_type_k basic_static_string<C, CCH, T>::char_type c)
{
    STLSOFT_ASSERT(is_valid());

    m_length = 1;
    m_buffer[0] = c;
    m_buffer[1] = c;

    STLSOFT_ASSERT(is_valid());

    return *this;
}


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>::size() const
{
    return class_type::length();
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline /* static */ ss_typename_type_k basic_static_string<C, CCH, T>::size_type basic_static_string<C, CCH, T>::max_size()
{
#if defined(STLSOFT_COMPILER_IS_BORLAND)
    return CCH_;
#else /* ? compiler */
    return cch;
#endif /* compiler */
}

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
{
    STLSOFT_ASSERT(is_valid());

    return length_();
}

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

    return class_type::max_size();
}

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

    return m_buffer[0] == 0;
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline /* static */ ss_sint_t basic_static_string<C, CCH, T>::compare_( ss_typename_type_k basic_static_string<C, CCH, T>::value_type const* lhs
                                                                    ,   ss_typename_type_k basic_static_string<C, CCH, T>::size_type        lhs_len
                                                                    ,   ss_typename_type_k basic_static_string<C, CCH, T>::value_type const* rhs
                                                                    ,   ss_typename_type_k basic_static_string<C, CCH, T>::size_type        rhs_len)
{
    size_type   cmp_len =   (lhs_len < rhs_len) ? lhs_len : rhs_len;
    ss_int_t    result  =   traits_type::compare(lhs, rhs, cmp_len);

    if(result == 0)
    {
        result = static_cast<ss_int_t>(lhs_len) - static_cast<ss_int_t>(rhs_len);
    }

#ifdef _DEBUG
//printf("compare_(\"%*s\",%d\n        ,\"%*s\",%d) == %d\n", lhs_len, lhs, lhs_len, rhs_len, rhs, rhs_len, result);
#endif /* _DEBUG */

    return result;
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline ss_sint_t basic_static_string<C, CCH, T>::compare(ss_typename_type_k basic_static_string<C, CCH, T>::size_type pos, ss_typename_type_k basic_static_string<C, CCH, T>::size_type n, ss_typename_type_k basic_static_string<C, CCH, T>::value_type const* s, ss_typename_type_k basic_static_string<C, CCH, T>::size_type cchRhs) const
{
    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 =   (s == 0) ? 0 : traits_type::length(s);

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

    STLSOFT_ASSERT(is_valid());

    return compare_(m_buffer + pos, lhs_len, s, rhs_len);
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline ss_sint_t basic_static_string<C, CCH, T>::compare(ss_typename_type_k basic_static_string<C, CCH, T>::size_type pos, ss_typename_type_k basic_static_string<C, CCH, T>::size_type n, ss_typename_type_k basic_static_string<C, CCH, T>::value_type const* s) const
{
    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 =   (s == 0) ? 0 : traits_type::length(s);

    STLSOFT_ASSERT(is_valid());

    return compare_(m_buffer + pos, lhs_len, s, rhs_len);
}

template<   ss_typename_param_k C
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -