fast_string_concatenator.hpp

新版本TR1的stl

/// @}

// Not to be implemented
private:
    fast_string_concatenator& operator =(class_type const&);
};

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

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

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

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(S const& lhs, S const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(S const& lhs, C const* rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(S const& lhs, C const rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(C const* lhs, S const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(C const lhs, S const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(fast_string_concatenator const& lhs, S const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(fast_string_concatenator const& lhs, C const* rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(fast_string_concatenator const& lhs, C const rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

// These constructors are for handling embedded braces in the concatenation sequences, and represent the pathological case
template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(fast_string_concatenator const& lhs, fast_string_concatenator const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(S const& lhs, fast_string_concatenator const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(C const* lhs, fast_string_concatenator const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(C const lhs, fast_string_concatenator const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T>::fast_string_concatenator(fsc_seed const& lhs, S const& rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
{}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
#if defined(STLSOFT_COMPILER_IS_GCC)
inline fast_string_concatenator<S, C, T>::operator S() const
#else /* ? compiler */
inline fast_string_concatenator<S, C, T>::operator ss_typename_type_k fast_string_concatenator<S, C, T>::string_type() const
#endif /* compiler */
{
    size_type   len = length();
    string_type s(len, '~');
#if defined(STLSOFT_FAST_STRING_CONCATENATION_ASSUME_CONTIGUOUS_STORAGE)

    char_type   &c0 = s.operator[](0);

// TODO: Need to fix this up, since assumes that all string types use contiguous storage? Or at least verify that it's got no problem as is

//    *write(&c0) = '\0'; // This assignment may not be necessary
    write(&c0);

    STLSOFT_ASSERT(s.length() == traits_type::length(&c0));
#else /* ? STLSOFT_FAST_STRING_CONCATENATION_ASSUME_CONTIGUOUS_STORAGE */
    write(s.begin());

    STLSOFT_ASSERT(s.length() == traits_type::length(s.c_str()));
#endif /* STLSOFT_FAST_STRING_CONCATENATION_ASSUME_CONTIGUOUS_STORAGE */

    return s;
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////
 * operator +
 */

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(fsc_seed const& lhs, S const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

#if 0
template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(S const& lhs, fsc_seed const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}
#endif /* 0 */

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> const& operator +(fsc_seed const& /* lhs */, fast_string_concatenator<S, C, T> const& rhs)
{
    return rhs;
}

#if 0
template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> const& operator +(fast_string_concatenator<S, C, T> const& /* lhs */, fsc_seed const& rhs)
{
    return rhs;
}
#endif /* 0 */




#if 0 /* These methods are not required, since they must be specifically provided for a given string class anyway */
template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(S const& lhs, S const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(S const& lhs, C const* rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(S const& lhs, C const rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(C const* lhs, S const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(C const lhs, S const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}
#endif /* 0 */

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(fast_string_concatenator<S, C, T> const& lhs, S const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(fast_string_concatenator<S, C, T> const& lhs, C const* rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(fast_string_concatenator<S, C, T> const& lhs, C const rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

// These operators are for handling embedded braces in the concatenation sequences, and represent the pathological case
template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(fast_string_concatenator<S, C, T> const& lhs, fast_string_concatenator<S, C, T> const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(S const& lhs, fast_string_concatenator<S, C, T> const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(C const* lhs, fast_string_concatenator<S, C, T> const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

template<   ss_typename_param_k S
        ,   ss_typename_param_k C
        ,   ss_typename_param_k T
        >
inline fast_string_concatenator<S, C, T> operator +(C const lhs, fast_string_concatenator<S, C, T> const& rhs)
{
    return fast_string_concatenator<S, C, T>(lhs, rhs);
}

/* ////////////////////////////////////////////////////////////////////// */

#ifndef _STLSOFT_NO_NAMESPACE
} // namespace stlsoft
#endif /* _STLSOFT_NO_NAMESPACE */

/* ////////////////////////////////////////////////////////////////////// */

#endif /* !STLSOFT_INCL_STLSOFT_STRING_HPP_FAST_STRING_CONCATENATOR */

/* ////////////////////////////////////////////////////////////////////// */