Improve TypeSignature implementation

mapbox · Aug 22, 2018 · aa08c90 · aa08c90
1 parent ecf9550
commit aa08c90
Show file tree

Hide file tree

Showing 2 changed files with 84 additions and 55 deletions.
diff --git a/include/jni/type_signature.hpp b/include/jni/type_signature.hpp
@@ -4,63 +4,86 @@
 #include <jni/object.hpp>
 #include <jni/array.hpp>
 
-#include <initializer_list>
-#include <string>
-
 namespace jni
    {
+    template < char... chars >
+    struct StringLiteral
+       {
+        operator const char *() const
+           {
+            static const char result[] = { chars..., 0 };
+            return result;
+           }
+       };
+
+    constexpr std::size_t StringLiteralLength(const char * str, std::size_t len = 0)
+       {
+        return str[0] ? StringLiteralLength(str + 1, len + 1) : len;
+       }
+
+    template < class, class >
+    struct TagLiteralImpl;
+
+    template < class Tag, std::size_t... Is >
+    struct TagLiteralImpl< Tag, std::index_sequence<Is...> >
+       {
+        using Value = StringLiteral< Tag::Name()[Is]... >;
+       };
+
+    template < class Tag >
+    using TagLiteral = typename TagLiteralImpl< Tag, std::make_index_sequence<StringLiteralLength(Tag::Name())> >::Value;
+
+    template < char... As, char... Bs >
+    constexpr auto Concat(const StringLiteral<As...>&,
+                          const StringLiteral<Bs...>&)
+       {
+        return StringLiteral<As..., Bs...>();
+       }
+
+    template < class A, class B, class... Rest >
+    constexpr auto Concat(const A& a,
+                          const B& b,
+                          const Rest&... rest)
+       {
+        return Concat(Concat(a, b), rest...);
+       }
+
     template < class > struct TypeSignature;
 
-    template <> struct TypeSignature< jboolean > { const char * operator()() const { return "Z"; } };
-    template <> struct TypeSignature< jbyte    > { const char * operator()() const { return "B"; } };
-    template <> struct TypeSignature< jchar    > { const char * operator()() const { return "C"; } };
-    template <> struct TypeSignature< jshort   > { const char * operator()() const { return "S"; } };
-    template <> struct TypeSignature< jint     > { const char * operator()() const { return "I"; } };
-    template <> struct TypeSignature< jlong    > { const char * operator()() const { return "J"; } };
-    template <> struct TypeSignature< jfloat   > { const char * operator()() const { return "F"; } };
-    template <> struct TypeSignature< jdouble  > { const char * operator()() const { return "D"; } };
-    template <> struct TypeSignature< void     > { const char * operator()() const { return "V"; } };
+    template <> struct TypeSignature< jboolean > { constexpr auto operator()() const { return StringLiteral<'Z'>(); } };
+    template <> struct TypeSignature< jbyte    > { constexpr auto operator()() const { return StringLiteral<'B'>(); } };
+    template <> struct TypeSignature< jchar    > { constexpr auto operator()() const { return StringLiteral<'C'>(); } };
+    template <> struct TypeSignature< jshort   > { constexpr auto operator()() const { return StringLiteral<'S'>(); } };
+    template <> struct TypeSignature< jint     > { constexpr auto operator()() const { return StringLiteral<'I'>(); } };
+    template <> struct TypeSignature< jlong    > { constexpr auto operator()() const { return StringLiteral<'J'>(); } };
+    template <> struct TypeSignature< jfloat   > { constexpr auto operator()() const { return StringLiteral<'F'>(); } };
+    template <> struct TypeSignature< jdouble  > { constexpr auto operator()() const { return StringLiteral<'D'>(); } };
+    template <> struct TypeSignature< void     > { constexpr auto operator()() const { return StringLiteral<'V'>(); } };
 
     template < class TheTag >
     struct TypeSignature< Object<TheTag> >
        {
-        const char * operator()() const
+        constexpr auto operator()() const
            {
-            static std::string value { std::string("L") + TheTag::Name() + ";" };
-            return value.c_str();
+            return Concat(StringLiteral<'L'>(), TagLiteral<TheTag>(), StringLiteral<';'>());
            }
        };
 
     template < class E >
     struct TypeSignature< Array<E> >
        {
-        const char * operator()() const
+        constexpr auto operator()() const
            {
-            static std::string value { std::string("[") + TypeSignature<E>()() };
-            return value.c_str();
+            return Concat(StringLiteral<'['>(), TypeSignature<E>()());
            }
        };
 
     template < class R, class... Args >
     struct TypeSignature< R (Args...) >
        {
-        private:
-            template < class T > void DoNothingWith(const std::initializer_list<T>&) const {}
-
-            std::string Compute() const
-               {
-                static std::string result("(");
-                DoNothingWith<int>( { ( result += TypeSignature<Args>()(), 0 )... } );
-                result += ")";
-                result += TypeSignature<R>()();
-                return result;
-               }
-
-        public:
-            const char * operator()() const
-               {
-                static std::string result = Compute();
-                return result.c_str();
-               }
+        constexpr auto operator()() const
+           {
+            return Concat(StringLiteral<'('>(), TypeSignature<Args>()()..., StringLiteral<')'>(), TypeSignature<R>()());
+           }
        };
    }
