/* Miscellaneous types used across stage boundaries.
   Copyright (C) 2025 Free Software Foundation, Inc.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "elna/boot/result.h"

namespace elna::boot
{
    location::location(const std::size_t line, const std::size_t column)
        : m_line(line), m_column(column)
    {
    }

    std::size_t location::line() const
    {
        return this->m_line;
    }

    std::size_t location::column() const
    {
        return this->m_column;
    }

    bool location::available() const
    {
        return this->m_line != 0 || this->m_column != 0;
    }

    bool location::operator==(const location& that) const
    {
        return this->m_line == that.m_line && this->m_column == that.m_column;
    }

    bool location::operator!=(const location& that) const
    {
        return !(*this == that);
    }

    source_position::source_position(location start, location end)
        : m_start(start), m_end(end)
    {
    }

    const location& source_position::start() const
    {
        return this->m_start;
    }

    const location& source_position::end() const
    {
        return this->m_end;
    }

    bool source_position::is_span() const
    {
        return this->m_start != this->m_end;
    }

    error::error(const source_position position)
        : position(position)
    {
    }

    std::deque<std::unique_ptr<error>>& error_container::errors()
    {
        return m_errors;
    }

    bool error_container::has_errors() const
    {
        return !m_errors.empty();
    }

    identifier::identifier(const std::string& name, const source_position& position)
        : m_name(name), m_position(position)
    {
    }

    const std::string& identifier::name() const
    {
        return this->m_name;
    }

    const source_position& identifier::position() const
    {
        return this->m_position;
    }

    bool identifier::operator==(const identifier& that) const
    {
        return this->m_name == that.m_name;
    }

    bool identifier::operator!=(const identifier& that) const
    {
        return !(*this == that);
    }

    bool identifier::operator==(const std::string& that) const
    {
        return this->m_name == that;
    }

    bool identifier::operator!=(const std::string& that) const
    {
        return !(*this == that);
    }

    identifier_definition::identifier_definition(const std::string& name,
            const source_position& position, const bool exported)
        : m_identifier(name, position), m_exported(exported)
    {
    }

    const std::string& identifier_definition::name() const
    {
        return this->m_identifier.name();
    }

    const identifier& identifier_definition::id() const
    {
        return this->m_identifier;
    }

    bool identifier_definition::exported() const
    {
        return this->m_exported;
    }
}

std::size_t std::hash<elna::boot::identifier>::operator()(
        const elna::boot::identifier& key) const
{
    return std::hash<std::string>{}(key.name());
}