Instigate Open Source Documentation

---

src/stl/_lexicographical_compare_3way.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_3WAY_HPP
#define INSTIGATE_STL_SET_LEXICOGRAPHICAL_COMPARE_3WAY_HPP

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

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

// headers from standard library

// forward declaration
namespace instigate {
        namespace stl {
                template <typename I, typename I1>
                int lexicographical_compare_3way(I b, I e, I1 f, I1 l);

                int lexicographical_compare_3way(const char* b, const char* e,
                             const char* f, const char* l);
        }
}

template <typename I, typename I1>
int instigate::stl::lexicographical_compare_3way(I b, I e, I1 f, I1 l)
{
        namespace SP = instigate::stl::single_pass_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace EQ = instigate::generic::equality_comparable;
        namespace LT = instigate::generic::less_than_comparable;
        namespace INC = instigate::stl::incrementable_iterator;
        namespace WR = instigate::stl::writable_iterator;
        CHECK(SP::requirements<I>);
        CHECK(RI::requirements<I>);
        CHECK(SP::requirements<I1>);
        CHECK(RI::requirements<I1>);
        typedef typename RI::interface<I>::value_type value_type1;
        typedef typename RI::interface<I1>::value_type value_type2;
        CHECK(LT::requirements<value_type1>);
        CHECK(LT::requirements<value_type2>);
        while (!equal(b, e) && !equal(f, l)) {
                if (less_than(dereference(b), dereference(f))) {
                        return -1;
                }
                if (less_than(dereference(f), dereference(b))) {
                        return 1;
                }
                increment(b);
                increment(f);
        }
        if(equal(f, l)) {
                return !equal(b, e);
        } else {
                return -1;
        }
}

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

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

#endif // INSTIGATE_STL_SET_LEXICOGRAPHICAL_COMPARE_3WAY_HPP

---

© Instigate CJSC, Open Source