Add StringSwitch::Cases functions that takes 6, 7 or 8 arguments.

[ruiu]

Summary

I wanted a Cases function that takes 6 parameters, so I added a few more.

[ruiu]

• Update as per Zach's comment.

[davide]

I ended up in a situation where I needed 11 arguments (if you want a similar example, just grep for StringSwitch<bool> in MC).
I think the proposed solution was OK'ish up to 10 arguments, but adding more might be not ideal. So, now that we live in a post C++98 world, what do you think about switching this class to use variadic templating? I'm going to implement such a solution if nobody has objections. (cc: @dblaikie for thoughts)

[davide]

In D24882#859796, @davide wrote:

I ended up in a situation where I needed 11 arguments (if you want a similar example, just grep for StringSwitch<bool> in MC).
I think the proposed solution was OK'ish up to 10 arguments, but adding more might be not ideal. So, now that we live in a post C++98 world, what do you think about switching this class to use variadic templating? I'm going to implement such a solution if nobody has objections. (cc: @dblaikie for thoughts)

See also https://reviews.llvm.org/D37420

[zturner]

Seems fine to me.

[ruiu]

IIRC, it is tricky to use a template because all but the last parameter are of the same in Cases. If it takes Value as the first parameter, it would have been easier to use a template. But I'm not a C++ expert, so there may be a straightforward way of doing it.

include/llvm/ADT/StringSwitch.h

public:
 
   template<unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch& Case(const char (&S)[N], const T& Value) {
     if (!Result && N-1 == Str.size() &&
         (std::memcmp(S, Str.data(), N-1) == 0)) {
       Result = &Value;
     }
-
     return *this;
   }
 
   template<unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch& EndsWith(const char (&S)[N], const T &Value) {
     if (!Result && Str.size() >= N-1 &&
         std::memcmp(S, Str.data() + Str.size() + 1 - N, N-1) == 0) {
       Result = &Value;
     }
-
     return *this;
   }
 
   template<unsigned N>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch& StartsWith(const char (&S)[N], const T &Value) {
     if (!Result && Str.size() >= N-1 &&
         std::memcmp(S, Str.data(), N-1) == 0) {
       Result = &Value;
     }
-
     return *this;
   }
 
   template<unsigned N0, unsigned N1>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
                       const T& Value) {
     if (!Result && (
         (N0-1 == Str.size() && std::memcmp(S0, Str.data(), N0-1) == 0) ||
         (N1-1 == Str.size() && std::memcmp(S1, Str.data(), N1-1) == 0))) {
       Result = &Value;
     }
-
     return *this;
   }
 
   template<unsigned N0, unsigned N1, unsigned N2>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
                       const char (&S2)[N2], const T& Value) {
     if (!Result && (
         (N0-1 == Str.size() && std::memcmp(S0, Str.data(), N0-1) == 0) ||
         (N1-1 == Str.size() && std::memcmp(S1, Str.data(), N1-1) == 0) ||
         (N2-1 == Str.size() && std::memcmp(S2, Str.data(), N2-1) == 0))) {
       Result = &Value;
     }
-
     return *this;
   }
 
   template<unsigned N0, unsigned N1, unsigned N2, unsigned N3>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
                       const char (&S2)[N2], const char (&S3)[N3],
                       const T& Value) {
     if (!Result && (
         (N0-1 == Str.size() && std::memcmp(S0, Str.data(), N0-1) == 0) ||
         (N1-1 == Str.size() && std::memcmp(S1, Str.data(), N1-1) == 0) ||
         (N2-1 == Str.size() && std::memcmp(S2, Str.data(), N2-1) == 0) ||
         (N3-1 == Str.size() && std::memcmp(S3, Str.data(), N3-1) == 0))) {
       Result = &Value;
     }
-
     return *this;
   }
 
   template<unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4>
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
                       const char (&S2)[N2], const char (&S3)[N3],
                       const char (&S4)[N4], const T& Value) {
     if (!Result && (
         (N0-1 == Str.size() && std::memcmp(S0, Str.data(), N0-1) == 0) ||
         (N1-1 == Str.size() && std::memcmp(S1, Str.data(), N1-1) == 0) ||
         (N2-1 == Str.size() && std::memcmp(S2, Str.data(), N2-1) == 0) ||
         (N3-1 == Str.size() && std::memcmp(S3, Str.data(), N3-1) == 0) ||
         (N4-1 == Str.size() && std::memcmp(S4, Str.data(), N4-1) == 0))) {
       Result = &Value;
     }
+    return *this;
+  }
 
