collator.hpp

//
// Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
//
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_LOCALE_COLLATOR_HPP_INCLUDED
#define BOOST_LOCALE_COLLATOR_HPP_INCLUDED

#include <boost/locale/config.hpp>
#include <locale>

#ifdef BOOST_MSVC
#    pragma warning(push)
#    pragma warning(disable : 4275 4251 4231 4660)
#endif

namespace boost { namespace locale {

    class info;


    enum class collate_level {
        primary = 0,    
        secondary = 1,  
        tertiary = 2,   
        quaternary = 3, 
        identical = 4   
    };

    class BOOST_DEPRECATED("Use collate_level") collator_base {
    public:
        using level_type = collate_level;
        static constexpr auto primary = collate_level::primary;
        static constexpr auto secondary = collate_level::secondary;
        static constexpr auto tertiary = collate_level::tertiary;
        static constexpr auto quaternary = collate_level::quaternary;
        static constexpr auto identical = collate_level::identical;
    };

    template<typename CharType>
    class collator : public std::collate<CharType> {
    public:
        typedef CharType char_type;
        typedef std::basic_string<CharType> string_type;

        int compare(collate_level level,
                    const char_type* b1,
                    const char_type* e1,
                    const char_type* b2,
                    const char_type* e2) const
        {
            return do_compare(level, b1, e1, b2, e2);
        }

        string_type transform(collate_level level, const char_type* b, const char_type* e) const
        {
            return do_transform(level, b, e);
        }

        long hash(collate_level level, const char_type* b, const char_type* e) const { return do_hash(level, b, e); }

        int compare(collate_level level, const string_type& l, const string_type& r) const
        {
            return do_compare(level, l.data(), l.data() + l.size(), r.data(), r.data() + r.size());
        }

        long hash(collate_level level, const string_type& s) const
        {
            return do_hash(level, s.data(), s.data() + s.size());
        }

        string_type transform(collate_level level, const string_type& s) const
        {
            return do_transform(level, s.data(), s.data() + s.size());
        }

    protected:
        collator(size_t refs = 0) : std::collate<CharType>(refs) {}

        int
        do_compare(const char_type* b1, const char_type* e1, const char_type* b2, const char_type* e2) const override
        {
            return do_compare(collate_level::identical, b1, e1, b2, e2);
        }

        string_type do_transform(const char_type* b, const char_type* e) const override
        {
            return do_transform(collate_level::identical, b, e);
        }

        long do_hash(const char_type* b, const char_type* e) const override
        {
            return do_hash(collate_level::identical, b, e);
        }

        virtual int do_compare(collate_level level,
                               const char_type* b1,
                               const char_type* e1,
                               const char_type* b2,
                               const char_type* e2) const = 0;

        virtual string_type do_transform(collate_level level, const char_type* b, const char_type* e) const = 0;
        virtual long do_hash(collate_level level, const char_type* b, const char_type* e) const = 0;
    };

    template<typename CharType, collate_level default_level = collate_level::identical>
    struct comparator {
    public:
        comparator(const std::locale& l = std::locale(), collate_level level = default_level) :
            locale_(l), level_(level)
        {}

        bool operator()(const std::basic_string<CharType>& left, const std::basic_string<CharType>& right) const
        {
            return std::use_facet<collator<CharType>>(locale_).compare(level_, left, right) < 0;
        }

    private:
        std::locale locale_;
        collate_level level_;
    };

}} // namespace boost::locale

#ifdef BOOST_MSVC
#    pragma warning(pop)
#endif


#endif