alt.hpp

新版本TR1的stl

    }

    return first;
#endif /* STLSOFT_CF_std_NAMESPACE */
}

/** \brief Equivalent to std::for_each()
 *
 * \ingroup group__library__algorithms
 */
template<   ss_typename_param_k I
        ,   ss_typename_param_k UF
        >
// [[synesis:function:algorithm: std_for_each(T<I> first, T<I> last, T<UF> func)]]
inline UF std_for_each(I first, I last, UF func)
{
#ifdef STLSOFT_CF_std_NAMESPACE
    return stlsoft_ns_qual_std(for_each)(first, last, func);
#else /* ? STLSOFT_CF_std_NAMESPACE */
    for(; first != last; ++first)
    {
        func(*first);
    }

    return func;
#endif /* STLSOFT_CF_std_NAMESPACE */
}

/** \brief Equivalent to std::replace()
 *
 * \ingroup group__library__algorithms
 */
template<   ss_typename_param_k I
        ,   ss_typename_param_k T
        >
// [[synesis:function:algorithm: std_replace(T<I> first, T<I> last, T<V> const& valFind, T<V> const& valReplace)]]
inline void std_replace(I first, I last, T const& valFind, T const& valReplace)
{
    for(; first != last; ++first)
    {
        if(valFind == *first)
        {
            *first = valReplace;
        }
    }
}

#ifdef STLSOFT_CF_std_NAMESPACE
/** \brief Equivalent to std::sort()
 *
 * \ingroup group__library__algorithms
 */
template <ss_typename_param_k RI>
// [[synesis:function:algorithm: std_sort(T<RI> first, T<RI> last)]]
inline void sort(RI first, RI last)
{
    stlsoft_ns_qual_std(sort)(first, last);
}

/** \brief Equivalent to std::sort()
 *
 * \ingroup group__library__algorithms
 */
template<   ss_typename_param_k RI
        ,   ss_typename_param_k BP
        >
// [[synesis:function:algorithm: std_sort(T<RI> first, T<RI> last, T<BP> pred)]]
inline void std_sort(RI first, RI last, BP pred)
{
    stlsoft_ns_qual_std(sort)(first, last, pred);
}

#else /* ? STLSOFT_CF_std_NAMESPACE */

// Nothing current defined
template <ss_typename_param_k RI>
inline void sort(RI first, RI last);

// Nothing current defined
template<   ss_typename_param_k RI
        ,   ss_typename_param_k BP
        >
inline void std_sort(RI first, RI last, BP pred);

#endif /* STLSOFT_CF_std_NAMESPACE */

/** \brief Equivalent to std::transform()
 *
 * \ingroup group__library__algorithms
 */
template<   ss_typename_param_k I
        ,   ss_typename_param_k O
        ,   ss_typename_param_k UF
        >
// [[synesis:function:algorithm: std_transform(T<I> first, T<I> last, T<O> dest, T<UF> func)]]
inline O std_transform(I first, I last, O dest, UF func)
{
#ifdef STLSOFT_CF_std_NAMESPACE
    return stlsoft_ns_qual_std(transform)(first, last, dest, func);
#else /* ? STLSOFT_CF_std_NAMESPACE */
    for(; first != last; ++first, ++dest)
    {
        *dest = func(*first);
    }

    return dest;
#endif /* STLSOFT_CF_std_NAMESPACE */
}

/** \brief Equivalent to std::unique()
 *
 * \ingroup group__library__algorithms
 */
template<   ss_typename_param_k FI
        ,   ss_typename_param_k BP
        >
// [[synesis:function:algorithm: std_unique(T<FI> first, T<FI> last, T<BP> pred)]]
inline FI std_unique(FI first, FI last, BP pred)
{
#ifdef STLSOFT_ENFORCE_ORDERING
    stlsoft_assert("range passed to unique() is not strict-weak ordered", is_strict_weak_ordered(first, last, pred));
#endif /* STLSOFT_ENFORCE_ORDERING */

#ifdef STLSOFT_CF_std_NAMESPACE
    return stlsoft_ns_qual_std(unique)(first, last, pred);
#else /* ? STLSOFT_CF_std_NAMESPACE */
    if(first != last)
    {
# ifdef _DEBUG
        const FI    start   =   first;
# endif /* _DEBUG */
        FI          curr    =   first;  // The first elements is always unique

        for(++first; first != last; ++first)
        {
            if(pred(*first, *curr))
            {
                ; // Same, so skip it
            }
            else
            {
                ++curr;
                if(first != curr)
                {
                    *curr = *first;
                }
            }
        }

        first = ++curr;
    }

    return first;
#endif /* STLSOFT_CF_std_NAMESPACE */
}

