algorithms.hpp

用STL的方式封装了WindowsAPI、COM调用、ACE、ATL、MFC、WTL等多种组件

        }
    }
#endif /* 0 */
}

/** Determines whether all elements from the range [first2, last2) are
 * contained within the range [first1, last1)
 *
 * \note The algorithm does <i>not</i> assume that the ranges are ordered, and
 * so does linear searches. If the ranges are ordered, you should use \c std::includes
 */
template<   ss_typename_param_k I1
        ,   ss_typename_param_k I2
        >
inline ss_bool_t unordered_includes(I1 first1, I1 last1, I2 first2, I2 last2)
{
    for(; first2 != last2; ++first2)
    {
        ss_bool_t   bFound  =   false;

        for(I1 i1 = first1; i1 != last1; ++i1)
        {
            if(*first2 == *i1)
            {
                bFound = true;
                break;
            }
        }

        if(!bFound)
        {
            return false;
        }
    }

    return true;
}

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

#ifdef STLSOFT_UNITTEST

namespace unittest
{
    namespace
    {
        ss_bool_t test_stlsoft_stlsoft_algorithms__copy_n(unittest_reporter *r)
        {
            ss_bool_t   bSuccess    =   true;

            char        src[]   =   "abcdefghijklm";
            char        dest[]  =   "~~~~~~~~~~~~~";

            // 1. n == 0

            copy_n(src, 0, dest);

            if(dest[0] != '~')
            {
                r->report("copy_n() failed for n == 0", __LINE__);
                bSuccess = false;
            }

            // 2. n == 1

            copy_n(src, 1, dest);

            if( dest[0] != 'a' ||
                dest[1] != '~')
            {
                r->report("copy_n() failed for n == 1", __LINE__);
                bSuccess = false;
            }

            // 3. all n

            copy_n(src, sizeof(src), dest);

            if(0 != strcmp(dest, dest))
            {
                r->report("copy_n() failed for all n", __LINE__);
                bSuccess = false;
            }

            return bSuccess;
        }

        ss_bool_t test_stlsoft_stlsoft_algorithms__copy_n_pr(unittest_reporter * /* r */)
        {
            ss_bool_t   bSuccess    =   true;

            return bSuccess;
        }

        ss_bool_t test_stlsoft_stlsoft_algorithms__copy_if(unittest_reporter * /* r */)
        {
            ss_bool_t   bSuccess    =   true;

            return bSuccess;
        }

        ss_bool_t test_stlsoft_stlsoft_algorithms__copy_if_pr(unittest_reporter * /* r */)
        {
            ss_bool_t   bSuccess    =   true;

            return bSuccess;
        }

        ss_bool_t test_stlsoft_stlsoft_algorithms__skip_equal(unittest_reporter * /* r */)
        {
            ss_bool_t   bSuccess    =   true;

            return bSuccess;
        }

        ss_bool_t test_stlsoft_stlsoft_algorithms__skip_equal_pr(unittest_reporter * /* r */)
        {
            ss_bool_t   bSuccess    =   true;

            return bSuccess;
        }

