TestOpEnums.h.inc | Explore in Territory

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

// Multi-result op kinds
enum class MultiResultOpEnum : uint64_t { … };

::std::optional<MultiResultOpEnum> symbolizeMultiResultOpEnum(uint64_t);
::llvm::StringRef stringifyMultiResultOpEnum(MultiResultOpEnum);
::std::optional<MultiResultOpEnum> symbolizeMultiResultOpEnum(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForMultiResultOpEnum() { … }


inline ::llvm::StringRef stringifyEnum(MultiResultOpEnum enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<MultiResultOpEnum> symbolizeEnum<MultiResultOpEnum>(::llvm::StringRef str) { … }

class MultiResultOpEnumAttr : public ::mlir::IntegerAttr { … };

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::MultiResultOpEnum, ::MultiResultOpEnum> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::MultiResultOpEnum value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::MultiResultOpEnum> { … };
}

// allowed 32-bit signless integer cases: 5, 10
enum class SomeI32Enum : uint32_t { … };

::std::optional<SomeI32Enum> symbolizeSomeI32Enum(uint32_t);
::llvm::StringRef stringifySomeI32Enum(SomeI32Enum);
::std::optional<SomeI32Enum> symbolizeSomeI32Enum(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForSomeI32Enum() { … }


inline ::llvm::StringRef stringifyEnum(SomeI32Enum enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<SomeI32Enum> symbolizeEnum<SomeI32Enum>(::llvm::StringRef str) { … }

class SomeI32EnumAttr : public ::mlir::IntegerAttr { … };

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::SomeI32Enum, ::SomeI32Enum> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::SomeI32Enum value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::SomeI32Enum> { … };
}

// allowed 64-bit signless integer cases: 5, 10
enum class SomeI64Enum : uint64_t { … };

::std::optional<SomeI64Enum> symbolizeSomeI64Enum(uint64_t);
::llvm::StringRef stringifySomeI64Enum(SomeI64Enum);
::std::optional<SomeI64Enum> symbolizeSomeI64Enum(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForSomeI64Enum() { … }


inline ::llvm::StringRef stringifyEnum(SomeI64Enum enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<SomeI64Enum> symbolizeEnum<SomeI64Enum>(::llvm::StringRef str) { … }

class SomeI64EnumAttr : public ::mlir::IntegerAttr { … };

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::SomeI64Enum, ::SomeI64Enum> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::SomeI64Enum value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::SomeI64Enum> { … };
}

namespace test {
// a test bit enum
enum class TestBitEnum : uint32_t { … };

::std::optional<TestBitEnum> symbolizeTestBitEnum(uint32_t);
std::string stringifyTestBitEnum(TestBitEnum);
::std::optional<TestBitEnum> symbolizeTestBitEnum(::llvm::StringRef);

inline constexpr TestBitEnum operator|(TestBitEnum a, TestBitEnum b) { … }
inline constexpr TestBitEnum operator&(TestBitEnum a, TestBitEnum b) { … }
inline constexpr TestBitEnum operator^(TestBitEnum a, TestBitEnum b) { … }
inline constexpr TestBitEnum operator~(TestBitEnum bits) { … }
inline constexpr bool bitEnumContainsAll(TestBitEnum bits, TestBitEnum bit) { … }
inline constexpr bool bitEnumContainsAny(TestBitEnum bits, TestBitEnum bit) { … }
inline constexpr TestBitEnum bitEnumClear(TestBitEnum bits, TestBitEnum bit) { … }
inline constexpr TestBitEnum bitEnumSet(TestBitEnum bits, TestBitEnum bit, /*optional*/bool value=true) { … }
  
inline std::string stringifyEnum(TestBitEnum enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<TestBitEnum> symbolizeEnum<TestBitEnum>(::llvm::StringRef str) { … }
} // namespace test

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<test::TestBitEnum, test::TestBitEnum> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, test::TestBitEnum value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<test::TestBitEnum> { … };
}

namespace test {
// another test bit enum
enum class TestBitEnumVerticalBar : uint32_t { … };

::std::optional<TestBitEnumVerticalBar> symbolizeTestBitEnumVerticalBar(uint32_t);
std::string stringifyTestBitEnumVerticalBar(TestBitEnumVerticalBar);
::std::optional<TestBitEnumVerticalBar> symbolizeTestBitEnumVerticalBar(::llvm::StringRef);

inline constexpr TestBitEnumVerticalBar operator|(TestBitEnumVerticalBar a, TestBitEnumVerticalBar b) { … }
inline constexpr TestBitEnumVerticalBar operator&(TestBitEnumVerticalBar a, TestBitEnumVerticalBar b) { … }
inline constexpr TestBitEnumVerticalBar operator^(TestBitEnumVerticalBar a, TestBitEnumVerticalBar b) { … }
inline constexpr TestBitEnumVerticalBar operator~(TestBitEnumVerticalBar bits) { … }
inline constexpr bool bitEnumContainsAll(TestBitEnumVerticalBar bits, TestBitEnumVerticalBar bit) { … }
inline constexpr bool bitEnumContainsAny(TestBitEnumVerticalBar bits, TestBitEnumVerticalBar bit) { … }
inline constexpr TestBitEnumVerticalBar bitEnumClear(TestBitEnumVerticalBar bits, TestBitEnumVerticalBar bit) { … }
inline constexpr TestBitEnumVerticalBar bitEnumSet(TestBitEnumVerticalBar bits, TestBitEnumVerticalBar bit, /*optional*/bool value=true) { … }
  
inline std::string stringifyEnum(TestBitEnumVerticalBar enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<TestBitEnumVerticalBar> symbolizeEnum<TestBitEnumVerticalBar>(::llvm::StringRef str) { … }
} // namespace test

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<test::TestBitEnumVerticalBar, test::TestBitEnumVerticalBar> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, test::TestBitEnumVerticalBar value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<test::TestBitEnumVerticalBar> { … };
}

namespace test {
// a test enum
enum class TestEnum : uint32_t { … };

::std::optional<TestEnum> symbolizeTestEnum(uint32_t);
::llvm::StringRef stringifyTestEnum(TestEnum);
::std::optional<TestEnum> symbolizeTestEnum(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForTestEnum() { … }


inline ::llvm::StringRef stringifyEnum(TestEnum enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<TestEnum> symbolizeEnum<TestEnum>(::llvm::StringRef str) { … }
} // namespace test

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<test::TestEnum, test::TestEnum> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, test::TestEnum value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<test::TestEnum> { … };
}

namespace test {
// allowed 32-bit signless integer cases: 0, 1
enum class SimpleEnum : uint32_t { … };

::std::optional<SimpleEnum> symbolizeSimpleEnum(uint32_t);
::llvm::StringRef stringifySimpleEnum(SimpleEnum);
::std::optional<SimpleEnum> symbolizeSimpleEnum(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForSimpleEnum() { … }


inline ::llvm::StringRef stringifyEnum(SimpleEnum enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<SimpleEnum> symbolizeEnum<SimpleEnum>(::llvm::StringRef str) { … }
} // namespace test

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::test::SimpleEnum, ::test::SimpleEnum> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::test::SimpleEnum value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::test::SimpleEnum> { … };
}
llvm/tools/mlir/test/lib/Dialect/Test/TestOpEnums.h.inc
