📄 static_string.hpp

📁 用STL的方式封装了WindowsAPI、COM调用、ACE、ATL、MFC、WTL等多种组件
💻 HPP
📖 第 1 页 / 共 5 页
字号:
上一页 1 2 3 45
    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_buffer + pos, lhs_len, rhs.m_buffer, 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>::class_type const &rhs) const
{
    STLSOFT_ASSERT(is_valid());

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

    STLSOFT_ASSERT(is_valid());

#ifdef _DEBUG
//printf("Comparing (\"%*s\",%d; \"%*s\",%d)\n", lhs_len, &m_buffer[0], lhs_len, rhs_len, &rhs.m_buffer[0], rhs_len);
#endif /* _DEBUG */

    return compare_(&m_buffer[0], lhs_len, &rhs.m_buffer[0], rhs_len);
}


template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline void basic_static_string<C, CCH, T>::resize( 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   ch /* = value_type() */)
{
    STLSOFT_MESSAGE_ASSERT("resize request too large for static_string", !(max_size() < n));

    STLSOFT_ASSERT(is_valid());

    size_type const len =   length();

    if(len != n)
    {
        if(len < n)
        {
            traits_type::assign(m_buffer + len, n - len, ch);
        }

        m_length = n;
        m_buffer[n] = 0;
    }

    STLSOFT_ASSERT(is_valid());
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline void basic_static_string<C, CCH, T>::clear()
{
    STLSOFT_ASSERT(is_valid());

    m_length = static_cast<ss_size_t>(-1);
    m_buffer[0] = 0;

    STLSOFT_ASSERT(is_valid());
}

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>::reference basic_static_string<C, CCH, T>::operator [](ss_typename_type_k basic_static_string<C, CCH, T>::size_type index)
{
    STLSOFT_MESSAGE_ASSERT("index access out of range in static_string", index < size());

    STLSOFT_ASSERT(is_valid());

    return m_buffer[index];
}

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>::const_reference basic_static_string<C, CCH, T>::operator [](ss_typename_type_k basic_static_string<C, CCH, T>::size_type index) const
{
    STLSOFT_MESSAGE_ASSERT("index access out of range in static_string", index < size() + 1); // Valid to return (const) reference to nul-terminator

    STLSOFT_ASSERT(is_valid());

    return m_buffer[index];
}


#ifdef STLSOFT_CF_EXCEPTION_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>::reference basic_static_string<C, CCH, T>::at(ss_typename_type_k basic_static_string<C, CCH, T>::size_type index)
{
    STLSOFT_ASSERT(is_valid());

    if(index >= size())
    {
        throw ::std::out_of_range("index out of range");
    }

    STLSOFT_ASSERT(is_valid());

    return m_buffer[index];
}

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>::const_reference basic_static_string<C, CCH, T>::at(ss_typename_type_k basic_static_string<C, CCH, T>::size_type index) const
{
    STLSOFT_ASSERT(is_valid());

    if(index > size())
    {
        throw ::std::out_of_range("index out of range");
    }

    STLSOFT_ASSERT(is_valid());

    return m_buffer[index];
}
#endif /* !STLSOFT_CF_EXCEPTION_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>::value_type const *basic_static_string<C, CCH, T>::c_str() const
{
    STLSOFT_ASSERT(is_valid());

    return m_buffer;
}

// Appending

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>::append(   ss_typename_type_k basic_static_string<C, CCH, T>::char_type const  *s
                                                                                                            ,   ss_typename_type_k basic_static_string<C, CCH, T>::size_type        n)
{
    STLSOFT_MESSAGE_ASSERT("resize request too large for static_string", !(max_size() < n + length()));

    STLSOFT_ASSERT(is_valid());

    if(0 != n)
    {
        traits_type::copy(m_buffer + m_length, s, n);

        m_length += n;
        m_buffer[m_length] = 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>::append(ss_typename_type_k basic_static_string<C, CCH, T>::char_type const *s)
{
    STLSOFT_ASSERT(is_valid());

    return append(s, (NULL == s) ? 0 : traits_type::length(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 &basic_static_string<C, CCH, T>::append(   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        cch)
{
    STLSOFT_ASSERT(is_valid());

    char_type const *s  =   rhs.m_buffer;
    size_type       len =   rhs.length();

    if(len < pos)
    {
        pos = len;
    }

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

    if(NULL != s)
    {
        s += pos;
    }
    else
    {
        cch = 0;
    }

    STLSOFT_ASSERT(is_valid());

    return append(s, cch);
}

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

    return append(s.m_buffer, s.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>::class_type &basic_static_string<C, CCH, T>::append(   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    ch)
{
    STLSOFT_MESSAGE_ASSERT("resize request too large for static_string", !(max_size() < n + length()));

//printf("append(pre): *this(%*s)\n", m_length, &m_buffer[0]);

    STLSOFT_ASSERT(is_valid());

    if(0 != n)
    {
        traits_type::assign(m_buffer + m_length, n, ch);

        m_length += n;
        m_buffer[m_length] = 0;
    }

//printf("append(post): *this(%*s)\n", m_length, &m_buffer[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>::append(   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 form, because of Visual C++ .NET's
    // disgusting STL swill. Sigh!
    return append(&(*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 &basic_static_string<C, CCH, T>::operator +=(ss_typename_type_k basic_static_string<C, CCH, T>::char_type ch)
{
    STLSOFT_ASSERT(is_valid());

    return append(1, ch);
}

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

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

    return append(rhs);
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline void basic_static_string<C, CCH, T>::push_back(ss_typename_type_k basic_static_string<C, CCH, T>::char_type ch)
{
    STLSOFT_ASSERT(is_valid());

    append(1, ch);
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline void basic_static_string<C, CCH, T>::reserve(ss_typename_type_k basic_static_string<C, CCH, T>::size_type n)
{
    STLSOFT_ASSERT(is_valid());

    STLSOFT_MESSAGE_ASSERT("reserve request out of range in static_string", !(max_size() < n));
}

template<   ss_typename_param_k C
        ,   ss_size_t           CCH
        ,   ss_typename_param_k T
        >
inline void basic_static_string<C, CCH, T>::swap(ss_typename_type_k basic_static_string<C, CCH, T>::class_type &other)
{
//printf("swap-1\n");

    STLSOFT_ASSERT(is_valid());

//printf("swap-2\n");

    value_type  buffer[CCH];

//printf("swap-3\n");

    traits_type::copy(        buffer, other.m_buffer, 1 + other.m_length);
    traits_type::copy(other.m_buffer,       m_buffer, 1 +       m_length);
    traits_type::copy(      m_buffer,         buffer, 1 + other.m_length);

//printf("swap-4\n");

    std_swap(m_length, other.m_length);

//printf("swap-5\n");

    STLSOFT_ASSERT(is_valid());
}

template<
上一页 1 2 3 45
⌨️ 快捷键说明

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