public:

struct Constant;

class ConstantId final {

public:

ConstantId() = delete;

ConstantId(const ConstantId&) = default;

ConstantId(ConstantId&&) = default;

ConstantId& operator=(const ConstantId&) = default;

ConstantId& operator=(ConstantId&&) = default;

std::string DebugString() const;

friend bool operator==(const ConstantId& lhs, const ConstantId& rhs) {

return lhs.data_ == rhs.data_;

}

friend bool operator<(const ConstantId& lhs, const ConstantId& rhs);

template <typename H>

friend H AbslHashValue(H state, const ConstantId& id) {

return H::combine(std::move(state), id.data_);

}

template <typename S>

friend void AbslStringify(S& sink, const ConstantId& id) {

sink.Append(id.DebugString());

}

private:

friend class EnumType;

friend class EnumValue;

explicit ConstantId(absl::string_view name)

: data_(absl::in_place_type<absl::string_view>, name) {}

explicit ConstantId(int64_t number)

: data_(absl::in_place_type<int64_t>, number) {}

absl::variant<absl::string_view, int64_t> data_;

};

static constexpr Kind kKind = Kind::kEnum;

using Type::Is;

static bool Is(const Type& type) { return type.kind() == kKind; }

static const EnumType& Cast(const Type& type) {

ABSL_DCHECK(Is(type)) << "cannot cast " << type.name() << " to enum";

return static_cast<const EnumType&>(type);

}

Kind kind() const { return kKind; }

virtual absl::string_view name() const ABSL_ATTRIBUTE_LIFETIME_BOUND = 0;

std::string DebugString() const { return std::string(name()); }

virtual size_t constant_count() const = 0;

// Find the constant definition for the given identifier. If the constant does

// not exist, an OK status and empty optional is returned. If the constant

// exists, an OK status and the constant is returned. Otherwise an error is

// returned.

absl::StatusOr<absl::optional<Constant>> FindConstant(ConstantId id) const

ABSL_ATTRIBUTE_LIFETIME_BOUND;

// Called by FindConstant.

virtual absl::StatusOr<absl::optional<Constant>> FindConstantByName(

absl::string_view name) const ABSL_ATTRIBUTE_LIFETIME_BOUND = 0;

// Called by FindConstant.

virtual absl::StatusOr<absl::optional<Constant>> FindConstantByNumber(

int64_t number) const ABSL_ATTRIBUTE_LIFETIME_BOUND = 0;

class ConstantIterator;

// Returns an iterator which can iterate over all the constants defined by

// this enumeration. The order with which iteration occurs is undefined.

virtual absl::StatusOr<UniqueRef<ConstantIterator>> NewConstantIterator(

MemoryManager& memory_manager) const ABSL_ATTRIBUTE_LIFETIME_BOUND = 0;

protected:

static ConstantId MakeConstantId(absl::string_view name) {

return ConstantId(name);

}

static ConstantId MakeConstantId(int64_t number) {

return ConstantId(number);

}

template <typename E>

static std::enable_if_t<

std::conjunction_v<

std::is_enum<E>,

std::is_convertible<std::underlying_type_t<E>, int64_t>>,

ConstantId>

MakeConstantId(E e) {

return MakeConstantId(

static_cast<int64_t>(static_cast<std::underlying_type_t<E>>(e)));

}

EnumType();

private:

friend internal::TypeInfo base_internal::GetEnumTypeTypeId(

const EnumType& enum_type);

struct NewInstanceVisitor;

struct FindConstantVisitor;

friend struct NewInstanceVisitor;

friend struct FindConstantVisitor;

friend class MemoryManager;

friend class EnumValue;

friend class TypeFactory;

friend class base_internal::TypeHandle;

EnumType(const EnumType&) = delete;

EnumType(EnumType&&) = delete;

// Called by CEL_IMPLEMENT_ENUM_TYPE() and Is() to perform type checking.

virtual internal::TypeInfo TypeId() const = 0;