+  template<unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+           unsigned N5>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
+                      const char (&S2)[N2], const char (&S3)[N3],
+                      const char (&S4)[N4], const char (&S5)[N5],
+                      const T& Value) {
+    if (!Result && (
+        (N0-1 == Str.size() && std::memcmp(S0, Str.data(), N0-1) == 0) ||
+        (N1-1 == Str.size() && std::memcmp(S1, Str.data(), N1-1) == 0) ||
+        (N2-1 == Str.size() && std::memcmp(S2, Str.data(), N2-1) == 0) ||
+        (N3-1 == Str.size() && std::memcmp(S3, Str.data(), N3-1) == 0) ||
+        (N4-1 == Str.size() && std::memcmp(S4, Str.data(), N4-1) == 0) ||
+        (N5-1 == Str.size() && std::memcmp(S5, Str.data(), N5-1) == 0))) {
+      Result = &Value;
+    }
+    return *this;
+  }
+
+  template<unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+           unsigned N5, unsigned N6>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
+                      const char (&S2)[N2], const char (&S3)[N3],
+                      const char (&S4)[N4], const char (&S5)[N5],
+                      const char (&S6)[N6], const T& Value) {
+    if (!Result && (
+        (N0-1 == Str.size() && std::memcmp(S0, Str.data(), N0-1) == 0) ||
+        (N1-1 == Str.size() && std::memcmp(S1, Str.data(), N1-1) == 0) ||
+        (N2-1 == Str.size() && std::memcmp(S2, Str.data(), N2-1) == 0) ||
+        (N3-1 == Str.size() && std::memcmp(S3, Str.data(), N3-1) == 0) ||
+        (N4-1 == Str.size() && std::memcmp(S4, Str.data(), N4-1) == 0) ||
+        (N5-1 == Str.size() && std::memcmp(S5, Str.data(), N5-1) == 0) ||
+        (N6-1 == Str.size() && std::memcmp(S6, Str.data(), N6-1) == 0))) {
+      Result = &Value;
+    }
+    return *this;
+  }
+
+  template<unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
+           unsigned N5, unsigned N6, unsigned N7>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1],
+                      const char (&S2)[N2], const char (&S3)[N3],
+                      const char (&S4)[N4], const char (&S5)[N5],
+                      const char (&S6)[N6], const char (&S7)[N7],
+                      const T& Value) {
+    if (!Result && (
+        (N0-1 == Str.size() && std::memcmp(S0, Str.data(), N0-1) == 0) ||
+        (N1-1 == Str.size() && std::memcmp(S1, Str.data(), N1-1) == 0) ||
+        (N2-1 == Str.size() && std::memcmp(S2, Str.data(), N2-1) == 0) ||
+        (N3-1 == Str.size() && std::memcmp(S3, Str.data(), N3-1) == 0) ||
+        (N4-1 == Str.size() && std::memcmp(S4, Str.data(), N4-1) == 0) ||
+        (N5-1 == Str.size() && std::memcmp(S5, Str.data(), N5-1) == 0) ||
+        (N6-1 == Str.size() && std::memcmp(S6, Str.data(), N6-1) == 0) ||
+        (N7-1 == Str.size() && std::memcmp(S7, Str.data(), N7-1) == 0))) {
+      Result = &Value;
+    }
     return *this;
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   R Default(const T& Value) const {
     if (Result)
       return *Result;
-
     return Value;
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   operator R() const {
     assert(Result && "Fell off the end of a string-switch");
     return *Result;
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_STRINGSWITCH_H