Skip to content

Commit f2c4e51

Browse files
jfirebaughjfirebaugh
committed
Array and Class inherit from Object
1 parent 68117a1 commit f2c4e51

File tree

6 files changed

+169
-171
lines changed

6 files changed

+169
-171
lines changed

‎include/jni/array.hpp

Lines changed: 30 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -7,72 +7,56 @@
77

88
namespace jni
99
{
10-
template < class E, class Enable = void >
10+
template < class E, class Enable >
1111
class Array;
1212

1313
template < class E >
14-
class Array< E, std::enable_if_t<IsPrimitive<E>::value> >
14+
class Array< E, std::enable_if_t<IsPrimitive<E>::value> > : public Object< ArrayTag<E> >
1515
{
1616
public:
17+
using SuperType = Object< ArrayTag<E> >;
18+
using UntaggedType = typename SuperType::UntaggedType;
1719
using ElementType = E;
18-
using UntaggedType = jarray<E>;
19-
20-
private:
21-
UntaggedType* array = nullptr;
2220

2321
protected:
2422
explicit Array(std::nullptr_t = nullptr)
2523
{}
2624

27-
explicit Array(UntaggedType* a)
28-
: array(a)
29-
{}
30-
31-
Array(const Array& a)
32-
: array(a.array)
25+
explicit Array(UntaggedType* p)
26+
: SuperType(p)
3327
{}
3428

35-
~Array() = default;
36-
29+
Array(const Array&) = delete;
3730
Array& operator=(const Array&) = delete;
38-
void reset(UntaggedType* a) { array = a; }
3931

4032
public:
41-
explicit operator bool() const { return array; }
42-
43-
UntaggedType& operator*() const { return *array; }
44-
UntaggedType* Get() const { return array; }
45-
46-
friend bool operator==( const Array& a, const Array& b ) { return a.Get() == b.Get(); }
47-
friend bool operator!=( const Array& a, const Array& b ) { return !( a == b ); }
48-
4933
jsize Length(JNIEnv& env) const
5034
{
51-
return GetArrayLength(env, SafeDereference(env, array));
35+
return GetArrayLength(env, SafeDereference(env, this->get()));
5236
}
5337

5438
ElementType Get(JNIEnv& env, jsize index) const
5539
{
5640
ElementType e;
57-
GetArrayRegion(env, SafeDereference(env, array), index, 1, &e);
41+
GetArrayRegion(env, SafeDereference(env, this->get()), index, 1, &e);
5842
return e;
5943
}
6044

6145
void Set(JNIEnv& env, jsize index, const ElementType& value)
6246
{
63-
SetArrayRegion(env, SafeDereference(env, array), index, 1, &value);
47+
SetArrayRegion(env, SafeDereference(env, this->get()), index, 1, &value);
6448
}
6549

6650
template < class Array >
6751
void GetRegion(JNIEnv& env, jsize start, Array& buf) const
6852
{
69-
GetArrayRegion(env, SafeDereference(env, array), start, buf);
53+
GetArrayRegion(env, SafeDereference(env, this->get()), start, buf);
7054
}
7155

7256
template < class Array >
7357
void SetRegion(JNIEnv& env, jsize start, const Array& buf)
7458
{
75-
SetArrayRegion(env, SafeDereference(env, array), start, buf);
59+
SetArrayRegion(env, SafeDereference(env, this->get()), start, buf);
7660
}
7761

7862
static Local<Array<E>> New(JNIEnv& env, jsize length)
@@ -83,103 +67,87 @@ namespace jni
8367
template < template < RefDeletionMethod > class Deleter = DefaultRefDeleter >
8468
Global<Array<E>, Deleter> NewGlobalRef(JNIEnv& env) const
8569
{
86-
return Global<Array<E>, Deleter>(env, jni::NewGlobalRef(env, array).release());
70+
return Global<Array<E>, Deleter>(env, jni::NewGlobalRef(env, this->get()).release());
8771
}
8872

8973
template < template < RefDeletionMethod > class Deleter = DefaultRefDeleter >
9074
Weak<Array<E>, Deleter> NewWeakGlobalRef(JNIEnv& env) const
9175
{
92-
return Weak<Array<E>, Deleter>(env, jni::NewWeakGlobalRef(env, array).release());
76+
return Weak<Array<E>, Deleter>(env, jni::NewWeakGlobalRef(env, this->get()).release());
9377
}
9478

9579
Local<Array<E>> NewLocalRef(JNIEnv& env) const
9680
{
97-
return Local<Array<E>>(env, jni::NewLocalRef(env, array).release());
81+
return Local<Array<E>>(env, jni::NewLocalRef(env, this->get()).release());
9882
}
9983
};
10084

10185
template < class TheTag >
102-
class Array< Object<TheTag> >
86+
class Array< Object<TheTag> > : public Object< ArrayTag<Object<TheTag>> >
10387
{
10488
public:
89+
using SuperType = Object< ArrayTag<Object<TheTag>> >;
90+
using UntaggedType = typename SuperType::UntaggedType;
10591
using TagType = TheTag;
10692
using ElementType = Object<TagType>;
107-
using UntaggedType = jarray<jobject>;
10893
using UntaggedElementType = typename ElementType::UntaggedType;
10994

110-
private:
111-
UntaggedType* array = nullptr;
112-
11395
protected:
11496
explicit Array(std::nullptr_t = nullptr)
11597
{}
11698

117-
explicit Array(UntaggedType* a)
118-
: array(a)
119-
{}
120-
121-
Array(const Array& a)
122-
: array(a.array)
99+
explicit Array(UntaggedType* p)
100+
: SuperType(p)
123101
{}
124102

125-
~Array() = default;
126-
103+
Array(const Array&) = delete;
127104
Array& operator=(const Array&) = delete;
128-
void reset(UntaggedType* a) { array = a; }
129105

130106
public:
131-
explicit operator bool() const { return array; }
132-
133-
UntaggedType& operator*() const { return *array; }
134-
UntaggedType* Get() const { return array; }
135-
136-
friend bool operator==( const Array& a, const Array& b ) { return a.Get() == b.Get(); }
137-
friend bool operator!=( const Array& a, const Array& b ) { return !( a == b ); }
138-
139107
jsize Length(JNIEnv& env) const
140108
{
141-
return GetArrayLength(env, SafeDereference(env, array));
109+
return GetArrayLength(env, SafeDereference(env, this->get()));
142110
}
143111

144112
Local<ElementType> Get(JNIEnv& env, jsize index) const
145113
{
146114
return Local<ElementType>(env,
147115
reinterpret_cast<UntaggedElementType*>(
148-
GetObjectArrayElement(env, SafeDereference(env, array), index)));
116+
GetObjectArrayElement(env, SafeDereference(env, this->get()), index)));
149117
}
150118

