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