Skip to content

Commit 6ca9cd8

Browse files
jfirebaughjfirebaugh
committed
Redo high-level ownership strategy
1 parent c34a3aa commit 6ca9cd8

File tree

7 files changed

+158
-195
lines changed

7 files changed

+158
-195
lines changed

‎examples/hello.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -44,8 +44,8 @@ static void RegisterHighLevel(JavaVM* vm)
4444

4545
jni::JNIEnv& env { jni::GetEnv(*vm) };
4646

47-
static auto system = *jni::Class<System>::Find(env).NewGlobalRef(env).release();
48-
static auto printStream = *jni::Class<PrintStream>::Find(env).NewGlobalRef(env).release();
47+
static auto system = jni::Class<System>::Find(env).NewGlobalRef(env).release();
48+
static auto printStream = jni::Class<PrintStream>::Find(env).NewGlobalRef(env).release();
4949

5050
static auto out = system.GetStaticField<jni::Object<PrintStream>>(env, "out");
5151
static auto println = printStream.GetMethod<void (jni::String)>(env, "println");

‎include/jni/array.hpp

Lines changed: 31 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -4,18 +4,21 @@
44
#include <jni/object.hpp>
55
#include <jni/tagging.hpp>
66
#include <jni/make.hpp>
7-
#include <jni/pointer_to_value.hpp>
7+
#include <jni/unique_pointerlike.hpp>
88

99
namespace jni
1010
{
1111
template < class E, class Enable = void >
1212
class Array;
1313

14-
template < class TagType >
15-
class ArrayDeleter;
14+
template < class E >
15+
using UniqueArray = UniquePointerlike< Array<E>, GlobalRefDeleter >;
16+
17+
template < class E >
18+
using UniqueWeakArray = UniquePointerlike< Array<E>, WeakGlobalRefDeleter >;
1619

1720
template < class E >
18-
using UniqueArray = std::unique_ptr< const Array<E>, ArrayDeleter<E> >;
21+
using UniqueLocalArray = UniquePointerlike< Array<E>, LocalRefDeleter >;
1922

2023
template < class E >
2124
class Array< E, std::enable_if_t<IsPrimitive<E>::value> >
@@ -28,10 +31,17 @@ namespace jni
2831
UntaggedType* array = nullptr;
2932

3033
public:
34+
explicit Array(std::nullptr_t = nullptr)
35+
{}
36+
3137
explicit Array(UntaggedType* a)
3238
: array(a)
3339
{}
3440

41+
explicit Array(UntaggedType& a)
42+
: array(&a)
43+
{}
44+
3545
explicit operator bool() const { return array; }
3646

3747
operator UntaggedType*() const { return array; }
@@ -94,10 +104,17 @@ namespace jni
94104
UntaggedType* array = nullptr;
95105

96106
public:
107+
explicit Array(std::nullptr_t = nullptr)
108+
{}
109+
97110
explicit Array(UntaggedType* a)
98111
: array(a)
99112
{}
100113

114+
explicit Array(UntaggedType& a)
115+
: array(&a)
116+
{}
117+
101118
explicit operator bool() const { return array; }
102119

103120
operator UntaggedType*() const { return array; }
@@ -136,31 +153,21 @@ namespace jni
136153
};
137154

138155
template < class E >
139-
class ArrayDeleter
156+
UniqueArray<E> Seize(JNIEnv& env, Array<E>&& array)
140157
{
141-
private:
142-
JNIEnv* env = nullptr;
143-
144-
public:
145-
using pointer = PointerToValue< Array<E> >;
146-
147-
ArrayDeleter() = default;
148-
ArrayDeleter(JNIEnv& e) : env(&e) {}
158+
return UniqueArray<E>(std::move(array), GlobalRefDeleter(env));
159+
}
149160

150-
void operator()(pointer p) const
151-
{
152-
if (p)
153-
{
154-
assert(env);
155-
env->DeleteGlobalRef(Unwrap(p->Get()));
156-
}
157-
}
158-
};
161+
template < class E >
162+
UniqueWeakArray<E> SeizeWeakRef(JNIEnv& env, Array<E>&& array)
163+
{
164+
return UniqueWeakArray<E>(std::move(array), WeakGlobalRefDeleter(env));
165+
}
159166

160167
template < class E >
161-
UniqueArray<E> Seize(JNIEnv& env, Array<E>&& array)
168+
UniqueLocalArray<E> SeizeLocalRef(JNIEnv& env, Array<E>&& array)
162169
{
163-
return UniqueArray<E>(PointerToValue<Array<E>>(std::move(array)), ArrayDeleter<E>(env));
170+
return UniqueLocalArray<E>(std::move(array), LocalRefDeleter(env));
164171
}
165172

166173

‎include/jni/class.hpp

Lines changed: 3 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22

33
#include <jni/functions.hpp>
44
#include <jni/tagging.hpp>
5-
#include <jni/pointer_to_value.hpp>
5+
#include <jni/unique_pointerlike.hpp>
66

77
namespace jni
88
{
@@ -17,10 +17,7 @@ namespace jni
1717
class Class;
1818

1919
template < class TagType >
20-
class ClassDeleter;
21-
22-
template < class TagType >
23-
using UniqueClass = std::unique_ptr< const Class<TagType>, ClassDeleter<TagType> >;
20+
using UniqueClass = UniquePointerlike< Class<TagType>, GlobalRefDeleter >;
2421

2522
template < class TheTag >
2623
class Class
@@ -142,31 +139,9 @@ namespace jni
142139
}
143140
};
144141

