1//===--- Variantvalue.cpp -------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//
10//===----------------------------------------------------------------------===//
11
12#include "mlir/Query/Matcher/VariantValue.h"
13
14namespace mlir::query::matcher {
15
16VariantMatcher::Payload::~Payload() = default;
17
18class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
19public:
20 explicit SinglePayload(DynMatcher matcher) : matcher(std::move(matcher)) {}
21
22 std::optional<DynMatcher> getDynMatcher() const override { return matcher; }
23
24 std::string getTypeAsString() const override { return "Matcher"; }
25
26private:
27 DynMatcher matcher;
28};
29
30VariantMatcher::VariantMatcher() = default;
31
32VariantMatcher VariantMatcher::SingleMatcher(DynMatcher matcher) {
33 return VariantMatcher(std::make_shared<SinglePayload>(args: std::move(matcher)));
34}
35
36std::optional<DynMatcher> VariantMatcher::getDynMatcher() const {
37 return value ? value->getDynMatcher() : std::nullopt;
38}
39
40void VariantMatcher::reset() { value.reset(); }
41
42std::string VariantMatcher::getTypeAsString() const { return "<Nothing>"; }
43
44VariantValue::VariantValue(const VariantValue &other)
45 : type(ValueType::Nothing) {
46 *this = other;
47}
48
49VariantValue::VariantValue(const llvm::StringRef string)
50 : type(ValueType::String) {
51 value.String = new llvm::StringRef(string);
52}
53
54VariantValue::VariantValue(const VariantMatcher &matcher)
55 : type(ValueType::Matcher) {
56 value.Matcher = new VariantMatcher(matcher);
57}
58
59VariantValue::VariantValue(int64_t signedValue) : type(ValueType::Signed) {
60 value.Signed = signedValue;
61}
62
63VariantValue::VariantValue(bool setBoolean) : type(ValueType::Boolean) {
64 value.Boolean = setBoolean;
65}
66
67VariantValue::~VariantValue() { reset(); }
68
69VariantValue &VariantValue::operator=(const VariantValue &other) {
70 if (this == &other)
71 return *this;
72 reset();
73 switch (other.type) {
74 case ValueType::String:
75 setString(other.getString());
76 break;
77 case ValueType::Matcher:
78 setMatcher(other.getMatcher());
79 break;
80 case ValueType::Signed:
81 setSigned(other.getSigned());
82 break;
83 case ValueType::Boolean:
84 setBoolean(other.getBoolean());
85 break;
86 case ValueType::Nothing:
87 type = ValueType::Nothing;
88 break;
89 }
90 return *this;
91}
92
93void VariantValue::reset() {
94 switch (type) {
95 case ValueType::String:
96 delete value.String;
97 break;
98 case ValueType::Matcher:
99 delete value.Matcher;
100 break;
101 // Cases that do nothing.
102 case ValueType::Signed:
103 case ValueType::Boolean:
104 case ValueType::Nothing:
105 break;
106 }
107 type = ValueType::Nothing;
108}
109
110// Signed
111bool VariantValue::isSigned() const { return type == ValueType::Signed; }
112
113int64_t VariantValue::getSigned() const { return value.Signed; }
114
115void VariantValue::setSigned(int64_t newValue) {
116 type = ValueType::Signed;
117 value.Signed = newValue;
118}
119
120// Boolean
121bool VariantValue::isBoolean() const { return type == ValueType::Boolean; }
122
123bool VariantValue::getBoolean() const { return value.Signed; }
124
125void VariantValue::setBoolean(bool newValue) {
126 type = ValueType::Boolean;
127 value.Signed = newValue;
128}
129
130bool VariantValue::isString() const { return type == ValueType::String; }
131
132const llvm::StringRef &VariantValue::getString() const {
133 assert(isString());
134 return *value.String;
135}
136
137void VariantValue::setString(const llvm::StringRef &newValue) {
138 reset();
139 type = ValueType::String;
140 value.String = new llvm::StringRef(newValue);
141}
142
143bool VariantValue::isMatcher() const { return type == ValueType::Matcher; }
144
145const VariantMatcher &VariantValue::getMatcher() const {
146 assert(isMatcher());
147 return *value.Matcher;
148}
149
150void VariantValue::setMatcher(const VariantMatcher &newValue) {
151 reset();
152 type = ValueType::Matcher;
153 value.Matcher = new VariantMatcher(newValue);
154}
155
156std::string VariantValue::getTypeAsString() const {
157 switch (type) {
158 case ValueType::String:
159 return "String";
160 case ValueType::Matcher:
161 return "Matcher";
162 case ValueType::Signed:
163 return "Signed";
164 case ValueType::Boolean:
165 return "Boolean";
166 case ValueType::Nothing:
167 return "Nothing";
168 }
169 llvm_unreachable("Invalid Type");
170}
171
172} // namespace mlir::query::matcher
173

source code of mlir/lib/Query/Matcher/VariantValue.cpp