diff --git a/test/high_level.cpp b/test/high_level.cpp
@@ -26,34 +26,40 @@ namespace
     struct Derived : public Base {};
    }
 
+template < char... Cs >
+bool operator==(const jni::StringLiteral<Cs...>& a, const char * b)
+   {
+    return std::string(a) == std::string(b);
+   }
+
 int main()
    {
     /// TypeSignature
 
-    assert(jni::TypeSignature< jni::jboolean >()() == std::string("Z"));
-    assert(jni::TypeSignature< jni::jbyte    >()() == std::string("B"));
-    assert(jni::TypeSignature< jni::jchar    >()() == std::string("C"));
-    assert(jni::TypeSignature< jni::jshort   >()() == std::string("S"));
-    assert(jni::TypeSignature< jni::jint     >()() == std::string("I"));
-    assert(jni::TypeSignature< jni::jlong    >()() == std::string("J"));
-    assert(jni::TypeSignature< jni::jfloat   >()() == std::string("F"));
-    assert(jni::TypeSignature< jni::jdouble  >()() == std::string("D"));
-    assert(jni::TypeSignature< void          >()() == std::string("V"));
+    assert(jni::TypeSignature< jni::jboolean >()() == "Z");
+    assert(jni::TypeSignature< jni::jbyte    >()() == "B");
+    assert(jni::TypeSignature< jni::jchar    >()() == "C");
+    assert(jni::TypeSignature< jni::jshort   >()() == "S");
+    assert(jni::TypeSignature< jni::jint     >()() == "I");
+    assert(jni::TypeSignature< jni::jlong    >()() == "J");
+    assert(jni::TypeSignature< jni::jfloat   >()() == "F");
+    assert(jni::TypeSignature< jni::jdouble  >()() == "D");
+    assert(jni::TypeSignature< void          >()() == "V");
 
-    assert(jni::TypeSignature< jni::Object<>  >()() == std::string("Ljava/lang/Object;"));
-    assert(jni::TypeSignature< jni::String    >()() == std::string("Ljava/lang/String;"));
+    assert(jni::TypeSignature< jni::Object<>  >()() == "Ljava/lang/Object;");
+    assert(jni::TypeSignature< jni::String    >()() == "Ljava/lang/String;");
 
-    assert(jni::TypeSignature< jni::Array<jni::jboolean> >()() == std::string("[Z"));
-    assert(jni::TypeSignature< jni::Array<jni::String>   >()() == std::string("[Ljava/lang/String;"));
+    assert(jni::TypeSignature< jni::Array<jni::jboolean> >()() == "[Z");
+    assert(jni::TypeSignature< jni::Array<jni::String>   >()() == "[Ljava/lang/String;");
 
-    assert(jni::TypeSignature< void () >()() == std::string("()V"));
-    assert(jni::TypeSignature< jni::jboolean () >()() == std::string("()Z"));
-    assert(jni::TypeSignature< void (jni::jboolean, jni::jbyte, jni::jchar) >()() == std::string("(ZBC)V"));
+    assert(jni::TypeSignature< void () >()() == "()V");
+    assert(jni::TypeSignature< jni::jboolean () >()() == "()Z");
+    assert(jni::TypeSignature< void (jni::jboolean, jni::jbyte, jni::jchar) >()() == "(ZBC)V");
 
     struct String { static constexpr const char * Name() { return "java/lang/String"; } };
-    assert(jni::TypeSignature< jni::Object<String> >()() == std::string("Ljava/lang/String;"));
-    assert(jni::TypeSignature< void (jni::Object<String>) >()() == std::string("(Ljava/lang/String;)V"));
-    assert(jni::TypeSignature< jni::Object<String> (void) >()() == std::string("()Ljava/lang/String;"));
+    assert(jni::TypeSignature< jni::Object<String> >()() == "Ljava/lang/String;");
+    assert(jni::TypeSignature< void (jni::Object<String>) >()() == "(Ljava/lang/String;)V");
+    assert(jni::TypeSignature< jni::Object<String> (void) >()() == "()Ljava/lang/String;");
 
 
     /// Class