        ss_bool_t test_stlsoft_stlsoft_algorithms__find_first_duplicate(unittest_reporter *r)
        {
            ss_bool_t   bSuccess    =   true;

            const char  r1[]        =   "abcdefghfijklm";
            const char  r2[]        =   "abcdefghijklmn";

            typedef stlsoft_ns_qual_std(pair)<char const*, char const*> char_pair_t;

            char_pair_t p1  =   find_first_duplicate(&r1[0], &r1[0] + STLSOFT_NUM_ELEMENTS(r1) - 1);

            if( p1.first == &r1[0] + STLSOFT_NUM_ELEMENTS(r1) - 1 ||
                p1.second == &r1[0] + STLSOFT_NUM_ELEMENTS(r1) - 1)
            {
                r->report("find_first_duplicate() failed for not finding duplicates within \"abcdefghfijklm\"", __LINE__);
                bSuccess = false;
            }
            else if(*p1.first != *p1.second)
            {
                r->report("find_first_duplicate() failed for reporting wrong duplicates within \"abcdefghfijklm\"", __LINE__);
                bSuccess = false;
            }

            char_pair_t p2  =   find_first_duplicate(&r2[0], &r2[0] + STLSOFT_NUM_ELEMENTS(r1) - 1);

            if( p2.first != &r2[0] + STLSOFT_NUM_ELEMENTS(r2) - 1 ||
                p2.second != &r2[0] + STLSOFT_NUM_ELEMENTS(r2) - 1)
            {
                r->report("find_first_duplicate() failed for finding duplicates within \"abcdefghijklmn\"", __LINE__);
                bSuccess = false;
            }

            return bSuccess;
        }

        ss_bool_t test_stlsoft_stlsoft_algorithms__find_first_duplicate_pr(unittest_reporter * /* r */)
        {
            ss_bool_t   bSuccess    =   true;

            return bSuccess;
        }

        ss_bool_t test_stlsoft_stlsoft_algorithms__unordered_includes(unittest_reporter *r)
        {
            ss_bool_t   bSuccess    =   true;

            const char  r1[]        =   "abcdefgh";
            const char  r2[]        =   "deadbeaf";

            if(!unordered_includes(&r1[0], &r1[0] + STLSOFT_NUM_ELEMENTS(r1) - 1, &r2[0], &r2[0] + STLSOFT_NUM_ELEMENTS(r1) - 1))
            {
                r->report("unordered_includes() failed for not finding \"deadbeaf\" within \"abcdefgh\"", __LINE__);
                bSuccess = false;
            }

            if(unordered_includes(&r2[0], &r2[0] + STLSOFT_NUM_ELEMENTS(r1) - 1, &r1[0], &r1[0] + STLSOFT_NUM_ELEMENTS(r1) - 1))
            {
                r->report("unordered_includes() failed for finding \"abcdefgh\" within \"deadbeaf\"", __LINE__);
                bSuccess = false;
            }

            return bSuccess;
        }

        ss_bool_t test_stlsoft_stlsoft_algorithms(unittest_reporter *r)
        {
            ss_bool_t               bSuccess    =   true;

            unittest_initialiser    init(r, "STLSoft", "stlsoft/algorithms", __FILE__);

            if(!test_stlsoft_stlsoft_algorithms__copy_n(r))
            {
                bSuccess = false;
            }

            if(!test_stlsoft_stlsoft_algorithms__copy_n_pr(r))
            {
                bSuccess = false;
            }

            if(!test_stlsoft_stlsoft_algorithms__copy_if(r))
            {
                bSuccess = false;
            }

            if(!test_stlsoft_stlsoft_algorithms__copy_if_pr(r))
            {
                bSuccess = false;
            }

            if(!test_stlsoft_stlsoft_algorithms__skip_equal(r))
            {
                bSuccess = false;
            }

            if(!test_stlsoft_stlsoft_algorithms__skip_equal_pr(r))
            {
                bSuccess = false;
            }

            if(!test_stlsoft_stlsoft_algorithms__find_first_duplicate(r))
            {
                bSuccess = false;
            }

            if(!test_stlsoft_stlsoft_algorithms__find_first_duplicate_pr(r))
            {
                bSuccess = false;
            }

            if(!test_stlsoft_stlsoft_algorithms__unordered_includes(r))
            {
                bSuccess = false;
            }

            return bSuccess;
        }

        unittest_registrar    unittest_stlsoft_stlsoft_algorithms(test_stlsoft_stlsoft_algorithms);
    } // anonymous namespace

} // namespace unittest

#endif /* STLSOFT_UNITTEST */

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

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

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

#endif /* !STLSOFT_INCL_STLSOFT_HPP_ALGORITHMS */

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