define_statement.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <string>
#include <variant>
 
#include "porytiles/utilities/c_parser/source_position.hpp"
#include "porytiles/utilities/panic/panic.hpp"
 
namespace porytiles {
 
using DefineValue = std::variant<std::int64_t, std::string, std::monostate>;
 
class DefineStatement {
  public:
    DefineStatement(std::string name, std::int64_t value, SourcePosition position)
        : name_{std::move(name)}, value_{value}, position_{position}
    {
    }
 
    DefineStatement(std::string name, std::string value, SourcePosition position)
        : name_{std::move(name)}, value_{std::move(value)}, position_{position}
    {
    }
 
    DefineStatement(std::string name, SourcePosition position)
        : name_{std::move(name)}, value_{std::monostate{}}, position_{position}
    {
    }
 
    [[nodiscard]] const std::string &name() const
    {
        return name_;
    }
 
    [[nodiscard]] const DefineValue &value() const
    {
        return value_;
    }
 
    [[nodiscard]] const SourcePosition &position() const
    {
        return position_;
    }
 
    [[nodiscard]] bool has_int_value() const
    {
        return std::holds_alternative<std::int64_t>(value_);
    }
 
    [[nodiscard]] bool has_string_value() const
    {
        return std::holds_alternative<std::string>(value_);
    }
 
    [[nodiscard]] bool is_flag() const
    {
        return std::holds_alternative<std::monostate>(value_);
    }
 
    [[nodiscard]] std::int64_t int_value() const
    {
        assert_or_panic(has_int_value(), "int_value() called on non-integer define");
        return std::get<std::int64_t>(value_);
    }
 
    [[nodiscard]] const std::string &string_value() const
    {
        assert_or_panic(has_string_value(), "string_value() called on non-string define");
        return std::get<std::string>(value_);
    }
 
  private:
    std::string name_;
    DefineValue value_;
    SourcePosition position_;
};
 
} // namespace porytiles