llvm/tools/mlir/unittests/TableGen/EnumsGenTest.cpp.inc

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Enum Utility Definitions                                                   *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: enums.td                                                             *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

std::string stringifyBitEnum64_Test(BitEnum64_Test symbol) { … }

::std::optional<BitEnum64_Test> symbolizeBitEnum64_Test(::llvm::StringRef str) { … }

::std::optional<BitEnum64_Test> symbolizeBitEnum64_Test(uint64_t value) { … }
bool BitEnum64_TestAttr::classof(::mlir::Attribute attr) { … }
BitEnum64_TestAttr BitEnum64_TestAttr::get(::mlir::MLIRContext *context, BitEnum64_Test val) { … }
BitEnum64_Test BitEnum64_TestAttr::getValue() const { … }

std::string stringifyBitEnumPrimaryGroup(BitEnumPrimaryGroup symbol) { … }

::std::optional<BitEnumPrimaryGroup> symbolizeBitEnumPrimaryGroup(::llvm::StringRef str) { … }

::std::optional<BitEnumPrimaryGroup> symbolizeBitEnumPrimaryGroup(uint32_t value) { … }
bool BitEnumPrimaryGroupAttr::classof(::mlir::Attribute attr) { … }
BitEnumPrimaryGroupAttr BitEnumPrimaryGroupAttr::get(::mlir::MLIRContext *context, BitEnumPrimaryGroup val) { … }
BitEnumPrimaryGroup BitEnumPrimaryGroupAttr::getValue() const { … }

std::string stringifyBitEnumWithGroup(BitEnumWithGroup symbol) { … }

::std::optional<BitEnumWithGroup> symbolizeBitEnumWithGroup(::llvm::StringRef str) { … }

::std::optional<BitEnumWithGroup> symbolizeBitEnumWithGroup(uint32_t value) { … }
bool BitEnumWithGroupAttr::classof(::mlir::Attribute attr) { … }
BitEnumWithGroupAttr BitEnumWithGroupAttr::get(::mlir::MLIRContext *context, BitEnumWithGroup val) { … }
BitEnumWithGroup BitEnumWithGroupAttr::getValue() const { … }

std::string stringifyBitEnumWithNone(BitEnumWithNone symbol) { … }

::std::optional<BitEnumWithNone> symbolizeBitEnumWithNone(::llvm::StringRef str) { … }

::std::optional<BitEnumWithNone> symbolizeBitEnumWithNone(uint32_t value) { … }
bool BitEnumWithNoneAttr::classof(::mlir::Attribute attr) { … }
BitEnumWithNoneAttr BitEnumWithNoneAttr::get(::mlir::MLIRContext *context, BitEnumWithNone val) { … }
BitEnumWithNone BitEnumWithNoneAttr::getValue() const { … }

std::string stringifyBitEnumWithoutNone(BitEnumWithoutNone symbol) { … }

::std::optional<BitEnumWithoutNone> symbolizeBitEnumWithoutNone(::llvm::StringRef str) { … }

::std::optional<BitEnumWithoutNone> symbolizeBitEnumWithoutNone(uint32_t value) { … }
bool BitEnumWithoutNoneAttr::classof(::mlir::Attribute attr) { … }
BitEnumWithoutNoneAttr BitEnumWithoutNoneAttr::get(::mlir::MLIRContext *context, BitEnumWithoutNone val) { … }
BitEnumWithoutNone BitEnumWithoutNoneAttr::getValue() const { … }

namespace Outer {
namespace Inner {
::llvm::StringRef ConvertToString(FooEnum val) { … }

::std::optional<FooEnum> ConvertToEnum(::llvm::StringRef str) { … }
::std::optional<FooEnum> symbolizeFooEnum(uint32_t value) { … }

bool FooEnumAttr::classof(::mlir::Attribute attr) { … }
FooEnumAttr FooEnumAttr::get(::mlir::MLIRContext *context, FooEnum val) { … }
FooEnum FooEnumAttr::getValue() const { … }
} // namespace Inner
} // namespace Outer

::llvm::StringRef stringifyI32Enum(I32Enum val) { … }

::std::optional<I32Enum> symbolizeI32Enum(::llvm::StringRef str) { … }
::std::optional<I32Enum> symbolizeI32Enum(uint32_t value) { … }

bool I32EnumAttr::classof(::mlir::Attribute attr) { … }
I32EnumAttr I32EnumAttr::get(::mlir::MLIRContext *context, I32Enum val) { … }
I32Enum I32EnumAttr::getValue() const { … }

::llvm::StringRef stringifyPrettyIntEnum(PrettyIntEnum val) { … }

::std::optional<PrettyIntEnum> symbolizePrettyIntEnum(::llvm::StringRef str) { … }
::std::optional<PrettyIntEnum> symbolizePrettyIntEnum(uint32_t value) { … }

bool PrettyIntEnumAttr::classof(::mlir::Attribute attr) { … }
PrettyIntEnumAttr PrettyIntEnumAttr::get(::mlir::MLIRContext *context, PrettyIntEnum val) { … }
PrettyIntEnum PrettyIntEnumAttr::getValue() const { … }