151119
void Set(JNIEnv& env, jsize index, const ElementType& value)
152120
{
153-
SetObjectArrayElement(env, SafeDereference(env, array), index, Untag(value));
121+
SetObjectArrayElement(env, SafeDereference(env, this->get()), index, Untag(value));
154122
}
155123

156124
static Local<Array<Object<TheTag>>> New(JNIEnv& env, jsize length, const Object<TheTag>* initialElement = nullptr)
157125
{
158-
return Local<Array<Object<TheTag>>>(env, &NewObjectArray(env, length, Class<TheTag>::Singleton(env), initialElement ? initialElement->Get() : nullptr));
126+
return Local<Array<Object<TheTag>>>(env, &NewObjectArray(env, length, *Class<TheTag>::Singleton(env), initialElement ? initialElement->get() : nullptr));
159127
}
160128

161129
template < template < RefDeletionMethod > class Deleter = DefaultRefDeleter >
162130
Global<Array<Object<TheTag>>, Deleter> NewGlobalRef(JNIEnv& env) const
163131
{
164-
return Global<Array<Object<TheTag>>, Deleter>(env, jni::NewGlobalRef(env, array).release());
132+
return Global<Array<Object<TheTag>>, Deleter>(env, jni::NewGlobalRef(env, this->get()).release());
165133
}
166134

167135
template < template < RefDeletionMethod > class Deleter = DefaultRefDeleter >
168136
Weak<Array<Object<TheTag>>, Deleter> NewWeakGlobalRef(JNIEnv& env) const
169137
{
170-
return Weak<Array<Object<TheTag>>, Deleter>(env, jni::NewWeakGlobalRef(env, array).release());
138+
return Weak<Array<Object<TheTag>>, Deleter>(env, jni::NewWeakGlobalRef(env, this->get()).release());
171139
}
172140

