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

kkaefer · kkaefer · commit 316f8ef77d99 · 2018-01-02T17:00:27.000-08:00
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 <>

Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ namespace jni`
`121`	`121`
`122`	`122`	`void Set(JNIEnv& env, jsize index, const ElementType& value)`
`123`	`123`	`{`
`124`		`- SetObjectArrayElement(env, SafeDereference(env, array), index, Untag(value));`
	`124`	`+ SetObjectArrayElement(env, SafeDereference(env, array), index, RemoveTag(value));`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`static Array<Object<TheTag>> New(JNIEnv& env, jsize length, const Class<TheTag>& clazz, const Object<TheTag>& initialElement = Object<TheTag>())`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ namespace jni`
`50`	`50`	`template < class... Args >`
`51`	`51`	`Object<TagType> New(JNIEnv& env, const Constructor<TagType, Args...>& method, const Args&... args) const`
`52`	`52`	`{`
`53`		`- return Object<TagType>(&NewObject(env, *clazz, method, Untag(args)...));`
	`53`	`+ return Object<TagType>(&NewObject(env, *clazz, method, RemoveTag(args)...));`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`template < class T >`
`@@ -85,20 +85,20 @@ namespace jni`
`85`	`85`	`auto Call(JNIEnv& env, const StaticMethod<TagType, R (Args...)>& method, const Args&... args) const`
`86`	`86`	`-> std::enable_if_t< IsPrimitive<R>::value, R >`
`87`	`87`	`{`
`88`		`- return CallStaticMethod<R>(env, *clazz, method, Untag(args)...);`
	`88`	`+ return CallStaticMethod<R>(env, *clazz, method, RemoveTag(args)...);`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`template < class R, class... Args >`
`92`	`92`	`auto Call(JNIEnv& env, const StaticMethod<TagType, R (Args...)>& method, const Args&... args) const`
`93`	`93`	`-> std::enable_if_t< !IsPrimitive<R>::value && !std::is_void<R>::value, R >`
`94`	`94`	`{`
`95`		`- return R(reinterpret_cast<UntaggedType<R>>(CallStaticMethod<jobject>(env, clazz, method, Untag(args)...)));`
	`95`	`+ return R(reinterpret_cast<UntaggedType<R>>(CallStaticMethod<jobject>(env, clazz, method, RemoveTag(args)...)));`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`template < class... Args >`
`99`	`99`	`void Call(JNIEnv& env, const StaticMethod<TagType, void (Args...)>& method, const Args&... args) const`
`100`	`100`	`{`
`101`		`- CallStaticMethod<void>(env, *clazz, method, Untag(args)...);`
	`101`	`+ CallStaticMethod<void>(env, *clazz, method, RemoveTag(args)...);`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`static Class Find(JNIEnv& env)`
Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ namespace jni`
`109`	`109`
`110`	`110`	`auto wrapper = [] (JNIEnv* env, UntaggedType<Subject> subject, UntaggedType<Args>... args) -> UntaggedType<R>`
`111`	`111`	`{`
`112`		`- return method(env, Tag<Subject>(subject), Tag<Args>(args)...);`
	`112`	`+ return method(env, AddTag<Subject>(subject), AddTag<Args>(args)...);`
`113`	`113`	`};`
`114`	`114`
`115`	`115`	`return MakeNativeMethod(name, TypeSignature<R (Args...)>()(), wrapper);`
`@@ -132,7 +132,7 @@ namespace jni`
`132`	`132`	`{`
`133`	`133`	`auto wrapper = [] (JNIEnv* env, UntaggedType<Subject> subject, UntaggedType<Args>... args) -> UntaggedType<R>`
`134`	`134`	`{`
`135`		`- return method(env, Tag<Subject>(subject), Tag<Args>(args)...);`
	`135`	`+ return method(env, AddTag<Subject>(subject), AddTag<Args>(args)...);`
`136`	`136`	`};`
`137`	`137`
`138`	`138`	`return MakeNativeMethod(name, TypeSignature<R (Args...)>()(), wrapper);`
Original file line number	Diff line number	Diff line change
`@@ -106,40 +106,40 @@ namespace jni`
`106`	`106`	`auto Call(JNIEnv& env, const Method<TagType, R (Args...)>& method, const Args&... args) const`
`107`	`107`	`-> std::enable_if_t< IsPrimitive<R>::value, R >`
`108`	`108`	`{`
`109`		`- return CallMethod<R>(env, obj, method, Untag(args)...);`
	`109`	`+ return CallMethod<R>(env, obj, method, RemoveTag(args)...);`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`template < class R, class... Args >`
`113`	`113`	`auto Call(JNIEnv& env, const Method<TagType, R (Args...)>& method, const Args&... args) const`
`114`	`114`	`-> std::enable_if_t< !IsPrimitive<R>::value && !std::is_void<R>::value, R >`
`115`	`115`	`{`
`116`		`- return R(reinterpret_cast<UntaggedType<R>>(CallMethod<jobject*>(env, obj, method, Untag(args)...)));`
	`116`	`+ return R(reinterpret_cast<UntaggedType<R>>(CallMethod<jobject*>(env, obj, method, RemoveTag(args)...)));`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`template < class... Args >`
`120`	`120`	`void Call(JNIEnv& env, const Method<TagType, void (Args...)>& method, const Args&... args) const`
`121`	`121`	`{`
`122`		`- CallMethod<void>(env, obj, method, Untag(args)...);`
	`122`	`+ CallMethod<void>(env, obj, method, RemoveTag(args)...);`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`template < class R, class... Args >`
`126`	`126`	`auto CallNonvirtual(JNIEnv& env, const Class<TagType>& clazz, const Method<TagType, R (Args...)>& method, const Args&... args) const`
`127`	`127`	`-> std::enable_if_t< IsPrimitive<R>::value, R >`
`128`	`128`	`{`
`129`		`- return CallNonvirtualMethod<R>(env, obj, clazz, method, Untag(args)...);`
	`129`	`+ return CallNonvirtualMethod<R>(env, obj, clazz, method, RemoveTag(args)...);`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`template < class R, class... Args >`
`133`	`133`	`auto CallNonvirtual(JNIEnv& env, const Class<TagType>& clazz, const Method<TagType, R (Args...)>& method, const Args&... args) const`
`134`	`134`	`-> std::enable_if_t< !IsPrimitive<R>::value, R >`
`135`	`135`	`{`
`136`		`- return R(reinterpret_cast<UntaggedType<R>>(CallNonvirtualMethod<jobject*>(env, obj, clazz, method, Untag(args)...)));`
	`136`	`+ return R(reinterpret_cast<UntaggedType<R>>(CallNonvirtualMethod<jobject*>(env, obj, clazz, method, RemoveTag(args)...)));`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`template < class... Args >`
`140`	`140`	`void CallNonvirtual(JNIEnv& env, const Class<TagType>& clazz, const Method<TagType, void (Args...)>& method, const Args&... args) const`
`141`	`141`	`{`
`142`		`- CallNonvirtualMethod<void>(env, obj, clazz, method, Untag(args)...);`
	`142`	`+ CallNonvirtualMethod<void>(env, obj, clazz, method, RemoveTag(args)...);`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`UniqueObject<TagType> NewGlobalRef(JNIEnv& env) const`
Original file line number	Diff line number	Diff line change
`@@ -7,36 +7,36 @@`
`7`	`7`	`namespace jni`
`8`	`8`	`{`
`9`	`9`	`template < class T >`
`10`		`- auto Tag(T primitive)`
	`10`	`+ auto AddTag(T primitive)`
`11`	`11`	`-> std::enable_if_t< IsPrimitive<T>::value, T >`
`12`	`12`	`{`
`13`	`13`	`return primitive;`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`template < class T, class U >`
`17`		`- auto Tag(U* u)`
	`17`	`+ auto AddTag(U* u)`
`18`	`18`	`-> std::enable_if_t< !IsPrimitive<T>::value, T >`
`19`	`19`	`{`
`20`	`20`	`return T(u);`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`template < class T, class U >`
`24`		`- auto Tag(U& u)`
	`24`	`+ auto AddTag(U& u)`
`25`	`25`	`-> std::enable_if_t< !IsPrimitive<T>::value, T >`
`26`	`26`	`{`
`27`	`27`	`return T(u);`
`28`	`28`	`}`
`29`	`29`
`30`	`30`
`31`	`31`	`template < class T >`
`32`		`- auto Untag(T primitive)`
	`32`	`+ auto RemoveTag(T primitive)`
`33`	`33`	`-> std::enable_if_t< IsPrimitive<T>::value, T >`
`34`	`34`	`{`
`35`	`35`	`return primitive;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`template < class T >`
`39`		`- auto Untag(const T& t)`
	`39`	`+ auto RemoveTag(const T& t)`
`40`	`40`	`-> std::enable_if_t< !IsPrimitive<T>::value, decltype(t.Get()) >`
`41`	`41`	`{`
`42`	`42`	`return t.Get();`
`@@ -46,7 +46,7 @@ namespace jni`
`46`	`46`	`template < class T >`
`47`	`47`	`struct UntaggedTypeTraits`
`48`	`48`	`{`
`49`		`- using Type = decltype(Untag(std::declval<T>()));`
	`49`	`+ using Type = decltype(RemoveTag(std::declval<T>()));`
`50`	`50`	`};`
`51`	`51`
`52`	`52`	`template <>`