1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _ANDROID_NIO_UTILS_H_
#define _ANDROID_NIO_UTILS_H_
#include <jni.h>
#include <cstddef>
namespace android {
/**
* Class providing scoped access to the memory backing a java.nio.Buffer instance.
*
* Instances of this class should only be allocated on the stack as heap allocation is not
* supported.
*
* Instances of this class do not create any global references for performance reasons.
*/
class AutoBufferPointer final {
public:
/** Constructor for an AutoBufferPointer instance.
*
* @param env The current JNI env
* @param nioBuffer Instance of a java.nio.Buffer whose memory will be accessed.
* @param commit JNI_TRUE if the underlying memory will be updated and should be
* copied back to the managed heap. JNI_FALSE if the data will
* not be modified or the modifications may be discarded.
*
* The commit parameter is only applicable if the buffer is backed by a managed heap
* array and the runtime had to provide a copy of the data rather than the original data.
*/
AutoBufferPointer(JNIEnv* env, jobject nioBuffer, jboolean commit);
/** Destructor for an AutoBufferPointer instance.
*
* Releases critical managed heap array pointer if acquired.
*/
~AutoBufferPointer();
/**
* Returns a pointer to the current position of the buffer provided to the constructor. This
* pointer is only valid whilst the AutoBufferPointer instance remains in scope.
*/
void* pointer() const { return fPointer; }
private:
JNIEnv* const fEnv;
void* fPointer; // Pointer to current buffer position when constructed.
void* fElements; // Pointer to array element 0 (null if buffer is direct, may be
// within fArray or point to a copy of the array).
jarray fArray; // Pointer to array on managed heap.
const jboolean fCommit; // Flag to commit data to source (when fElements is a copy of fArray).
// Unsupported constructors and operators.
AutoBufferPointer() = delete;
AutoBufferPointer(AutoBufferPointer&) = delete;
AutoBufferPointer& operator=(AutoBufferPointer&) = delete;
static void* operator new(size_t);
static void* operator new[](size_t);
static void* operator new(size_t, void*);
static void* operator new[](size_t, void*);
static void operator delete(void*, size_t);
static void operator delete[](void*, size_t);
};
} /* namespace android */
#endif // _ANDROID_NIO_UTILS_H_
|