173141
Local<Array<Object<TheTag>>> NewLocalRef(JNIEnv& env) const
174142
{
175-
return Local<Array<Object<TheTag>>>(env, jni::NewLocalRef(env, array).release());
143+
return Local<Array<Object<TheTag>>>(env, jni::NewLocalRef(env, this->get()).release());
176144
}
177145
};
178146

179147
template < class T >
180148
std::vector<T> MakeAnything(ThingToMake<std::vector<T>>, JNIEnv& env, const Array<T>& array)
181149
{
182-
NullCheck(env, array.Get());
150+
NullCheck(env, array.get());
183151
std::vector<T> result(GetArrayLength(env, *array));
184152
GetArrayRegion(env, *array, 0, result);
185153
return result;
@@ -196,7 +164,7 @@ namespace jni
196164
inline
197165
std::string MakeAnything(ThingToMake<std::string>, JNIEnv& env, const Array<jbyte>& array)
198166
{
199-
NullCheck(env, array.Get());
167+
NullCheck(env, array.get());
200168
std::string result;
201169
result.resize(GetArrayLength(env, *array));
202170
GetArrayRegion(env, *array, 0, result.size(), reinterpret_cast<jbyte*>(&result[0]));

‎include/jni/class.hpp

Lines changed: 17 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -3,94 +3,78 @@
33
#include <jni/functions.hpp>
44
#include <jni/tagging.hpp>
55
#include <jni/advanced_ownership.hpp>
6+
#include <jni/object.hpp>
67

78
namespace jni
89
{
9-
template < class TheTag > class Object;
1010
template < class TheTag, class... > class Constructor;
1111
template < class TheTag, class > class Field;
1212
template < class TheTag, class > class StaticField;
1313
template < class TheTag, class > class Method;
1414
template < class TheTag, class > class StaticMethod;
1515

1616
template < class TheTag >
17-
class Class
17+
class Class : public Object<ClassTag>
1818
{
1919
public:
2020
using TagType = TheTag;
21+
using SuperType = Object<ClassTag>;
2122
using UntaggedType = jclass;
2223

23-
private:
24-
jclass* clazz = nullptr;
25-
2624
protected:
2725
explicit Class(std::nullptr_t = nullptr)
2826
{}
2927

30-
explicit Class(jclass* c)
31-
: clazz(c)
32-
{}
33-
34-
Class(const Class& c)
35-
: clazz(c.clazz)
28+
explicit Class(UntaggedType* p)
29+
: SuperType(p)
3630
{}
3731

38-
~Class() = default;
39-
32+
Class(const Class&) = delete;
4033
Class& operator=(const Class&) = delete;
41-
void reset(jclass* c) { clazz = c; }
4234

4335
public:
44-
explicit operator bool() const { return clazz; }
45-
46-
jclass& operator*() const { return *clazz; }
47-
jclass* Get() const { return clazz; }
48-
49-
friend bool operator==( const Class& a, const Class& b ) { return a.Get() == b.Get(); }
50-
friend bool operator!=( const Class& a, const Class& b ) { return !( a == b ); }
51-
5236
template < class... ExpectedArgs, class... ActualArgs >
5337
auto New(JNIEnv& env, const Constructor<TagType, ExpectedArgs...>& method, const ActualArgs&... args) const
5438
-> std::enable_if_t< Conjunction<std::is_convertible<const ActualArgs&, const ExpectedArgs&>...>::value, Local<Object<TagType>> >
5539
{
56-
return Local<Object<TagType>>(env, &NewObject(env, *clazz, method, Untag(args)...));
40+
return Local<Object<TagType>>(env, &NewObject(env, *this->get(), method, Untag(args)...));
5741
}
5842

5943
template < class T >
6044
auto Get(JNIEnv& env, const StaticField<TagType, T>& field) const
6145
-> std::enable_if_t< IsPrimitive<T>::value, T >
6246
{
63-
return jni::GetStaticField<T>(env, *clazz, field);
47+
return jni::GetStaticField<T>(env, *this->get(), field);
6448
}
6549

6650
template < class T >
6751
auto Get(JNIEnv& env, const StaticField<TagType, T>& field) const
6852
-> std::enable_if_t< !IsPrimitive<T>::value, Local<T> >
6953
{
70-
return Local<T>(env, reinterpret_cast<typename T::UntaggedType*>(jni::GetStaticField<jobject*>(env, *clazz, field)));
54+
return Local<T>(env, reinterpret_cast<typename T::UntaggedType*>(jni::GetStaticField<jobject*>(env, *this->get(), field)));
7155
}
7256

7357
template < class T >
7458
auto Set(JNIEnv& env, const StaticField<TagType, T>& field, T value) const
7559
-> std::enable_if_t< IsPrimitive<T>::value >
7660
{
77-
SetStaticField<T>(env, *clazz, field, value);
61+
SetStaticField<T>(env, *this->get(), field, value);
7862
}
7963

8064
template < class Expected, class Actual >
8165
auto Set(JNIEnv& env, const StaticField<TagType, Expected>& field, const Actual& value) const
8266
-> std::enable_if_t< !IsPrimitive<Expected>::value
8367
&& std::is_convertible<const Actual&, const Expected&>::value >
8468
{
85-
SetStaticField<jobject*>(env, *clazz, field, value.Get());
69+
SetStaticField<jobject*>(env, *this->get(), field, value.get());
8670
}
8771

8872
template < class R, class... ExpectedArgs, class... ActualArgs >
8973
auto Call(JNIEnv& env, const StaticMethod<TagType, R (ExpectedArgs...)>& method, const ActualArgs&... args) const
9074
-> std::enable_if_t< IsPrimitive<R>::value
9175
&& Conjunction<std::is_convertible<const ActualArgs&, const ExpectedArgs&>...>::value, R >
9276
{
93-
return CallStaticMethod<R>(env, *clazz, method, Untag(args)...);
77+
return CallStaticMethod<R>(env, *this->get(), method, Untag(args)...);
9478
}
9579

9680
template < class R, class... ExpectedArgs, class... ActualArgs >
@@ -99,14 +83,14 @@ namespace jni
9983
&& !std::is_void<R>::value
10084
&& Conjunction<std::is_convertible<const ActualArgs&, const ExpectedArgs&>...>::value, Local<R> >
10185
{
102-
return Local<R>(env, reinterpret_cast<typename R::UntaggedType*>(CallStaticMethod<jobject*>(env, *clazz, method, Untag(args)...)));
86+
return Local<R>(env, reinterpret_cast<typename R::UntaggedType*>(CallStaticMethod<jobject*>(env, *this->get(), method, Untag(args)...)));
10387
}
10488

10589
template < class... ExpectedArgs, class... ActualArgs >
10690
auto Call(JNIEnv& env, const StaticMethod<TagType, void (ExpectedArgs...)>& method, const ActualArgs&... args) const
10791
-> std::enable_if_t< Conjunction<std::is_convertible<const ActualArgs&, const ExpectedArgs&>...>::value >
10892
{
109-
CallStaticMethod<void>(env, *clazz, method, Untag(args)...);
93+
CallStaticMethod<void>(env, *this->get(), method, Untag(args)...);
11094
}
11195

11296
static Local<Class> Find(JNIEnv& env)
@@ -153,18 +137,18 @@ namespace jni
153137
template < template < RefDeletionMethod > class Deleter = DefaultRefDeleter >
154138
Global<Class<TagType>, Deleter> NewGlobalRef(JNIEnv& env) const
155139
{
156-
return Global<Class<TagType>, Deleter>(env, jni::NewGlobalRef(env, clazz).release());
140+
return Global<Class<TagType>, Deleter>(env, jni::NewGlobalRef(env, this->get()).release());
157141
}
158142

159143
template < template < RefDeletionMethod > class Deleter = DefaultRefDeleter >
160144
Weak<Class<TagType>, Deleter> NewWeakGlobalRef(JNIEnv& env) const
161145
{
162-
return Weak<Class<TagType>, Deleter>(env, jni::NewWeakGlobalRef(env, clazz).release());
146+
return Weak<Class<TagType>, Deleter>(env, jni::NewWeakGlobalRef(env, this->get()).release());
163147
}
164148

165149
Local<Class<TagType>> NewLocalRef(JNIEnv& env) const
166150
{
167-
return Local<Class<TagType>>(env, jni::NewLocalRef(env, clazz).release());
151+
return Local<Class<TagType>>(env, jni::NewLocalRef(env, this->get()).release());
168152
}
169153
};
170154
}

0 commit comments

Comments
 (0)