location.hh

#pragma once
 
#include <clingo/core/symbol.hh>
 
#include <cstddef>
#include <optional>
#include <variant>
 
namespace CppClingo {
 
 
class Position {
  public:
    Position(String file, size_t line, size_t column) : file_{file}, line_{line}, column_{column} {}
    [[nodiscard]] auto file() const -> String const & { return *file_; }
    [[nodiscard]] auto line() const -> size_t { return line_; }
    [[nodiscard]] auto column() const -> size_t { return column_; }
 
    friend auto operator==(Position const &a, Position const &b) -> bool = default;
    friend auto operator<=>(Position const &a, Position const &b) = default;
 
    template <class T> friend auto operator<<(T &out, Position const &pos) -> T & {
        out << pos.file() << ":" << pos.line() << ":" << pos.column();
        return out;
    }
 
  private:
    SharedString file_;
    size_t line_;
    size_t column_;
};
 
class Location {
  public:
    Location(Position begin, Position end) : begin_{std::move(begin)}, end_{std::move(end)} {}
 
    [[nodiscard]] auto begin() const -> Position const & { return begin_; }
    [[nodiscard]] auto end() const -> Position const & { return end_; }
 
    friend auto operator+(Location const &a, Location const &b) -> Location { return {a.begin_, b.end_}; }
    friend auto operator+(Location const &a, Position b) -> Location { return {a.begin_, std::move(b)}; }
    friend auto operator+(Location const &a, std::optional<Position> b) -> Location {
        if (b.has_value()) {
            return {a.begin_, b.value()};
        }
        return a;
    }
    friend auto operator+(Position a, Location const &b) -> Location { return {std::move(a), b.end_}; }
    friend auto operator+(std::optional<Position> a, Location const &b) -> Location {
        if (a) {
            return {*a, b.end_};
        }
        return b;
    }
    friend auto operator+=(Location &a, Location const &b) -> Location & {
        a.end_ = b.end_;
        return a;
    }
    friend auto operator+=(Location &a, Position b) -> Location & {
        a.end_ = std::move(b);
        return a;
    }
    friend auto operator+=(Location &a, std::optional<Position> b) -> Location & {
        if (b) {
            a.end_ = *std::move(b);
        }
        return a;
    }
 
    friend auto operator==(Location const &a, Location const &b) -> bool = default;
    friend auto operator<=>(Location const &a, Location const &b) = default;
 
    template <class T> friend auto operator<<(T &out, Location const &loc) -> T & {
        out << loc.begin() << "-";
        if (loc.end().file() != loc.begin().file()) {
            out << loc.end();
        } else if (loc.end().line() != loc.begin().line()) {
            out << loc.end().line() << ":" << loc.end().column();
        } else {
            out << loc.end().column();
        }
        return out;
    }
 
  private:
    Position begin_;
    Position end_;
};
 
inline auto operator+(Position a, Position b) -> Location {
    return {std::move(a), std::move(b)};
}
 
template <class T>
    requires requires(T const &x) { x.loc(); }
auto location(T const &x) -> Location const & {
    return x.loc();
}
 
template <class... T>
    requires requires(T const &...x) { (location(x), ...); }
auto location(std::variant<T...> const &x) -> Location const & {
    return std::visit([](auto const &y) -> Location const & { return location(y); }, x);
}
 
 
} // namespace CppClingo