1 //===--- StringSwitch.h - Switch-on-literal-string Construct --------------===/
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //===----------------------------------------------------------------------===/
8 //
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 <cassert>
18 #include <cstring>
19 
20 namespace llvm {
21 
22 /// \brief A switch()-like statement whose cases are string literals.
23 ///
24 /// The StringSwitch class is a simple form of a switch() statement that
25 /// determines whether the given string matches one of the given string
26 /// literals. The template type parameter \p T is the type of the value that
27 /// will be returned from the string-switch expression. For example,
28 /// the following code switches on the name of a color in \c argv[i]:
29 ///
30 /// \code
31 /// Color color = StringSwitch<Color>(argv[i])
32 ///   .Case("red", Red)
33 ///   .Case("orange", Orange)
34 ///   .Case("yellow", Yellow)
35 ///   .Case("green", Green)
36 ///   .Case("blue", Blue)
37 ///   .Case("indigo", Indigo)
38 ///   .Cases("violet", "purple", Violet)
39 ///   .Default(UnknownColor);
40 /// \endcode
41 template<typename T, typename R = T>
42 class StringSwitch {
43   /// \brief The string we are matching.
44   StringRef Str;
45 
46   /// \brief The pointer to the result of this switch statement, once known,
47   /// null before that.
48   const T *Result;
49 
50 public:
StringSwitch(StringRef S)51   explicit StringSwitch(StringRef S)
52   : Str(S), Result(nullptr) { }
53 
54   template<unsigned N>
Case(const char (& S)[N],const T & Value)55   StringSwitch& Case(const char (&S)[N], const T& Value) {
56     if (!Result && N-1 == Str.size() &&
57         (std::memcmp(S, Str.data(), N-1) == 0)) {
58       Result = &Value;
59     }
60 
61     return *this;
62   }
63 
64   template<unsigned N>
EndsWith(const char (& S)[N],const T & Value)65   StringSwitch& EndsWith(const char (&S)[N], const T &Value) {
66     if (!Result && Str.size() >= N-1 &&
67         std::memcmp(S, Str.data() + Str.size() + 1 - N, N-1) == 0) {
68       Result = &Value;
69     }
70 
71     return *this;
72   }
73 
74   template<unsigned N>
StartsWith(const char (& S)[N],const T & Value)75   StringSwitch& StartsWith(const char (&S)[N], const T &Value) {
76     if (!Result && Str.size() >= N-1 &&
77         std::memcmp(S, Str.data(), N-1) == 0) {
78       Result = &Value;
79     }
80 
81     return *this;
82   }
83 
84   template<unsigned N0, unsigned N1>
Cases(const char (& S0)[N0],const char (& S1)[N1],const T & Value)85   StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
86                       const T& Value) {
87     return Case(S0, Value).Case(S1, Value);
88   }
89 
90   template<unsigned N0, unsigned N1, unsigned N2>
Cases(const char (& S0)[N0],const char (& S1)[N1],const char (& S2)[N2],const T & Value)91   StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
92                       const char (&S2)[N2], const T& Value) {
93     return Case(S0, Value).Case(S1, Value).Case(S2, Value);
94   }
95 
96   template<unsigned N0, unsigned N1, unsigned N2, unsigned N3>
Cases(const char (& S0)[N0],const char (& S1)[N1],const char (& S2)[N2],const char (& S3)[N3],const T & Value)97   StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
98                       const char (&S2)[N2], const char (&S3)[N3],
99                       const T& Value) {
100     return Case(S0, Value).Case(S1, Value).Case(S2, Value).Case(S3, Value);
101   }
102 
103   template<unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4>
Cases(const char (& S0)[N0],const char (& S1)[N1],const char (& S2)[N2],const char (& S3)[N3],const char (& S4)[N4],const T & Value)104   StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
105                       const char (&S2)[N2], const char (&S3)[N3],
106                       const char (&S4)[N4], const T& Value) {
107     return Case(S0, Value).Case(S1, Value).Case(S2, Value).Case(S3, Value)
108       .Case(S4, Value);
109   }
110 
Default(const T & Value)111   R Default(const T& Value) const {
112     if (Result)
113       return *Result;
114 
115     return Value;
116   }
117 
R()118   operator R() const {
119     assert(Result && "Fell off the end of a string-switch");
120     return *Result;
121   }
122 };
123 
124 } // end namespace llvm
125 
126 #endif // LLVM_ADT_STRINGSWITCH_H
127