Movatterモバイル変換

[0]ホーム
URL:

LLVM 20.0.0git
StringSwitch.h
Go to the documentation of this file.
1//===--- StringSwitch.h - Switch-on-literal-string Construct --------------===/
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/// \file
9/// This file implements the StringSwitch template, which mimics a switch()
10/// statement whose cases are string literals.
11///
12//===----------------------------------------------------------------------===/
13#ifndef LLVM_ADT_STRINGSWITCH_H
14#define LLVM_ADT_STRINGSWITCH_H
15
16#include "llvm/ADT/StringRef.h"
17#include "llvm/Support/Compiler.h"
18#include <cassert>
19#include <cstring>
20#include <optional>
21
22namespacellvm {
23
24/// A switch()-like statement whose cases are string literals.
25///
26/// The StringSwitch class is a simple form of a switch() statement that
27/// determines whether the given string matches one of the given string
28/// literals. The template type parameter \p T is the type of the value that
29/// will be returned from the string-switch expression. For example,
30/// the following code switches on the name of a color in \c argv[i]:
31///
32/// \code
33/// Color color = StringSwitch<Color>(argv[i])
34/// .Case("red", Red)
35/// .Case("orange", Orange)
36/// .Case("yellow", Yellow)
37/// .Case("green", Green)
38/// .Case("blue", Blue)
39/// .Case("indigo", Indigo)
40/// .Cases("violet", "purple", Violet)
41/// .Default(UnknownColor);
42/// \endcode
43template<typename T,typename R = T>
44classStringSwitch {
45 /// The string we are matching.
46constStringRef Str;
47
48 /// The pointer to the result of this switch statement, once known,
49 /// null before that.
50 std::optional<T> Result;
51
52public:
53explicitStringSwitch(StringRef S)
54 : Str(S), Result() { }
55
56// StringSwitch is not copyable.
57StringSwitch(constStringSwitch &) =delete;
58
59// StringSwitch is not assignable due to 'Str' being 'const'.
60voidoperator=(constStringSwitch &) =delete;
61voidoperator=(StringSwitch &&other) =delete;
62
63StringSwitch(StringSwitch &&other)
64 : Str(other.Str), Result(std::move(other.Result)) { }
65
66~StringSwitch() =default;
67
68// Case-sensitive case matchers
69StringSwitch &Case(StringLiteral S,TValue) {
70if (!Result && Str == S) {
71 Result = std::move(Value);
72 }
73return *this;
74 }
75
76StringSwitch&EndsWith(StringLiteral S,TValue) {
77if (!Result && Str.ends_with(S)) {
78 Result = std::move(Value);
79 }
80return *this;
81 }
82
83StringSwitch&StartsWith(StringLiteral S,TValue) {
84if (!Result && Str.starts_with(S)) {
85 Result = std::move(Value);
86 }
87return *this;
88 }
89
90StringSwitch &Cases(StringLiteral S0,StringLiteralS1,TValue) {
91returnCase(S0,Value).Case(S1,Value);
92 }
93
94StringSwitch &Cases(StringLiteral S0,StringLiteralS1,StringLiteral S2,
95TValue) {
96returnCase(S0,Value).Cases(S1, S2,Value);
97 }
98
99StringSwitch &Cases(StringLiteral S0,StringLiteralS1,StringLiteral S2,
100StringLiteral S3,TValue) {
101returnCase(S0,Value).Cases(S1, S2, S3,Value);
102 }
103
104StringSwitch &Cases(StringLiteral S0,StringLiteralS1,StringLiteral S2,
105StringLiteral S3,StringLiteral S4,TValue) {
106returnCase(S0,Value).Cases(S1, S2, S3, S4,Value);
107 }
108
109StringSwitch &Cases(StringLiteral S0,StringLiteralS1,StringLiteral S2,
110StringLiteral S3,StringLiteral S4,StringLiteral S5,
111TValue) {
112returnCase(S0,Value).Cases(S1, S2, S3, S4, S5,Value);
113 }
114
115StringSwitch &Cases(StringLiteral S0,StringLiteralS1,StringLiteral S2,
116StringLiteral S3,StringLiteral S4,StringLiteral S5,
117StringLiteral S6,TValue) {
118returnCase(S0,Value).Cases(S1, S2, S3, S4, S5, S6,Value);
119 }
120
121StringSwitch &Cases(StringLiteral S0,StringLiteralS1,StringLiteral S2,
122StringLiteral S3,StringLiteral S4,StringLiteral S5,
123StringLiteral S6,StringLiteral S7,TValue) {
124returnCase(S0,Value).Cases(S1, S2, S3, S4, S5, S6, S7,Value);
125 }
126
127StringSwitch &Cases(StringLiteral S0,StringLiteralS1,StringLiteral S2,
128StringLiteral S3,StringLiteral S4,StringLiteral S5,
129StringLiteral S6,StringLiteral S7,StringLiteralS8,
130TValue) {
131returnCase(S0,Value).Cases(S1, S2, S3, S4, S5, S6, S7,S8,Value);
132 }
133
134StringSwitch &Cases(StringLiteral S0,StringLiteralS1,StringLiteral S2,
135StringLiteral S3,StringLiteral S4,StringLiteral S5,
136StringLiteral S6,StringLiteral S7,StringLiteralS8,
137StringLiteral S9,TValue) {
138returnCase(S0,Value).Cases(S1, S2, S3, S4, S5, S6, S7,S8, S9,Value);
139 }
140
141// Case-insensitive case matchers.
142StringSwitch &CaseLower(StringLiteral S,TValue) {
143if (!Result && Str.equals_insensitive(S))
144 Result = std::move(Value);
145
146return *this;
147 }
148
149StringSwitch &EndsWithLower(StringLiteral S,TValue) {
150if (!Result && Str.ends_with_insensitive(S))
151 Result =Value;
152
153return *this;
154 }
155
156StringSwitch &StartsWithLower(StringLiteral S,TValue) {
157if (!Result && Str.starts_with_insensitive(S))
158 Result = std::move(Value);
159
160return *this;
161 }
162
163StringSwitch &CasesLower(StringLiteral S0,StringLiteralS1,TValue) {
164returnCaseLower(S0,Value).CaseLower(S1,Value);
165 }
166
167StringSwitch &CasesLower(StringLiteral S0,StringLiteralS1,StringLiteral S2,
168TValue) {
169returnCaseLower(S0,Value).CasesLower(S1, S2,Value);
170 }
171
172StringSwitch &CasesLower(StringLiteral S0,StringLiteralS1,StringLiteral S2,
173StringLiteral S3,TValue) {
174returnCaseLower(S0,Value).CasesLower(S1, S2, S3,Value);
175 }
176
177StringSwitch &CasesLower(StringLiteral S0,StringLiteralS1,StringLiteral S2,
178StringLiteral S3,StringLiteral S4,TValue) {
179returnCaseLower(S0,Value).CasesLower(S1, S2, S3, S4,Value);
180 }
181
182 [[nodiscard]] RDefault(TValue) {
183if (Result)
184return std::move(*Result);
185returnValue;
186 }
187
188 [[nodiscard]]operator R() {
189assert(Result &&"Fell off the end of a string-switch");
190return std::move(*Result);
191 }
192};
193
194}// end namespace llvm
195
196#endif// LLVM_ADT_STRINGSWITCH_H
S1
static const LLT S1
Definition:AMDGPULegalizerInfo.cpp:282
S8
static const LLT S8
Definition:AMDGPULegalizerInfo.cpp:283
Compiler.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef.h
T
llvm::StringLiteral
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition:StringRef.h:853
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition:StringRef.h:51
llvm::StringSwitch
A switch()-like statement whose cases are string literals.
Definition:StringSwitch.h:44
llvm::StringSwitch::CasesLower
StringSwitch & CasesLower(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, T Value)
Definition:StringSwitch.h:177
llvm::StringSwitch::Cases
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, T Value)
Definition:StringSwitch.h:109
llvm::StringSwitch::EndsWithLower
StringSwitch & EndsWithLower(StringLiteral S, T Value)
Definition:StringSwitch.h:149
llvm::StringSwitch::StartsWithLower
StringSwitch & StartsWithLower(StringLiteral S, T Value)
Definition:StringSwitch.h:156
llvm::StringSwitch::CaseLower
StringSwitch & CaseLower(StringLiteral S, T Value)
Definition:StringSwitch.h:142
llvm::StringSwitch::Case
StringSwitch & Case(StringLiteral S, T Value)
Definition:StringSwitch.h:69
llvm::StringSwitch::CasesLower
StringSwitch & CasesLower(StringLiteral S0, StringLiteral S1, T Value)
Definition:StringSwitch.h:163
llvm::StringSwitch::Cases
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, T Value)
Definition:StringSwitch.h:104
llvm::StringSwitch::operator=
void operator=(const StringSwitch &)=delete
llvm::StringSwitch::CasesLower
StringSwitch & CasesLower(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, T Value)
Definition:StringSwitch.h:172
llvm::StringSwitch::Default
R Default(T Value)
Definition:StringSwitch.h:182
llvm::StringSwitch::StartsWith
StringSwitch & StartsWith(StringLiteral S, T Value)
Definition:StringSwitch.h:83
llvm::StringSwitch::Cases
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, StringLiteral S6, StringLiteral S7, StringLiteral S8, T Value)
Definition:StringSwitch.h:127
llvm::StringSwitch::Cases
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, T Value)
Definition:StringSwitch.h:90
llvm::StringSwitch::StringSwitch
StringSwitch(const StringSwitch &)=delete
llvm::StringSwitch::Cases
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, T Value)
Definition:StringSwitch.h:99
llvm::StringSwitch::EndsWith
StringSwitch & EndsWith(StringLiteral S, T Value)
Definition:StringSwitch.h:76
llvm::StringSwitch::Cases
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, StringLiteral S6, StringLiteral S7, T Value)
Definition:StringSwitch.h:121
llvm::StringSwitch::StringSwitch
StringSwitch(StringSwitch &&other)
Definition:StringSwitch.h:63
llvm::StringSwitch::operator=
void operator=(StringSwitch &&other)=delete
llvm::StringSwitch::Cases
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, StringLiteral S6, T Value)
Definition:StringSwitch.h:115
llvm::StringSwitch::Cases
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, T Value)
Definition:StringSwitch.h:94
llvm::StringSwitch::StringSwitch
StringSwitch(StringRef S)
Definition:StringSwitch.h:53
llvm::StringSwitch::Cases
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2, StringLiteral S3, StringLiteral S4, StringLiteral S5, StringLiteral S6, StringLiteral S7, StringLiteral S8, StringLiteral S9, T Value)
Definition:StringSwitch.h:134
llvm::StringSwitch::CasesLower
StringSwitch & CasesLower(StringLiteral S0, StringLiteral S1, StringLiteral S2, T Value)
Definition:StringSwitch.h:167
llvm::StringSwitch::~StringSwitch
~StringSwitch()=default
llvm::Value
LLVM Value Representation.
Definition:Value.h:74
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition:AddressRanges.h:18
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition:STLExtras.h:1873
std
Implement std::hash so that hash_code can be used in STL containers.
Definition:BitVector.h:858
Generated on Thu Jul 17 2025 08:16:36 for LLVM by doxygen 1.9.6
[8]ページ先頭
©2009-2025 Movatter.jp