/** \brief Equivalent to std::unique()
 *
 * \ingroup group__library__algorithms
 */
template <ss_typename_param_k FI>
// [[synesis:function:algorithm: std_unique(T<FI> first, T<FI> last)]]
inline FI std_unique(FI first, FI last)
{
#ifdef STLSOFT_ENFORCE_ORDERING
    stlsoft_assert("range passed to unique() is not strict-weak ordered", is_strict_weak_ordered(first, last));
#endif /* STLSOFT_ENFORCE_ORDERING */

#ifdef STLSOFT_CF_std_NAMESPACE
    return stlsoft_ns_qual_std(unique)(first, last);
#else /* ? STLSOFT_CF_std_NAMESPACE */
    if(first != last)
    {
# ifdef _DEBUG
        const FI    start   =   first;
# endif /* _DEBUG */
        FI          curr    =   first;  // The first elements is always unique

        for(++first; first != last; ++first)
        {
            if(*first == *curr)
            {
                ; // Same, so skip it
            }
            else
            {
                ++curr;
                if(first != curr)
                {
                    *curr = *first;
                }
            }
        }

        first = ++curr;
    }

    return first;
#endif /* STLSOFT_CF_std_NAMESPACE */
}

/** \brief Equivalent to std::unique_copy()
 *
 * \ingroup group__library__algorithms
 */
template<   ss_typename_param_k FI
        ,   ss_typename_param_k OI
        >
// [[synesis:function:algorithm: std_unique_copy(T<FI> first, T<FI> last, T<OI> dest)]]
inline OI std_unique_copy(FI first, FI last, OI dest)
{
#ifdef STLSOFT_ENFORCE_ORDERING
    stlsoft_assert("range passed to unique_copy() is not strict-weak ordered", is_strict_weak_ordered(first, last));
#endif /* STLSOFT_ENFORCE_ORDERING */

#ifdef STLSOFT_CF_std_NAMESPACE
    return stlsoft_ns_qual_std(unique_copy)(first, last, dest);
#else /* ? STLSOFT_CF_std_NAMESPACE */
    if(first != last)
    {
# ifdef _DEBUG
        const FI    start   =   first;
# endif /* _DEBUG */
        FI          curr    =   first;  // The first elements is always unique

        *dest++ = *first++;
        for(; first != last; ++first)
        {
            if(*first == *curr)
            {
                ; // Same, so skip it
            }
            else
            {
                curr = first;
                *dest++ = *first;
            }
        }

        first = ++curr;
    }

    return dest;
#endif /* STLSOFT_CF_std_NAMESPACE */
}

/** \brief Equivalent to std::unique_copy()
 *
 * \ingroup group__library__algorithms
 */
template<   ss_typename_param_k FI
        ,   ss_typename_param_k OI
        ,   ss_typename_param_k BP
        >
// [[synesis:function:algorithm: std_unique_copy(T<FI> first, T<FI> last, T<OI> dest, T<BP> pred)]]
inline OI std_unique_copy(FI first, FI last, OI dest, BP pred)
{
#ifdef STLSOFT_ENFORCE_ORDERING
    stlsoft_assert("range passed to unique_copy() is not strict-weak ordered", is_strict_weak_ordered(first, last, pred));
#endif /* STLSOFT_ENFORCE_ORDERING */

#ifdef STLSOFT_CF_std_NAMESPACE
    return stlsoft_ns_qual_std(unique_copy)(first, last, dest, pred);
#else /* ? STLSOFT_CF_std_NAMESPACE */
    if(first != last)
    {
# ifdef _DEBUG
        const FI    start   =   first;
# endif /* _DEBUG */
        FI          curr    =   first;  // The first elements is always unique

        *dest++ = *first++;
        for(; first != last; ++first)
        {
            if(pred(*first, *curr))
            {
                ; // Same, so skip it
            }
            else
            {
                curr = first;
                *dest++ = *first;
            }
        }

        first = ++curr;
    }

    return dest;
#endif /* STLSOFT_CF_std_NAMESPACE */
}

////////////////////////////////////////////////////////////////////////////

/// @} // end of group algorithms_std_alt

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

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

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

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

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

#endif /* !STLSOFT_INCL_STLSOFT_ALGORITHMS_STD_HPP_ALT */

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