145-
template < class TagType >
146-
class ClassDeleter
147-
{
148-
private:
149-
JNIEnv* env = nullptr;
150-
151-
public:
152-
using pointer = PointerToValue< Class<TagType> >;
153-
154-
ClassDeleter() = default;
155-
ClassDeleter(JNIEnv& e) : env(&e) {}
156-
157-
void operator()(pointer p) const
158-
{
159-
if (p)
160-
{
161-
assert(env);
162-
env->DeleteGlobalRef(Unwrap(p->Get()));
163-
}
164-
}
165-
};
166-
167142
template < class TagType >
168143
UniqueClass<TagType> Seize(JNIEnv& env, Class<TagType>&& clazz)
169144
{
170-
return UniqueClass<TagType>(PointerToValue<Class<TagType>>(std::move(clazz)), ClassDeleter<TagType>(env));
145+
return UniqueClass<TagType>(std::move(clazz), GlobalRefDeleter(env));
171146
}
172147
}

‎include/jni/object.hpp

Lines changed: 7 additions & 82 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22

33
#include <jni/functions.hpp>
44
#include <jni/tagging.hpp>
5-
#include <jni/pointer_to_value.hpp>
5+
#include <jni/unique_pointerlike.hpp>
66

77
#include <cstddef>
88

@@ -20,23 +20,14 @@ namespace jni
2020
template < class TheTag >
2121
class Object;
2222

23-
template < class TagType >
24-
class ObjectDeleter;
25-
2623
template < class TagType = ObjectTag >
27-
using UniqueObject = std::unique_ptr< const Object<TagType>, ObjectDeleter<TagType> >;
28-
29-
template < class TagType >
30-
class WeakObjectRefDeleter;
24+
using UniqueObject = UniquePointerlike< Object<TagType>, GlobalRefDeleter >;
3125

3226
template < class TagType = ObjectTag >
33-
using UniqueWeakObject = std::unique_ptr< const Object<TagType>, WeakObjectRefDeleter<TagType> >;
34-
35-
template < class TagType >
36-
class LocalObjectRefDeleter;
27+
using UniqueWeakObject = UniquePointerlike< Object<TagType>, WeakGlobalRefDeleter >;
3728

3829
template < class TagType = ObjectTag >
39-
using UniqueLocalObject = std::unique_ptr< const Object<TagType>, LocalObjectRefDeleter<TagType> >;
30+
using UniqueLocalObject = UniquePointerlike< Object<TagType>, LocalRefDeleter >;
4031

4132
template < class TheTag = ObjectTag >
4233
class Object
@@ -164,88 +155,22 @@ namespace jni
164155
}
165156
};
166157

167-
template < class TagType >
168-
class ObjectDeleter
169-
{
170-
private:
171-
JNIEnv* env = nullptr;
172-
173-
public:
174-
using pointer = PointerToValue< Object<TagType> >;
175-
176-
ObjectDeleter() = default;
177-
ObjectDeleter(JNIEnv& e) : env(&e) {}
178-
179-
void operator()(pointer p) const
180-
{
181-
if (p)
182-
{
183-
assert(env);
184-
env->DeleteGlobalRef(Unwrap(p->Get()));
185-
}
186-
}
187-
};
188-
189158
template < class TagType >
190159
UniqueObject<TagType> Seize(JNIEnv& env, Object<TagType>&& object)
191160
{
192-
return UniqueObject<TagType>(PointerToValue<Object<TagType>>(std::move(object)), ObjectDeleter<TagType>(env));
161+
return UniqueObject<TagType>(std::move(object), GlobalRefDeleter(env));
193162
}
194163

195-
template < class TagType >
196-
class WeakObjectRefDeleter
197-
{
198-
private:
199-
JNIEnv* env = nullptr;
200-
201-
public:
202-
using pointer = PointerToValue< Object<TagType> >;
203-
204-
WeakObjectRefDeleter() = default;
205-
WeakObjectRefDeleter(JNIEnv& e) : env(&e) {}
206-
207-
void operator()(pointer p) const
208-
{
209-
if (p)
210-
{
211-
assert(env);
212-
env->DeleteWeakGlobalRef(Unwrap(p->Get()));
213-
}
214-
}
215-
};
216-
217164
template < class TagType >
218165
UniqueWeakObject<TagType> SeizeWeakRef(JNIEnv& env, Object<TagType>&& object)
219166
{
220-
return UniqueWeakObject<TagType>(PointerToValue<Object<TagType>>(std::move(object)), WeakObjectRefDeleter<TagType>(env));
167+
return UniqueWeakObject<TagType>(std::move(object), WeakGlobalRefDeleter(env));
221168
}
222169

223-
template < class TagType >
224-
class LocalObjectRefDeleter
225-
{
226-
private:
227-
JNIEnv* env = nullptr;
228-
229-
public:
230-
using pointer = PointerToValue< Object<TagType> >;
231-
232-
LocalObjectRefDeleter() = default;
233-
LocalObjectRefDeleter(JNIEnv& e) : env(&e) {}
234-
235-
void operator()(pointer p) const
236-
{
237-
if (p)
238-
{
239-
assert(env);
240-
env->DeleteLocalRef(Unwrap(p->Get()));
241-
}
242-
}
243-
};
244-
245170
template < class TagType >
246171
UniqueLocalObject<TagType> SeizeLocalRef(JNIEnv& env, Object<TagType>&& object)
247172
{
248-
return UniqueLocalObject<TagType>(PointerToValue<Object<TagType>>(std::move(object)), LocalObjectRefDeleter<TagType>(env));
173+
return UniqueLocalObject<TagType>(std::move(object), LocalRefDeleter(env));
249174
}
250175

251176

‎include/jni/pointer_to_value.hpp

Lines changed: 0 additions & 57 deletions
This file was deleted.

0 commit comments

Comments
 (0)