free up jni::Tag name by renaming to AddTag/RemoveTag for clarity

mapbox · Jan 3, 2018 · 316f8ef · 316f8ef
1 parent c34a3aa
commit 316f8ef
Show file tree

Hide file tree

Showing 5 changed files with 19 additions and 19 deletions.
diff --git a/include/jni/array.hpp b/include/jni/array.hpp
@@ -121,7 +121,7 @@ namespace jni
 
             void Set(JNIEnv& env, jsize index, const ElementType& value)
                {
-                SetObjectArrayElement(env, SafeDereference(env, array), index, Untag(value));
+                SetObjectArrayElement(env, SafeDereference(env, array), index, RemoveTag(value));
                }
 
             static Array<Object<TheTag>> New(JNIEnv& env, jsize length, const Class<TheTag>& clazz, const Object<TheTag>& initialElement = Object<TheTag>())

diff --git a/include/jni/class.hpp b/include/jni/class.hpp
@@ -50,7 +50,7 @@ namespace jni
             template < class... Args >
             Object<TagType> New(JNIEnv& env, const Constructor<TagType, Args...>& method, const Args&... args) const
                {
-                return Object<TagType>(&NewObject(env, *clazz, method, Untag(args)...));
+                return Object<TagType>(&NewObject(env, *clazz, method, RemoveTag(args)...));
                }
 
             template < class T >
@@ -85,20 +85,20 @@ namespace jni
             auto Call(JNIEnv& env, const StaticMethod<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< IsPrimitive<R>::value, R >
                {
-                return CallStaticMethod<R>(env, *clazz, method, Untag(args)...);
+                return CallStaticMethod<R>(env, *clazz, method, RemoveTag(args)...);
                }
 
             template < class R, class... Args >
             auto Call(JNIEnv& env, const StaticMethod<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< !IsPrimitive<R>::value && !std::is_void<R>::value, R >
                {
-                return R(reinterpret_cast<UntaggedType<R>>(CallStaticMethod<jobject*>(env, *clazz, method, Untag(args)...)));
+                return R(reinterpret_cast<UntaggedType<R>>(CallStaticMethod<jobject*>(env, *clazz, method, RemoveTag(args)...)));
                }
 
             template < class... Args >
             void Call(JNIEnv& env, const StaticMethod<TagType, void (Args...)>& method, const Args&... args) const
                {
-                CallStaticMethod<void>(env, *clazz, method, Untag(args)...);
+                CallStaticMethod<void>(env, *clazz, method, RemoveTag(args)...);
                }
 
             static Class Find(JNIEnv& env)

diff --git a/include/jni/native_method.hpp b/include/jni/native_method.hpp
@@ -109,7 +109,7 @@ namespace jni
 
             auto wrapper = [] (JNIEnv* env, UntaggedType<Subject> subject, UntaggedType<Args>... args) -> UntaggedType<R>
                {
-                return method(*env, Tag<Subject>(*subject), Tag<Args>(args)...);
+                return method(*env, AddTag<Subject>(*subject), AddTag<Args>(args)...);
                };
 
             return MakeNativeMethod(name, TypeSignature<R (Args...)>()(), wrapper);
@@ -132,7 +132,7 @@ namespace jni
            {
             auto wrapper = [] (JNIEnv* env, UntaggedType<Subject> subject, UntaggedType<Args>... args) -> UntaggedType<R>
                {
-                return method(*env, Tag<Subject>(*subject), Tag<Args>(args)...);
+                return method(*env, AddTag<Subject>(*subject), AddTag<Args>(args)...);
                };
 
             return MakeNativeMethod(name, TypeSignature<R (Args...)>()(), wrapper);

diff --git a/include/jni/object.hpp b/include/jni/object.hpp
@@ -106,40 +106,40 @@ namespace jni
             auto Call(JNIEnv& env, const Method<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< IsPrimitive<R>::value, R >
                {
-                return CallMethod<R>(env, obj, method, Untag(args)...);
+                return CallMethod<R>(env, obj, method, RemoveTag(args)...);
                }
 
             template < class R, class... Args >
             auto Call(JNIEnv& env, const Method<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< !IsPrimitive<R>::value && !std::is_void<R>::value, R >
                {
-                return R(reinterpret_cast<UntaggedType<R>>(CallMethod<jobject*>(env, obj, method, Untag(args)...)));
+                return R(reinterpret_cast<UntaggedType<R>>(CallMethod<jobject*>(env, obj, method, RemoveTag(args)...)));
                }
 
             template < class... Args >
             void Call(JNIEnv& env, const Method<TagType, void (Args...)>& method, const Args&... args) const
                {
-                CallMethod<void>(env, obj, method, Untag(args)...);
+                CallMethod<void>(env, obj, method, RemoveTag(args)...);
                }
 
             template < class R, class... Args >
             auto CallNonvirtual(JNIEnv& env, const Class<TagType>& clazz, const Method<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< IsPrimitive<R>::value, R >
                {
-                return CallNonvirtualMethod<R>(env, obj, clazz, method, Untag(args)...);
+                return CallNonvirtualMethod<R>(env, obj, clazz, method, RemoveTag(args)...);
                }
 
             template < class R, class... Args >
             auto CallNonvirtual(JNIEnv& env, const Class<TagType>& clazz, const Method<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< !IsPrimitive<R>::value, R >
                {
-                return R(reinterpret_cast<UntaggedType<R>>(CallNonvirtualMethod<jobject*>(env, obj, clazz, method, Untag(args)...)));
+                return R(reinterpret_cast<UntaggedType<R>>(CallNonvirtualMethod<jobject*>(env, obj, clazz, method, RemoveTag(args)...)));
                }
 
             template < class... Args >
             void CallNonvirtual(JNIEnv& env, const Class<TagType>& clazz, const Method<TagType, void (Args...)>& method, const Args&... args) const
                {
-                CallNonvirtualMethod<void>(env, obj, clazz, method, Untag(args)...);
+                CallNonvirtualMethod<void>(env, obj, clazz, method, RemoveTag(args)...);
                }
 
             UniqueObject<TagType> NewGlobalRef(JNIEnv& env) const

diff --git a/include/jni/tagging.hpp b/include/jni/tagging.hpp
@@ -7,36 +7,36 @@
 namespace jni
    {
     template < class T >
-    auto Tag(T primitive)
+    auto AddTag(T primitive)
        -> std::enable_if_t< IsPrimitive<T>::value, T >
        {
         return primitive;
        }
 
     template < class T, class U >
-    auto Tag(U* u)
+    auto AddTag(U* u)
        -> std::enable_if_t< !IsPrimitive<T>::value, T >
        {
         return T(u);
        }
 
     template < class T, class U >
-    auto Tag(U& u)
+    auto AddTag(U& u)
        -> std::enable_if_t< !IsPrimitive<T>::value, T >
        {
         return T(u);
        }
 
 
     template < class T >
-    auto Untag(T primitive)
+    auto RemoveTag(T primitive)
        -> std::enable_if_t< IsPrimitive<T>::value, T >
        {
         return primitive;
        }
 
     template < class T >
-    auto Untag(const T& t)
+    auto RemoveTag(const T& t)
        -> std::enable_if_t< !IsPrimitive<T>::value, decltype(t.Get()) >
        {
         return t.Get();
@@ -46,7 +46,7 @@ namespace jni
     template < class T >
     struct UntaggedTypeTraits
        {
-        using Type = decltype(Untag(std::declval<T>()));
+        using Type = decltype(RemoveTag(std::declval<T>()));
        };
 
     template <>