tribool.hpp

// The MIT License (MIT)

// Copyright (c) 2012-2014 Danny Y., Rapptz

// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#ifndef GEARS_UTILITY_TRIBOOL_HPP
#define GEARS_UTILITY_TRIBOOL_HPP

#include <utility>
#ifndef GEARS_NO_IOSTREAM
#include <iosfwd>
#include <locale>
#include <string>
#endif // GEARS_NO_IOSTREAM

namespace gears {
namespace utility {
struct indeterminate_t {
    constexpr indeterminate_t() {}
};

constexpr indeterminate_t indeterminate{};

struct tribool {
private:
    enum class state : char {
        true_, false_, unknown
    } value;
public:
    constexpr tribool() noexcept: value(state::unknown) {}

    constexpr tribool(indeterminate_t) noexcept: value(state::unknown) {}

    constexpr tribool(bool v) noexcept: value(v ? state::true_ : state::false_) {}

    explicit constexpr operator bool() const noexcept {
        return value == state::true_;
    }

    friend constexpr bool is_true(const tribool& tri) noexcept {
        return tri.value == state::true_;
    }

    friend constexpr bool is_false(const tribool& tri) noexcept {
        return tri.value == state::false_;
    }

    friend constexpr bool is_indeterminate(const tribool& tri) noexcept {
        return tri.value == state::unknown;
    }

    constexpr tribool operator==(const tribool& rhs) const noexcept {
        return (value == state::unknown || rhs.value == state::unknown) ?
                    tribool(indeterminate) : tribool(value == rhs.value);
    }

    constexpr tribool operator!=(const tribool& rhs) const noexcept {
        return (value == state::unknown || rhs.value == state::unknown) ?
                    tribool(indeterminate) : tribool(value != rhs.value);
    }

    constexpr tribool operator!() const noexcept {
        return value == state::unknown ? tribool(indeterminate) : tribool(!(value == state::true_));
    }
};

constexpr tribool operator&&(const tribool& lhs, const tribool& rhs) noexcept {
    return is_false(lhs) || is_false(rhs) ? tribool(false) :
                is_indeterminate(lhs) || is_indeterminate(rhs) ? tribool(indeterminate) : tribool(true);
}

constexpr tribool operator&&(const tribool& lhs, bool b) noexcept {
    return lhs && tribool(b);
}

constexpr tribool operator&&(bool b, const tribool& rhs) noexcept {
    return tribool(b) && rhs;
}

constexpr tribool operator||(const tribool& lhs, const tribool& rhs) noexcept {
    return is_true(lhs) || is_true(rhs) ? tribool(true) :
                is_indeterminate(lhs) || is_indeterminate(rhs) ? tribool(indeterminate) : tribool(false);
}

constexpr tribool operator||(const tribool& lhs, bool b) noexcept {
    return lhs || tribool(b);
}

constexpr tribool operator||(bool b, const tribool& rhs) noexcept {
    return tribool(b) || rhs;
}

#ifndef GEARS_NO_IOSTREAM

template<typename CharT>
constexpr const CharT* get_default_indeterminate_name() noexcept;

template<>
constexpr const char* get_default_indeterminate_name<char>() noexcept {
    return "indeterminate";
}

template<>
constexpr const wchar_t* get_default_indeterminate_name<wchar_t>() noexcept {
    return L"indeterminate";
}

template<typename CharT>
struct indeterminate_name : public std::locale::facet {
public:
    using char_type = CharT;
    using string_type = std::basic_string<CharT>;
private:
    string_type name_ = get_default_indeterminate_name<CharT>();
public:
    indeterminate_name() = default;

    explicit constexpr indeterminate_name(string_type name) noexcept: name_(std::move(name)) {}

    constexpr string_type name() const noexcept {
        return name_;
    }

    static std::locale::id id;
};

template<typename CharT>
std::locale::id indeterminate_name<CharT>::id;

template<typename CharT, typename Traits>
inline auto operator<<(std::basic_ostream<CharT, Traits>& out, const tribool& tri) -> decltype(out) {
    if(!is_indeterminate(tri)) {
        return out << static_cast<bool>(tri);
    }

    typename std::basic_ostream<CharT, Traits>::sentry sentry(out);
    if(sentry) {
        if(out.flags() & std::ios_base::boolalpha) {
            if(std::has_facet<indeterminate_name<CharT>>(out.getloc())) {
                auto&& facet = std::use_facet<indeterminate_name<CharT>>(out.getloc());
                out << facet.name();
            }
            else {
                out << get_default_indeterminate_name<CharT>();
            }
        }
        else {
            out << 2;
        }
    }

    return out;
}

template<typename CharT, typename Traits>
inline auto operator>>(std::basic_istream<CharT, Traits>& in, tribool& tri) -> decltype(in) {
    if(in.flags() & std::ios_base::boolalpha) {
        typename std::basic_istream<CharT, Traits>::sentry sentry(in);
        if(sentry) {
            auto&& loc = in.getloc();
            auto&& numpunct_facet = std::use_facet<std::numpunct<CharT>>(loc);
            auto&& false_name = numpunct_facet.falsename();
            auto&& true_name = numpunct_facet.truename();

            using other_facet = indeterminate_name<CharT>;
            std::basic_string<CharT> other_name = get_default_indeterminate_name<CharT>();
            if(std::has_facet<other_facet>(loc)) {
                auto&& facet = std::use_facet<other_facet>(loc);
                other_name = facet.name();
            }

            std::basic_string<CharT> str;
            if(in >> str) {
                if(str == false_name) {
                    tri = false;
                }
                else if(str == true_name) {
                    tri = true;
                }
                else if(str == other_name) {
                    tri = indeterminate;
                }
                else {
                    in.setstate(std::ios_base::failbit);
                }
            }
            return in;
        }
    }
    else {
        int x;
        if(in >> x) {
            switch(x) {
            case 0: tri = false;         break;
            case 1: tri = true;          break;
            case 2: tri = indeterminate; break;
            default:
                in.setstate(std::ios_base::failbit);
                break;
            }
        }
    }
    return in;
}

#endif // GEARS_NO_IOSTREAM
} // utility
} // gears

#endif // GEARS_UTILITY_TRIBOOL_HPP