Instigate Open Source Documentation

---

src/stl/_lexicographical_compare.hpp

Go to the documentation of this file.

#ifndef _INSTIGATE_STL_INTERNAL_HEADER_IN_ALGORITHM
#error This is an internal header file used to implement Instigate STL.\
        It should never be included directly by a program.
#endif

#ifndef INSTIGATE_STL_SET_LEXICOGRAPHICAL_COMPARE_HPP
#define INSTIGATE_STL_SET_LEXICOGRAPHICAL_COMPARE_HPP

// headers from this project
#include "concept.hpp"
#include "_min.hpp"
#include "_basis.hpp"

// headers from other project
#include <generic/base.hpp>

// headers from standard library
#include <string.h>

// forward declaration
namespace instigate {
        namespace stl {
                template <typename I, typename I1>
                bool lexicographical_compare(I b, I e, I1 f, I1 l);
                template <typename I, typename I1, typename B>
                bool lexicographical_compare(I b, I e, I1 f, I1 l, B p);
                inline bool lexicographical_compare(const char* b,const char* e,
                                                  const char* f, const char* l);
        }
}

template <typename I, typename I1>
bool instigate::stl::lexicographical_compare(I b, I e, I1 f, I1 l)
{
        for (; !equal(b, e) && !equal(f, l); increment(b), increment(f)) {
                if (less_than(const_dereference(b), const_dereference(f))) {
                        return true;
                }
                if (less_than(const_dereference(f), const_dereference(b))) {
                        return false;
                }
        }
        return  equal(b, e) && !equal(f, l);
}

template <typename I, typename I1, typename B>
bool instigate::stl::lexicographical_compare(I b, I e, I1 f, I1 l, B p)
{
        namespace RI = instigate::stl::readable_iterator;
        namespace BP = instigate::stl::binary_predicate;
        typedef typename RI::interface<I>::value_type value_type1;
        typedef typename RI::interface<I1>::value_type value_type2;
        typedef typename BP::interface<B>::first_argument_type 
                first_argument_type;
        typedef typename BP::interface<B>::second_argument_type 
                second_argument_type;
        CHECK_CONVERTIBILITY(value_type1, first_argument_type);
        CHECK_CONVERTIBILITY(value_type2, second_argument_type);
        for (; !equal(b, e) && !equal(f, l); increment(b), increment(f)) {
                if(invoke_predicate(p, const_dereference(b), 
                                                const_dereference(f))) {
                        return true;
                }
                if(invoke_predicate(p, const_dereference(f),
                                        const_dereference(b))) 
                {
                        return false;
                }
        }
        return  equal(b, e) && !equal(f, l);
}

inline bool instigate::stl::
lexicographical_compare(const char* b, const char* e, 
                        const char* f, const char* l)
{
        using namespace instigate::stl;
        assert(e >= b);
        assert(l >= f);
        const size_t len1 = e - b;
        const size_t len2 = l - f;
        int r = 0;
        assign(r, memcmp(b, f, instigate::stl::min(len1, len2)));
        if (0 != r) {
                return less_than(r, 0);
        } else {
                return less_than(len1, len2);
        }
}

// vim:et:tabstop=8:shiftwidth=8:cindent:fo=croq:textwidth=80:

#endif // INSTIGATE_STL_SET_LEXICOGRAPHICAL_COMPARE_HPP

---

© Instigate CJSC, Open Source