Pointer (BridJ (NativeLibs4Java C/C++ Interop Layer) 0.7.0 API)

java.lang.Object
- org.bridj.Pointer<T>

All Implemented Interfaces:

Comparable<Pointer<?>>, Iterable<T>

Direct Known Subclasses:

TypedPointer
```
public abstract class Pointer<T>
extends Object
implements Comparable<Pointer<?>>, Iterable<T>
```
Pointer to a native memory location.
Pointer is the entry point of any pointer-related operation in BridJ.
Manipulating memory
- Wrapping a memory address as a pointer : pointerToAddress(long)
- Reading / writing a primitive from / to the pointed memory location :
 getInt() / setInt(int)
 getLong() / setLong(long)
 getShort() / setShort(short)
 getByte() / setByte(byte)
 getChar() / setChar(char)
 getFloat() / setFloat(float)
 getDouble() / setDouble(double)
 getBoolean() / setBoolean(boolean)
 getSizeT() / setSizeT(long)
 getCLong() / setCLong(long)
- Reading / writing the nth contiguous primitive value from / to the pointed memory location :
 getIntAtIndex(long) / setIntAtIndex(long, int)
 getLongAtIndex(long) / setLongAtIndex(long, long)
 getShortAtIndex(long) / setShortAtIndex(long, short)
 getByteAtIndex(long) / setByteAtIndex(long, byte)
 getCharAtIndex(long) / setCharAtIndex(long, char)
 getFloatAtIndex(long) / setFloatAtIndex(long, float)
 getDoubleAtIndex(long) / setDoubleAtIndex(long, double)
 getBooleanAtIndex(long) / setBooleanAtIndex(long, boolean)
 getSizeTAtIndex(long) / setSizeTAtIndex(long, long)
 getCLongAtIndex(long) / setCLongAtIndex(long, long)
- Reading / writing a primitive from / to the pointed memory location with a byte offset:
 getIntAtOffset(long) / setIntAtOffset(long, int)
 getLongAtOffset(long) / setLongAtOffset(long, long)
 getShortAtOffset(long) / setShortAtOffset(long, short)
 getByteAtOffset(long) / setByteAtOffset(long, byte)
 getCharAtOffset(long) / setCharAtOffset(long, char)
 getFloatAtOffset(long) / setFloatAtOffset(long, float)
 getDoubleAtOffset(long) / setDoubleAtOffset(long, double)
 getBooleanAtOffset(long) / setBooleanAtOffset(long, boolean)
 getSizeTAtOffset(long) / setSizeTAtOffset(long, long)
 getCLongAtOffset(long) / setCLongAtOffset(long, long)
- Reading / writing an array of primitives from / to the pointed memory location :
 getInts(int) / setInts(int[]) ; With an offset : getIntsAtOffset(long, int) / setIntsAtOffset(long, int[])
 getLongs(int) / setLongs(long[]) ; With an offset : getLongsAtOffset(long, int) / setLongsAtOffset(long, long[])
 getShorts(int) / setShorts(short[]) ; With an offset : getShortsAtOffset(long, int) / setShortsAtOffset(long, short[])
 getBytes(int) / setBytes(byte[]) ; With an offset : getBytesAtOffset(long, int) / setBytesAtOffset(long, byte[])
 getChars(int) / setChars(char[]) ; With an offset : getCharsAtOffset(long, int) / setCharsAtOffset(long, char[])
 getFloats(int) / setFloats(float[]) ; With an offset : getFloatsAtOffset(long, int) / setFloatsAtOffset(long, float[])
 getDoubles(int) / setDoubles(double[]) ; With an offset : getDoublesAtOffset(long, int) / setDoublesAtOffset(long, double[])
 getBooleans(int) / setBooleans(boolean[]) ; With an offset : getBooleansAtOffset(long, int) / setBooleansAtOffset(long, boolean[])
 getSizeTs(int) / setSizeTs(long[]) ; With an offset : getSizeTsAtOffset(long, int) / setSizeTsAtOffset(long, long[])
 getCLongs(int) / setCLongs(long[]) ; With an offset : getCLongsAtOffset(long, int) / setCLongsAtOffset(long, long[])
- Reading / writing an NIO buffer of primitives from / to the pointed memory location :
 getIntBuffer(long) (can be used for writing as well) / setInts(IntBuffer)
 getLongBuffer(long) (can be used for writing as well) / setLongs(LongBuffer)
 getShortBuffer(long) (can be used for writing as well) / setShorts(ShortBuffer)
 getByteBuffer(long) (can be used for writing as well) / setBytes(ByteBuffer)
 getFloatBuffer(long) (can be used for writing as well) / setFloats(FloatBuffer)
 getDoubleBuffer(long) (can be used for writing as well) / setDoubles(DoubleBuffer)
- Reading / writing a String from / to the pointed memory location using the default charset :
 getCString() / setCString(String) ; With an offset : getCStringAtOffset(long) / setCStringAtOffset(long, String)
 getWideCString() / setWideCString(String) ; With an offset : getWideCStringAtOffset(long) / setWideCStringAtOffset(long, String)
- Reading / writing a String with control on the charset :
 getStringAtOffset(long, StringType, Charset) / setStringAtOffset(long, String, StringType, Charset)
Allocating memory
- Getting the pointer to a struct / a C++ class / a COM object : getPointer(NativeObject)
- Allocating a dynamic callback (without a static Callback definition, which would be the preferred way) :
 allocateDynamicCallback(DynamicCallback, org.bridj.ann.Convention.Style, Type, Type[])
- Allocating a primitive with / without an initial value (zero-initialized) :
 pointerToInt(int) / allocateInt()
 pointerToLong(long) / allocateLong()
 pointerToShort(short) / allocateShort()
 pointerToByte(byte) / allocateByte()
 pointerToChar(char) / allocateChar()
 pointerToFloat(float) / allocateFloat()
 pointerToDouble(double) / allocateDouble()
 pointerToBoolean(boolean) / allocateBoolean()
 pointerToSizeT(long) / allocateSizeT()
 pointerToCLong(long) / allocateCLong()
- Allocating an array of primitives with / without initial values (zero-initialized) :
 pointerToInts(int[]) or pointerToInts(IntBuffer) / allocateInts(long)
 pointerToLongs(long[]) or pointerToLongs(LongBuffer) / allocateLongs(long)
 pointerToShorts(short[]) or pointerToShorts(ShortBuffer) / allocateShorts(long)
 pointerToBytes(byte[]) or pointerToBytes(ByteBuffer) / allocateBytes(long)
 pointerToChars(char[]) or pointerToChars(CharBuffer) / allocateChars(long)
 pointerToFloats(float[]) or pointerToFloats(FloatBuffer) / allocateFloats(long)
 pointerToDoubles(double[]) or pointerToDoubles(DoubleBuffer) / allocateDoubles(long)
 pointerToSizeTs(long[]) / allocateSizeTs(long)
 pointerToCLongs(long[]) / allocateCLongs(long)
 pointerToBuffer(Buffer) / n/a
- Allocating a native String :
 pointerToCString(String) (default charset)
 pointerToWideCString(String) (default charset)
 pointerToString(String, StringType, Charset)
- Allocating a Pointer.ListType.Dynamic Java List that uses native memory storage (think of getting back the pointer with NativeList.getPointer() when you're done mutating the list):
 allocateList(Class, long)
- Transforming a pointer to a Java List that uses the pointer as storage (think of getting back the pointer with NativeList.getPointer() when you're done mutating the list, if it's Pointer.ListType.Dynamic) :
 asList(ListType)
 asList()
Casting pointers
- Cast a pointer to a DynamicFunction :
 asDynamicFunction(org.bridj.ann.Convention.Style, java.lang.reflect.Type, java.lang.reflect.Type[])
- Cast a pointer to a StructObject or a Callback (as the ones generated by JNAerator)
 : as(Class)
- Cast a pointer to a complex type pointer (use CPPType.getCPPType(Object[]) to create a C++ template type, for instance) :
 as(Type)
- Get an untyped pointer :
 asUntyped()
Dealing with pointer bounds
- Pointers to memory allocated through Pointer.pointerTo*, Pointer.allocate* have validity bounds that help prevent buffer overflows, at least when the Pointer API is used
- offset(long), next(long) and other similar methods retain pointer bounds
- getValidBytes() and getValidElements() return the amount of valid memory readable from the pointer
- Bounds can be declared manually with validBytes(long) (useful for memory allocated by native code)

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Pointer.ListType` Types of pointer-based list implementations that can be created through `asList()` or `asList(ListType)`.
`static interface`	`Pointer.Releaser` Object responsible for reclamation of some pointed memory when it's not used anymore.
`static class`	`Pointer.StringType` Type of a native character string.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`defaultAlignment` Default alignment used to allocate memory from the static factory methods in Pointer class (any value lower or equal to 1 means no alignment)
`static Pointer<?>`	`NULL` The NULL pointer is always Java's null value
`static int`	`SIZE` Size of a pointer in bytes.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <V> Pointer<V>`	`allocate(Class<V> elementClass)` Create a memory area large enough to a single items of type elementClass.
`static <V> Pointer<V>`	`allocate(PointerIO<V> io)` Create a memory area large enough to hold one item of the type associated to the provided PointerIO instance (see `PointerIO.getTargetType()`)
`static <V> Pointer<V>`	`allocate(Type elementClass)` Create a memory area large enough to a single items of type elementClass.
`static <V> Pointer<V>`	`allocateAlignedArray(Class<V> elementClass, long arrayLength, int alignment)` Create a memory area large enough to hold arrayLength items of type elementClass, ensuring the pointer to the memory is aligned to the provided boundary.
`static <V> Pointer<V>`	`allocateAlignedArray(Type elementClass, long arrayLength, int alignment)` Create a memory area large enough to hold arrayLength items of type elementClass, ensuring the pointer to the memory is aligned to the provided boundary.
`static <V> Pointer<V>`	`allocateAlignedBytes(PointerIO<V> io, long byteSize, int alignment, Pointer.Releaser beforeDeallocation)` Create a memory area large enough to hold byteSize consecutive bytes and return a pointer to elements of the type associated to the provided PointerIO instance (see `PointerIO.getTargetType()`), ensuring the pointer to the memory is aligned to the provided boundary.
`static <V> Pointer<V>`	`allocateArray(Class<V> elementClass, long arrayLength)` Create a memory area large enough to hold arrayLength items of type elementClass.
`static <V> Pointer<V>`	`allocateArray(PointerIO<V> io, long arrayLength)` Create a memory area large enough to hold arrayLength items of the type associated to the provided PointerIO instance (see `PointerIO.getTargetType()`)
`static <V> Pointer<V>`	`allocateArray(PointerIO<V> io, long arrayLength, Pointer.Releaser beforeDeallocation)` Create a memory area large enough to hold arrayLength items of the type associated to the provided PointerIO instance (see `PointerIO.getTargetType()`)
`static <V> Pointer<V>`	`allocateArray(Type elementClass, long arrayLength)` Create a memory area large enough to hold arrayLength items of type elementClass.
`static Pointer<Boolean>`	`allocateBoolean()` Allocate enough memory for a boolean value and return a pointer to it.
`static Pointer<Boolean>`	`allocateBooleans(long arrayLength)` Allocate enough memory for arrayLength boolean values and return a pointer to that memory.
`static Pointer<Pointer<Boolean>>`	`allocateBooleans(long dim1, long dim2)` Allocate enough memory for dim1 * dim2 boolean values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Boolean>>>`	`allocateBooleans(long dim1, long dim2, long dim3)` Allocate enough memory for dim1 * dim2 * dim3 boolean values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Byte>`	`allocateByte()` Allocate enough memory for a byte value and return a pointer to it.
`static Pointer<Byte>`	`allocateBytes(long arrayLength)` Allocate enough memory for arrayLength byte values and return a pointer to that memory.
`static Pointer<Pointer<Byte>>`	`allocateBytes(long dim1, long dim2)` Allocate enough memory for dim1 * dim2 byte values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Byte>>>`	`allocateBytes(long dim1, long dim2, long dim3)` Allocate enough memory for dim1 * dim2 * dim3 byte values in a packed multi-dimensional C array and return a pointer to that memory.
`static <V> Pointer<V>`	`allocateBytes(PointerIO<V> io, long byteSize, Pointer.Releaser beforeDeallocation)` Create a memory area large enough to hold byteSize consecutive bytes and return a pointer to elements of the type associated to the provided PointerIO instance (see `PointerIO.getTargetType()`)
`static Pointer<Character>`	`allocateChar()` Allocate enough memory for a char value and return a pointer to it.
`static Pointer<Character>`	`allocateChars(long arrayLength)` Allocate enough memory for arrayLength char values and return a pointer to that memory.
`static Pointer<Pointer<Character>>`	`allocateChars(long dim1, long dim2)` Allocate enough memory for dim1 * dim2 char values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Character>>>`	`allocateChars(long dim1, long dim2, long dim3)` Allocate enough memory for dim1 * dim2 * dim3 char values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<CLong>`	`allocateCLong()` Allocate enough memory for a CLong value and return a pointer to it.
`static Pointer<CLong>`	`allocateCLongs(long arrayLength)` Allocate enough memory for arrayLength CLong values and return a pointer to that memory.
`static Pointer<Double>`	`allocateDouble()` Allocate enough memory for a double value and return a pointer to it.
`static Pointer<Double>`	`allocateDoubles(long arrayLength)` Allocate enough memory for arrayLength double values and return a pointer to that memory.
`static Pointer<Pointer<Double>>`	`allocateDoubles(long dim1, long dim2)` Allocate enough memory for dim1 * dim2 double values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Double>>>`	`allocateDoubles(long dim1, long dim2, long dim3)` Allocate enough memory for dim1 * dim2 * dim3 double values in a packed multi-dimensional C array and return a pointer to that memory.
`static <R> Pointer<DynamicFunction<R>>`	`allocateDynamicCallback(DynamicCallback<R> callback, Convention.Style callingConvention, Type returnType, Type... parameterTypes)` Create a native callback which signature corresponds to the provided calling convention, return type and parameter types, and which redirects calls to the provided Java `DynamicCallback` handler.
`static Pointer<Float>`	`allocateFloat()` Allocate enough memory for a float value and return a pointer to it.
`static Pointer<Float>`	`allocateFloats(long arrayLength)` Allocate enough memory for arrayLength float values and return a pointer to that memory.
`static Pointer<Pointer<Float>>`	`allocateFloats(long dim1, long dim2)` Allocate enough memory for dim1 * dim2 float values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Float>>>`	`allocateFloats(long dim1, long dim2, long dim3)` Allocate enough memory for dim1 * dim2 * dim3 float values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Integer>`	`allocateInt()` Allocate enough memory for a int value and return a pointer to it.
`static Pointer<Integer>`	`allocateInts(long arrayLength)` Allocate enough memory for arrayLength int values and return a pointer to that memory.
`static Pointer<Pointer<Integer>>`	`allocateInts(long dim1, long dim2)` Allocate enough memory for dim1 * dim2 int values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Integer>>>`	`allocateInts(long dim1, long dim2, long dim3)` Allocate enough memory for dim1 * dim2 * dim3 int values in a packed multi-dimensional C array and return a pointer to that memory.
`static <E> NativeList<E>`	`allocateList(Class<E> type, long capacity)` Create a `Pointer.ListType.Dynamic` list with the provided initial capacity (see `Pointer.ListType.Dynamic`).
`static <E> NativeList<E>`	`allocateList(PointerIO<E> io, long capacity)` Create a `Pointer.ListType.Dynamic` list with the provided initial capacity (see `Pointer.ListType.Dynamic`).
`static <E> NativeList<E>`	`allocateList(Type type, long capacity)` Create a `Pointer.ListType.Dynamic` list with the provided initial capacity (see `Pointer.ListType.Dynamic`).
`static Pointer<Long>`	`allocateLong()` Allocate enough memory for a long value and return a pointer to it.
`static Pointer<Long>`	`allocateLongs(long arrayLength)` Allocate enough memory for arrayLength long values and return a pointer to that memory.
`static Pointer<Pointer<Long>>`	`allocateLongs(long dim1, long dim2)` Allocate enough memory for dim1 * dim2 long values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Long>>>`	`allocateLongs(long dim1, long dim2, long dim3)` Allocate enough memory for dim1 * dim2 * dim3 long values in a packed multi-dimensional C array and return a pointer to that memory.
`static <V> Pointer<Pointer<?>>`	`allocatePointer()` Create a memory area large enough to hold an untyped pointer.
`static <P> Pointer<Pointer<P>>`	`allocatePointer(Class<P> targetType)` Create a memory area large enough to hold a pointer.
`static <P> Pointer<Pointer<P>>`	`allocatePointer(Type targetType)` Create a memory area large enough to hold a pointer.
`static <P> Pointer<Pointer<Pointer<P>>>`	`allocatePointerPointer(Class<P> targetType)` Create a memory area large enough to hold a pointer to a pointer
`static <P> Pointer<Pointer<Pointer<P>>>`	`allocatePointerPointer(Type targetType)` Create a memory area large enough to hold a pointer to a pointer
`static <P> Pointer<Pointer<P>>`	`allocatePointers(Class<P> targetType, int arrayLength)` Create a memory area large enough to hold an array of arrayLength typed pointers.
`static Pointer<Pointer<?>>`	`allocatePointers(int arrayLength)` Allocate enough memory for arrayLength untyped pointer values and return a pointer to that memory.
`static <P> Pointer<Pointer<P>>`	`allocatePointers(Type targetType, int arrayLength)` Create a memory area large enough to hold an array of arrayLength typed pointers.
`static Pointer<Short>`	`allocateShort()` Allocate enough memory for a short value and return a pointer to it.
`static Pointer<Short>`	`allocateShorts(long arrayLength)` Allocate enough memory for arrayLength short values and return a pointer to that memory.
`static Pointer<Pointer<Short>>`	`allocateShorts(long dim1, long dim2)` Allocate enough memory for dim1 * dim2 short values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Short>>>`	`allocateShorts(long dim1, long dim2, long dim3)` Allocate enough memory for dim1 * dim2 * dim3 short values in a packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<SizeT>`	`allocateSizeT()` Allocate enough memory for a SizeT value and return a pointer to it.
`static Pointer<SizeT>`	`allocateSizeTs(long arrayLength)` Allocate enough memory for arrayLength SizeT values and return a pointer to that memory.
`static <P extends TypedPointer> Pointer<P>`	`allocateTypedPointer(Class<P> type)` Allocate enough memory for a typed pointer value and return a pointer to it.
`static <P extends TypedPointer> Pointer<P>`	`allocateTypedPointers(Class<P> type, long arrayLength)` Allocate enough memory for arrayLength typed pointer values and return a pointer to that memory.
`T`	`apply(long index)` Alias for `get(long)` defined for more natural use from the Scala language.
`<U> Pointer<U>`	`as(Class<U> type)` Cast this pointer to another pointer type.
`<U> Pointer<U>`	`as(PointerIO<U> newIO)` Cast this pointer to another pointer type
`<U> Pointer<U>`	`as(Type type)` Cast this pointer to another pointer type Synonym of `as(Class)` The following C code : `T* pointerT = ...; U* pointerU = (U*)pointerT;` Can be translated to the following Java code : `Pointer<T> pointerT = ...; Pointer<U> pointerU = pointerT.as(U.class);`
`<R> DynamicFunction<R>`	`asDynamicFunction(Convention.Style callingConvention, Type returnType, Type... parameterTypes)` Cast this pointer as a function pointer to a function that returns the specified return type and takes the specified parameter types.
`NativeList<T>`	`asList()` Create a `Pointer.ListType.FixedCapacity` native list that uses this pointer as storage (and has this pointer's pointed valid elements as initial content).
`NativeList<T>`	`asList(Pointer.ListType type)` Create a native list that uses this pointer as initial storage (and has this pointer's pointed valid elements as initial content).
`Pointer<?>`	`asUntyped()` Cast this pointer to an untyped pointer.
`void`	`clearBytes(long length)` Write zero bytes to the first length bytes pointed by this pointer
`void`	`clearBytesAtOffset(long byteOffset, long length, byte value)` Write a byte `value` to each of the `length` bytes at the address pointed to by this pointer shifted by a `byteOffset`
`void`	`clearValidBytes()` Write zero bytes to all of the valid bytes pointed by this pointer
`Pointer<T>`	`clone()` Creates a copy of the pointed memory location (allocates a new area of memory) and returns a pointer to it.
`int`	`compareBytes(Pointer<?> other, long byteCount)` Compare the byteCount bytes at the memory location pointed by this pointer to the byteCount bytes at the memory location pointer by other using the C memcmp function.
`int`	`compareBytesAtOffset(long byteOffset, Pointer<?> other, long otherByteOffset, long byteCount)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues)
`int`	`compareTo(Pointer<?> p)` Compare to another pointer based on pointed addresses.
`Pointer<T>`	`copyBytesAtOffsetTo(long byteOffset, Pointer<?> destination, long byteOffsetInDestination, long byteCount)` Deprecated.
`Pointer<T>`	`copyBytesTo(Pointer<?> destination, long byteCount)` Deprecated.
`Pointer<T>`	`copyTo(Pointer<?> destination)` Copy remaining bytes from this pointer to a destination using the memcpy C function (see `copyBytesTo(Pointer, long)`, `getValidBytes()`)
`Pointer<T>`	`copyTo(Pointer<?> destination, long elementCount)` Copy remaining elements from this pointer to a destination using the memcpy C function (see `copyBytesAtOffsetTo(long, Pointer, long, long)`, `getValidBytes()`)
`boolean`	`equals(Object obj)` Test equality of the pointer using the address.
`Pointer<T>`	`find(Pointer<?> needle)` Find the first appearance of the sequence of valid bytes pointed by needle in the memory area pointed to by this bounded pointer (behaviour equivalent to memmem, which is used underneath on platforms where it is available)
`Pointer<T>`	`findByte(long byteOffset, byte value, long searchLength)` Find the first occurrence of a value in the memory block of length searchLength bytes pointed by this pointer shifted by a byteOffset
`Pointer<T>`	`findLast(Pointer<?> needle)` Find the last appearance of the sequence of valid bytes pointed by needle in the memory area pointed to by this bounded pointer (also see `find(Pointer)`).
`T`	`get()` Dereference this pointer (*ptr).
`T`	`get(long index)` Gets the n-th element from this pointer.
`static <T> T`	`get(Pointer<T> pointer)` Returns null if pointer is null, otherwise dereferences the pointer (calls pointer.get()).
`static long`	`getAddress(NativeObject instance, Class targetType)` Get the address of a native object, specifying the type of the pointer's target (same as `getPointer(instance, targetType).getPeer()`, see `getPointer(NativeObject, Type)`).
`Object`	`getArray()` Read the array of remaining elements from the pointed memory location.
`Object`	`getArray(int length)` Read an array of elements from the pointed memory location.
`Object`	`getArrayAtOffset(long byteOffset, int length)` Read an array of elements from the pointed memory location shifted by a byte offset.
`abstract boolean`	`getBoolean()` Read a boolean value from the pointed memory location
`boolean`	`getBooleanAtIndex(long valueIndex)` Read the nth contiguous boolean value from the pointed memory location.
`abstract boolean`	`getBooleanAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getBoolean()` over this method.
`boolean[]`	`getBooleans()` Read the array of remaining boolean values from the pointed memory location
`boolean[]`	`getBooleans(int length)` Read an array of boolean values of the specified length from the pointed memory location
`boolean[]`	`getBooleansAtOffset(long byteOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getBooleans(int)` over this method.
`<B extends Buffer> B`	`getBuffer()` Read the NIO `Buffer` of remaining elements from the pointed memory location.
`<B extends Buffer> B`	`getBuffer(int length)` Read an NIO `Buffer` of elements from the pointed memory location.
`<B extends Buffer> B`	`getBufferAtOffset(long byteOffset, int length)` Read an NIO `Buffer` of elements from the pointed memory location shifted by a byte offset.
`abstract byte`	`getByte()` Read a byte value from the pointed memory location
`byte`	`getByteAtIndex(long valueIndex)` Read the nth contiguous byte value from the pointed memory location.
`abstract byte`	`getByteAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getByte()` over this method.
`ByteBuffer`	`getByteBuffer()` Get a direct buffer of byte values that points to this pointer's target memory locations
`ByteBuffer`	`getByteBuffer(long length)` Get a direct buffer of byte values of the specified length that points to this pointer's target memory location
`ByteBuffer`	`getByteBufferAtOffset(long byteOffset, long length)` Get a direct buffer of byte values of the specified length that points to this pointer's target memory location shifted by a byte offset
`byte[]`	`getBytes()` Read the array of remaining byte values from the pointed memory location
`void`	`getBytes(byte[] dest)` Read byte values into the specified destination array from the pointed memory location
`void`	`getBytes(ByteBuffer dest)` Read byte values into the specified destination buffer from the pointed memory location
`byte[]`	`getBytes(int length)` Read an array of byte values of the specified length from the pointed memory location
`void`	`getBytesAtOffset(long byteOffset, byte[] dest, int destOffset, int length)` Read length byte values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
`byte[]`	`getBytesAtOffset(long byteOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getBytes(int)` over this method.
`abstract char`	`getChar()` Read a char value from the pointed memory location
`char`	`getCharAtIndex(long valueIndex)` Read the nth contiguous char value from the pointed memory location.
`abstract char`	`getCharAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getChar()` over this method.
`char[]`	`getChars()` Read the array of remaining char values from the pointed memory location
`char[]`	`getChars(int length)` Read an array of char values of the specified length from the pointed memory location
`char[]`	`getCharsAtOffset(long byteOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getChars(int)` over this method.
`long`	`getCLong()` Read a CLong value from the pointed memory location
`long`	`getCLongAtIndex(long valueIndex)` Read the nth contiguous CLong value from the pointed memory location.
`long`	`getCLongAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getCLong()` over this method.
`long[]`	`getCLongs()` Read the array of remaining CLong values from the pointed memory location
`long[]`	`getCLongs(int arrayLength)` Read an array of CLong values of the specified length from the pointed memory location
`long[]`	`getCLongsAtOffset(long byteOffset, int arrayLength)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getCLongs(int)` over this method.
`String`	`getCString()` Read a C string using the default charset from the pointed memory location (see `Pointer.StringType.C`).
`String`	`getCStringAtOffset(long byteOffset)` Read a C string using the default charset from the pointed memory location shifted by a byte offset (see `Pointer.StringType.C`).
`abstract double`	`getDouble()` Read a double value from the pointed memory location
`double`	`getDoubleAtIndex(long valueIndex)` Read the nth contiguous double value from the pointed memory location.
`abstract double`	`getDoubleAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getDouble()` over this method.
`DoubleBuffer`	`getDoubleBuffer()` Get a direct buffer of double values that points to this pointer's target memory locations
`DoubleBuffer`	`getDoubleBuffer(long length)` Get a direct buffer of double values of the specified length that points to this pointer's target memory location
`DoubleBuffer`	`getDoubleBufferAtOffset(long byteOffset, long length)` Get a direct buffer of double values of the specified length that points to this pointer's target memory location shifted by a byte offset
`double[]`	`getDoubles()` Read the array of remaining double values from the pointed memory location
`void`	`getDoubles(double[] dest)` Read double values into the specified destination array from the pointed memory location
`void`	`getDoubles(DoubleBuffer dest)` Read double values into the specified destination buffer from the pointed memory location
`double[]`	`getDoubles(int length)` Read an array of double values of the specified length from the pointed memory location
`void`	`getDoublesAtOffset(long byteOffset, double[] dest, int destOffset, int length)` Read length double values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
`double[]`	`getDoublesAtOffset(long byteOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getDoubles(int)` over this method.
`abstract float`	`getFloat()` Read a float value from the pointed memory location
`float`	`getFloatAtIndex(long valueIndex)` Read the nth contiguous float value from the pointed memory location.
`abstract float`	`getFloatAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getFloat()` over this method.
`FloatBuffer`	`getFloatBuffer()` Get a direct buffer of float values that points to this pointer's target memory locations
`FloatBuffer`	`getFloatBuffer(long length)` Get a direct buffer of float values of the specified length that points to this pointer's target memory location
`FloatBuffer`	`getFloatBufferAtOffset(long byteOffset, long length)` Get a direct buffer of float values of the specified length that points to this pointer's target memory location shifted by a byte offset
`float[]`	`getFloats()` Read the array of remaining float values from the pointed memory location
`void`	`getFloats(float[] dest)` Read float values into the specified destination array from the pointed memory location
`void`	`getFloats(FloatBuffer dest)` Read float values into the specified destination buffer from the pointed memory location
`float[]`	`getFloats(int length)` Read an array of float values of the specified length from the pointed memory location
`void`	`getFloatsAtOffset(long byteOffset, float[] dest, int destOffset, int length)` Read length float values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
`float[]`	`getFloatsAtOffset(long byteOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getFloats(int)` over this method.
`abstract int`	`getInt()` Read a int value from the pointed memory location
`int`	`getIntAtIndex(long valueIndex)` Read the nth contiguous int value from the pointed memory location.
`abstract int`	`getIntAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getInt()` over this method.
`IntBuffer`	`getIntBuffer()` Get a direct buffer of int values that points to this pointer's target memory locations
`IntBuffer`	`getIntBuffer(long length)` Get a direct buffer of int values of the specified length that points to this pointer's target memory location
`IntBuffer`	`getIntBufferAtOffset(long byteOffset, long length)` Get a direct buffer of int values of the specified length that points to this pointer's target memory location shifted by a byte offset
`long`	`getIntegralAtOffset(long byteOffset, int integralSize)`
`int[]`	`getInts()` Read the array of remaining int values from the pointed memory location
`int[]`	`getInts(int length)` Read an array of int values of the specified length from the pointed memory location
`void`	`getInts(int[] dest)` Read int values into the specified destination array from the pointed memory location
`void`	`getInts(IntBuffer dest)` Read int values into the specified destination buffer from the pointed memory location
`int[]`	`getIntsAtOffset(long byteOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getInts(int)` over this method.
`void`	`getIntsAtOffset(long byteOffset, int[] dest, int destOffset, int length)` Read length int values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
`PointerIO<T>`	`getIO()` Get the PointerIO instance used by this pointer to get and set pointed values.
`abstract long`	`getLong()` Read a long value from the pointed memory location
`long`	`getLongAtIndex(long valueIndex)` Read the nth contiguous long value from the pointed memory location.
`abstract long`	`getLongAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getLong()` over this method.
`LongBuffer`	`getLongBuffer()` Get a direct buffer of long values that points to this pointer's target memory locations
`LongBuffer`	`getLongBuffer(long length)` Get a direct buffer of long values of the specified length that points to this pointer's target memory location
`LongBuffer`	`getLongBufferAtOffset(long byteOffset, long length)` Get a direct buffer of long values of the specified length that points to this pointer's target memory location shifted by a byte offset
`long[]`	`getLongs()` Read the array of remaining long values from the pointed memory location
`long[]`	`getLongs(int length)` Read an array of long values of the specified length from the pointed memory location
`void`	`getLongs(long[] dest)` Read long values into the specified destination array from the pointed memory location
`void`	`getLongs(LongBuffer dest)` Read long values into the specified destination buffer from the pointed memory location
`long[]`	`getLongsAtOffset(long byteOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getLongs(int)` over this method.
`void`	`getLongsAtOffset(long byteOffset, long[] dest, int destOffset, int length)` Read length long values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
`<O extends NativeObject> O`	`getNativeObject(Class<O> type)` Read a native object value from the pointed memory location
`<O extends NativeObject> O`	`getNativeObject(Type type)` Read a native object value from the pointed memory location
`<O extends NativeObject> O`	`getNativeObjectAtOffset(long byteOffset, Class<O> type)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getNativeObject(Class)` over this method.
`<O extends NativeObject> O`	`getNativeObjectAtOffset(long byteOffset, Type type)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getNativeObject(Type)` over this method.
`long`	`getPeer()` Get the address of the memory pointed to by this pointer ("cast this pointer to long", in C jargon).
`static long`	`getPeer(Pointer<?> pointer)` Get a pointer's peer (see `getPeer()`), or zero if the pointer is null.
`Pointer<?>`	`getPointer()` Deprecated. Avoid using untyped pointers, if possible.
`<U> Pointer<U>`	`getPointer(Class<U> c)` Read a pointer value from the pointed memory location.
`static <N extends NativeObject> Pointer<N>`	`getPointer(N instance)` Get a pointer to a native object (C++ or ObjectiveC class, struct, union, callback...)
`static <N extends NativeObjectInterface> Pointer<N>`	`getPointer(N instance)` Get a pointer to a native object (C++ or ObjectiveC class, struct, union, callback...)
`static <R extends NativeObject> Pointer<R>`	`getPointer(NativeObject instance, Type targetType)` Get a pointer to a native object, specifying the type of the pointer's target.
`<U> Pointer<U>`	`getPointer(PointerIO<U> pio)` Read a pointer value from the pointed memory location
`Pointer<?>`	`getPointerAtIndex(long valueIndex)` Read the nth contiguous pointer value from the pointed memory location.
`Pointer<?>`	`getPointerAtOffset(long byteOffset)` Read a pointer value from the pointed memory location shifted by a byte offset
`<U> Pointer<U>`	`getPointerAtOffset(long byteOffset, Class<U> c)` Read a pointer value from the pointed memory location shifted by a byte offset
`<U> Pointer<U>`	`getPointerAtOffset(long byteOffset, PointerIO<U> pio)` Read a pointer value from the pointed memory location shifted by a byte offset
`<U> Pointer<U>`	`getPointerAtOffset(long byteOffset, Type t)` Read a pointer value from the pointed memory location shifted by a byte offset
`Pointer<?>[]`	`getPointers()` Deprecated. Use a typed version instead : `getPointersAtOffset(long, int, Type)`, `getPointersAtOffset(long, int, Class)` or `getPointersAtOffset(long, int, PointerIO)`
`Pointer<?>[]`	`getPointers(int arrayLength)` Deprecated. Use a typed version instead : `getPointersAtOffset(long, int, Type)`, `getPointersAtOffset(long, int, Class)` or `getPointersAtOffset(long, int, PointerIO)`
`Pointer<?>[]`	`getPointersAtOffset(long byteOffset, int arrayLength)` Deprecated. Use a typed version instead : `getPointersAtOffset(long, int, Type)`, `getPointersAtOffset(long, int, Class)` or `getPointersAtOffset(long, int, PointerIO)`
`<U> Pointer<U>[]`	`getPointersAtOffset(long byteOffset, int arrayLength, Class<U> t)` Read an array of pointer values from the pointed memory location shifted by a byte offset
`<U> Pointer<U>[]`	`getPointersAtOffset(long byteOffset, int arrayLength, PointerIO pio)` Read an array of pointer values from the pointed memory location shifted by a byte offset
`<U> Pointer<U>[]`	`getPointersAtOffset(long byteOffset, int arrayLength, Type t)` Read an array of pointer values from the pointed memory location shifted by a byte offset
`Pointer<Pointer<T>>`	`getReference()` Returns a pointer to this pointer.
`abstract short`	`getShort()` Read a short value from the pointed memory location
`short`	`getShortAtIndex(long valueIndex)` Read the nth contiguous short value from the pointed memory location.
`abstract short`	`getShortAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getShort()` over this method.
`ShortBuffer`	`getShortBuffer()` Get a direct buffer of short values that points to this pointer's target memory locations
`ShortBuffer`	`getShortBuffer(long length)` Get a direct buffer of short values of the specified length that points to this pointer's target memory location
`ShortBuffer`	`getShortBufferAtOffset(long byteOffset, long length)` Get a direct buffer of short values of the specified length that points to this pointer's target memory location shifted by a byte offset
`short[]`	`getShorts()` Read the array of remaining short values from the pointed memory location
`short[]`	`getShorts(int length)` Read an array of short values of the specified length from the pointed memory location
`void`	`getShorts(short[] dest)` Read short values into the specified destination array from the pointed memory location
`void`	`getShorts(ShortBuffer dest)` Read short values into the specified destination buffer from the pointed memory location
`short[]`	`getShortsAtOffset(long byteOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getShorts(int)` over this method.
`void`	`getShortsAtOffset(long byteOffset, short[] dest, int destOffset, int length)` Read length short values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
`long`	`getSizeT()` Read a SizeT value from the pointed memory location
`long`	`getSizeTAtIndex(long valueIndex)` Read the nth contiguous SizeT value from the pointed memory location.
`long`	`getSizeTAtOffset(long byteOffset)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getSizeT()` over this method.
`long[]`	`getSizeTs()` Read the array of remaining SizeT values from the pointed memory location
`long[]`	`getSizeTs(int arrayLength)` Read an array of SizeT values of the specified length from the pointed memory location
`long[]`	`getSizeTsAtOffset(long byteOffset, int arrayLength)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `getSizeTs(int)` over this method.
`String`	`getString(Pointer.StringType type)` Read a native string from the pointed memory location using the default charset.
`String`	`getString(Pointer.StringType type, Charset charset)` Read a native string from the pointed memory location, using the provided charset or the system's default if not provided.
`String`	`getStringAtOffset(long byteOffset, Pointer.StringType type, Charset charset)` Read a native string from the pointed memory location shifted by a byte offset, using the provided charset or the system's default if not provided.
`long`	`getTargetSize()` Get the unitary size of the pointed elements in bytes.
`Type`	`getTargetType()` Get the type of pointed elements.
`long`	`getValidBytes()` Get the amount of memory known to be valid from this pointer, or -1 if it is unknown.
`long`	`getValidElements()` Get the amount of memory known to be valid from this pointer (expressed in elements of the target type, see `getTargetType()`) or -1 if it is unknown.
`String`	`getWideCString()` Read a WideC string using the default charset from the pointed memory location (see `Pointer.StringType.WideC`).
`String`	`getWideCStringAtOffset(long byteOffset)` Read a WideC string using the default charset from the pointed memory location shifted by a byte offset (see `Pointer.StringType.WideC`).
`int`	`hashCode()` Compute a hash code based on pointed address.
`static <E extends Enum<E>> Type`	`intEnumType(Class<? extends IntValuedEnum<E>> targetType)` Create a `IntValuedEnum<T>` type.
`boolean`	`isAligned()` Check that the pointer's peer is aligned to the target type alignment.
`boolean`	`isAligned(long alignment)` Check that the pointer's peer is aligned to the given alignment.
`abstract boolean`	`isOrdered()` Whether this pointer reads data in the system's native byte order or not.
`ListIterator<T>`	`iterator()` Returns an iterator over the elements pointed by this pointer.
`Pointer<T>`	`moveBytesAtOffsetTo(long byteOffset, Pointer<?> destination, long byteOffsetInDestination, long byteCount)` Deprecated.
`Pointer<T>`	`moveBytesTo(Pointer<?> destination)` Copy all valid bytes from the memory location indicated by this pointer to that of another pointer, using the memmove C function.
`Pointer<T>`	`moveBytesTo(Pointer<?> destination, long byteCount)` Copy bytes from the memory location indicated by this pointer to that of another pointer, using the memmove C function.
`Pointer<T>`	`next()` Returns a pointer to the next target.
`Pointer<T>`	`next(long delta)` Returns a pointer to the n-th next (or previous) target.
`Pointer<T>`	`offset(long byteOffset)` Returns a pointer which address value was obtained by this pointer's by adding a byte offset.
`ByteOrder`	`order()` Get the byte order (endianness) of this pointer.
`Pointer<T>`	`order(ByteOrder order)` Create a view of this pointer that has the byte order provided in argument, or return this if this pointer already uses the requested byte order.
`static <N extends NativeObject> Pointer<N>`	`pointerTo(N instance)` Deprecated. Will be removed in a future version, please use `getPointer(NativeObject)` instead.
`static Pointer<?>`	`pointerToAddress(long peer)` Deprecated.
`static <P> Pointer<P>`	`pointerToAddress(long peer, Class<P> targetClass)` Deprecated.
`static <P> Pointer<P>`	`pointerToAddress(long peer, Class<P> targetClass, Pointer.Releaser releaser)` Create a pointer out of a native memory address
`static Pointer<?>`	`pointerToAddress(long peer, long size)` Deprecated.
`static Pointer<?>`	`pointerToAddress(long peer, long size, Pointer.Releaser releaser)` Create a pointer out of a native memory address
`static <P> Pointer<P>`	`pointerToAddress(long peer, long size, PointerIO<P> io, Pointer.Releaser releaser)` Create a pointer out of a native memory address
`static Pointer<?>`	`pointerToAddress(long peer, Pointer.Releaser releaser)` Deprecated.
`static <P> Pointer<P>`	`pointerToAddress(long peer, PointerIO<P> io)` Create a pointer out of a native memory address
`static <P> Pointer<P>`	`pointerToAddress(long peer, Type targetType)` Deprecated.
`static <P> Pointer<P>`	`pointerToAddress(long peer, Type targetType, Pointer.Releaser releaser)` Create a pointer out of a native memory address
`static <T> Pointer<T>`	`pointerToArray(Object array)` Allocate enough memory for array.length values, copy the values of the array provided as argument into it and return a pointer to that memory.
`static Pointer<Boolean>`	`pointerToBoolean(boolean value)` Allocate enough memory for a single boolean value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<Boolean>`	`pointerToBooleans(boolean... values)` Allocate enough memory for values.length boolean values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Pointer<Boolean>>`	`pointerToBooleans(boolean[][] values)` Allocate enough memory for all the values in the 2D boolean array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Boolean>>>`	`pointerToBooleans(boolean[][][] values)` Allocate enough memory for all the values in the 3D boolean array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<?>`	`pointerToBuffer(Buffer buffer)` Create a pointer to the memory location used by a direct NIO buffer.
`static Pointer<Byte>`	`pointerToByte(byte value)` Allocate enough memory for a single byte value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<Byte>`	`pointerToBytes(byte... values)` Allocate enough memory for values.length byte values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Pointer<Byte>>`	`pointerToBytes(byte[][] values)` Allocate enough memory for all the values in the 2D byte array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Byte>>>`	`pointerToBytes(byte[][][] values)` Allocate enough memory for all the values in the 3D byte array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Byte>`	`pointerToBytes(ByteBuffer buffer)` Create a pointer to the memory location used by a direct NIO ByteBuffer.
`static Pointer<Character>`	`pointerToChar(char value)` Allocate enough memory for a single char value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<Character>`	`pointerToChars(char... values)` Allocate enough memory for values.length char values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Pointer<Character>>`	`pointerToChars(char[][] values)` Allocate enough memory for all the values in the 2D char array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Character>>>`	`pointerToChars(char[][][] values)` Allocate enough memory for all the values in the 3D char array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Character>`	`pointerToChars(CharBuffer buffer)` Create a pointer to the memory location used by a direct NIO CharBuffer.
`static Pointer<CLong>`	`pointerToCLong(CLong value)` Allocate enough memory for a single CLong value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<CLong>`	`pointerToCLong(long value)` Allocate enough memory for a single CLong value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<CLong>`	`pointerToCLongs(CLong... values)` Allocate enough memory for values.length CLong values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<CLong>`	`pointerToCLongs(int[] values)` Allocate enough memory for values.length CLong values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<CLong>`	`pointerToCLongs(long... values)` Allocate enough memory for values.length CLong values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Byte>`	`pointerToCString(String string)` Allocate memory and write a C string to it, using the system's default charset to convert the string.
`static Pointer<Pointer<Byte>>`	`pointerToCStrings(String... strings)` Allocate an array of pointers to strings.
`static Pointer<Double>`	`pointerToDouble(double value)` Allocate enough memory for a single double value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<Double>`	`pointerToDoubles(double... values)` Allocate enough memory for values.length double values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Pointer<Double>>`	`pointerToDoubles(double[][] values)` Allocate enough memory for all the values in the 2D double array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Double>>>`	`pointerToDoubles(double[][][] values)` Allocate enough memory for all the values in the 3D double array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Double>`	`pointerToDoubles(DoubleBuffer buffer)` Create a pointer to the memory location used by a direct NIO DoubleBuffer.
`static <E extends Enum<E>> Pointer<IntValuedEnum<E>>`	`pointerToEnum(IntValuedEnum<E> instance)` Get a pointer to an enum.
`static Pointer<Float>`	`pointerToFloat(float value)` Allocate enough memory for a single float value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<Float>`	`pointerToFloats(float... values)` Allocate enough memory for values.length float values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Pointer<Float>>`	`pointerToFloats(float[][] values)` Allocate enough memory for all the values in the 2D float array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Float>>>`	`pointerToFloats(float[][][] values)` Allocate enough memory for all the values in the 3D float array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Float>`	`pointerToFloats(FloatBuffer buffer)` Create a pointer to the memory location used by a direct NIO FloatBuffer.
`static Pointer<Integer>`	`pointerToInt(int value)` Allocate enough memory for a single int value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<Integer>`	`pointerToInts(int... values)` Allocate enough memory for values.length int values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Pointer<Integer>>`	`pointerToInts(int[][] values)` Allocate enough memory for all the values in the 2D int array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Integer>>>`	`pointerToInts(int[][][] values)` Allocate enough memory for all the values in the 3D int array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Integer>`	`pointerToInts(IntBuffer buffer)` Create a pointer to the memory location used by a direct NIO IntBuffer.
`static Pointer<Long>`	`pointerToLong(long value)` Allocate enough memory for a single long value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<Long>`	`pointerToLongs(long... values)` Allocate enough memory for values.length long values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Pointer<Long>>`	`pointerToLongs(long[][] values)` Allocate enough memory for all the values in the 2D long array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Long>>>`	`pointerToLongs(long[][][] values)` Allocate enough memory for all the values in the 3D long array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Long>`	`pointerToLongs(LongBuffer buffer)` Create a pointer to the memory location used by a direct NIO LongBuffer.
`static <T> Pointer<Pointer<T>>`	`pointerToPointer(Pointer<T> value)` Allocate enough memory for a single pointer value, copy the value provided in argument into it and return a pointer to that memory.
`static <T> Pointer<Pointer<T>>`	`pointerToPointers(Pointer<T>... values)` Allocate enough memory for values.length pointer values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Short>`	`pointerToShort(short value)` Allocate enough memory for a single short value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<Short>`	`pointerToShorts(short... values)` Allocate enough memory for values.length short values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<Pointer<Short>>`	`pointerToShorts(short[][] values)` Allocate enough memory for all the values in the 2D short array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Pointer<Pointer<Short>>>`	`pointerToShorts(short[][][] values)` Allocate enough memory for all the values in the 3D short array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
`static Pointer<Short>`	`pointerToShorts(ShortBuffer buffer)` Create a pointer to the memory location used by a direct NIO ShortBuffer.
`static Pointer<SizeT>`	`pointerToSizeT(long value)` Allocate enough memory for a single SizeT value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<SizeT>`	`pointerToSizeT(SizeT value)` Allocate enough memory for a single SizeT value, copy the value provided in argument into it and return a pointer to that memory.
`static Pointer<SizeT>`	`pointerToSizeTs(int[] values)` Allocate enough memory for values.length SizeT values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<SizeT>`	`pointerToSizeTs(long... values)` Allocate enough memory for values.length SizeT values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<SizeT>`	`pointerToSizeTs(SizeT... values)` Allocate enough memory for values.length SizeT values, copy the values provided as argument into it and return a pointer to that memory.
`static Pointer<?>`	`pointerToString(String string, Pointer.StringType type, Charset charset)` Allocate memory and write a string to it, using the system's default charset to convert the string (See `Pointer.StringType` for details on the supported types).
`static Pointer<Character>`	`pointerToWideCString(String string)` Allocate memory and write a WideC string to it, using the system's default charset to convert the string.
`static Pointer<Pointer<Character>>`	`pointerToWideCStrings(String... strings)` Allocate an array of pointers to strings.
`static Type`	`pointerType(Type targetType)` Create a `Pointer<T>` type.
`void`	`release()` Manually release the memory pointed by this pointer if it was allocated on the Java side.
`static void`	`release(Pointer... pointers)` Release pointers, if they're not null (see `release()`).
`T`	`set(long index, T value)` Sets the n-th element from this pointer, and return it (different behaviour from `List.set(int, Object)` which returns the old value of that element !!!).
`T`	`set(T value)` Assign a value to the pointed memory location, and return it (different behaviour from `List.set(int, Object)` which returns the old value of that element !!!).
`Pointer<T>`	`setArray(Object array)` Write an array of elements to the pointed memory location.
`Pointer<T>`	`setArrayAtOffset(long byteOffset, Object array)` Write an array of elements to the pointed memory location shifted by a byte offset.
`abstract Pointer<T>`	`setBoolean(boolean value)` Write a boolean value to the pointed memory location
`Pointer<T>`	`setBooleanAtIndex(long valueIndex, boolean value)` Write the nth contiguous boolean value to the pointed memory location.
`abstract Pointer<T>`	`setBooleanAtOffset(long byteOffset, boolean value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setBoolean(boolean)` over this method.
`Pointer<T>`	`setBooleans(boolean[] values)` Write an array of boolean values of the specified length to the pointed memory location
`Pointer<T>`	`setBooleansAtOffset(long byteOffset, boolean[] values)` Write an array of boolean values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setBooleansAtOffset(long byteOffset, boolean[] values, int valuesOffset, int length)` Write an array of boolean values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
`abstract Pointer<T>`	`setByte(byte value)` Write a byte value to the pointed memory location
`Pointer<T>`	`setByteAtIndex(long valueIndex, byte value)` Write the nth contiguous byte value to the pointed memory location.
`abstract Pointer<T>`	`setByteAtOffset(long byteOffset, byte value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setByte(byte)` over this method.
`Pointer<T>`	`setBytes(byte[] values)` Write an array of byte values of the specified length to the pointed memory location
`Pointer<T>`	`setBytes(ByteBuffer values)` Write a buffer of byte values of the specified length to the pointed memory location
`Pointer<T>`	`setBytesAtOffset(long byteOffset, byte[] values)` Write an array of byte values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setBytesAtOffset(long byteOffset, byte[] values, int valuesOffset, int length)` Write an array of byte values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
`Pointer<T>`	`setBytesAtOffset(long byteOffset, ByteBuffer values)` Write a buffer of byte values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setBytesAtOffset(long byteOffset, ByteBuffer values, long valuesOffset, long length)` Write a buffer of byte values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
`abstract Pointer<T>`	`setChar(char value)` Write a char value to the pointed memory location
`Pointer<T>`	`setCharAtIndex(long valueIndex, char value)` Write the nth contiguous char value to the pointed memory location.
`abstract Pointer<T>`	`setCharAtOffset(long byteOffset, char value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setChar(char)` over this method.
`Pointer<T>`	`setChars(char[] values)` Write an array of char values of the specified length to the pointed memory location
`Pointer<T>`	`setChars(CharBuffer values)` Write a buffer of char values of the specified length to the pointed memory location
`Pointer<T>`	`setCharsAtOffset(long byteOffset, char[] values)` Write an array of char values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setCharsAtOffset(long byteOffset, char[] values, int valuesOffset, int length)` Write an array of char values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
`Pointer<T>`	`setCharsAtOffset(long byteOffset, CharBuffer values)` Write a buffer of char values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setCharsAtOffset(long byteOffset, CharBuffer values, long valuesOffset, long length)` Write a buffer of char values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
`Pointer<T>`	`setCLong(CLong value)` Write a CLong value to the pointed memory location
`Pointer<T>`	`setCLong(long value)` Write a CLong value to the pointed memory location
`Pointer<T>`	`setCLongAtIndex(long valueIndex, long value)` Write the nth contiguous CLong value to the pointed memory location.
`Pointer<T>`	`setCLongAtOffset(long byteOffset, CLong value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setCLong(CLong)` over this method.
`Pointer<T>`	`setCLongAtOffset(long byteOffset, long value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setCLong(long)` over this method.
`Pointer<T>`	`setCLongs(CLong[] values)` Write an array of CLong values to the pointed memory location
`Pointer<T>`	`setCLongs(int[] values)` Write an array of CLong values to the pointed memory location
`Pointer<T>`	`setCLongs(long[] values)` Write an array of CLong values to the pointed memory location
`Pointer<T>`	`setCLongsAtOffset(long byteOffset, CLong... values)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setCLongs(CLong...)` over this method.
`abstract Pointer<T>`	`setCLongsAtOffset(long byteOffset, int[] values)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setCLongs(int[])` over this method.
`Pointer<T>`	`setCLongsAtOffset(long byteOffset, long[] values)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setCLongs(long[])` over this method.
`abstract Pointer<T>`	`setCLongsAtOffset(long byteOffset, long[] values, int valuesOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setCLongs(long[])` over this method.
`Pointer<T>`	`setCString(String s)` Write a C string using the default charset to the pointed memory location (see `Pointer.StringType.C`).
`Pointer<T>`	`setCStringAtOffset(long byteOffset, String s)` Write a C string using the default charset to the pointed memory location shifted by a byte offset (see `Pointer.StringType.C`).
`abstract Pointer<T>`	`setDouble(double value)` Write a double value to the pointed memory location
`Pointer<T>`	`setDoubleAtIndex(long valueIndex, double value)` Write the nth contiguous double value to the pointed memory location.
`abstract Pointer<T>`	`setDoubleAtOffset(long byteOffset, double value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setDouble(double)` over this method.
`Pointer<T>`	`setDoubles(double[] values)` Write an array of double values of the specified length to the pointed memory location
`Pointer<T>`	`setDoubles(DoubleBuffer values)` Write a buffer of double values of the specified length to the pointed memory location
`Pointer<T>`	`setDoublesAtOffset(long byteOffset, double[] values)` Write an array of double values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setDoublesAtOffset(long byteOffset, double[] values, int valuesOffset, int length)` Write an array of double values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
`Pointer<T>`	`setDoublesAtOffset(long byteOffset, DoubleBuffer values)` Write a buffer of double values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setDoublesAtOffset(long byteOffset, DoubleBuffer values, long valuesOffset, long length)` Write a buffer of double values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
`abstract Pointer<T>`	`setFloat(float value)` Write a float value to the pointed memory location
`Pointer<T>`	`setFloatAtIndex(long valueIndex, float value)` Write the nth contiguous float value to the pointed memory location.
`abstract Pointer<T>`	`setFloatAtOffset(long byteOffset, float value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setFloat(float)` over this method.
`Pointer<T>`	`setFloats(float[] values)` Write an array of float values of the specified length to the pointed memory location
`Pointer<T>`	`setFloats(FloatBuffer values)` Write a buffer of float values of the specified length to the pointed memory location
`Pointer<T>`	`setFloatsAtOffset(long byteOffset, float[] values)` Write an array of float values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setFloatsAtOffset(long byteOffset, float[] values, int valuesOffset, int length)` Write an array of float values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
`Pointer<T>`	`setFloatsAtOffset(long byteOffset, FloatBuffer values)` Write a buffer of float values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setFloatsAtOffset(long byteOffset, FloatBuffer values, long valuesOffset, long length)` Write a buffer of float values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
`abstract Pointer<T>`	`setInt(int value)` Write a int value to the pointed memory location
`Pointer<T>`	`setIntAtIndex(long valueIndex, int value)` Write the nth contiguous int value to the pointed memory location.
`abstract Pointer<T>`	`setIntAtOffset(long byteOffset, int value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setInt(int)` over this method.
`Pointer<T>`	`setIntegralAtOffset(long byteOffset, org.bridj.AbstractIntegral value)`
`Pointer<T>`	`setInts(int[] values)` Write an array of int values of the specified length to the pointed memory location
`Pointer<T>`	`setInts(IntBuffer values)` Write a buffer of int values of the specified length to the pointed memory location
`Pointer<T>`	`setIntsAtOffset(long byteOffset, int[] values)` Write an array of int values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setIntsAtOffset(long byteOffset, int[] values, int valuesOffset, int length)` Write an array of int values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
`Pointer<T>`	`setIntsAtOffset(long byteOffset, IntBuffer values)` Write a buffer of int values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setIntsAtOffset(long byteOffset, IntBuffer values, long valuesOffset, long length)` Write a buffer of int values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
`abstract Pointer<T>`	`setLong(long value)` Write a long value to the pointed memory location
`Pointer<T>`	`setLongAtIndex(long valueIndex, long value)` Write the nth contiguous long value to the pointed memory location.
`abstract Pointer<T>`	`setLongAtOffset(long byteOffset, long value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setLong(long)` over this method.
`Pointer<T>`	`setLongs(long[] values)` Write an array of long values of the specified length to the pointed memory location
`Pointer<T>`	`setLongs(LongBuffer values)` Write a buffer of long values of the specified length to the pointed memory location
`Pointer<T>`	`setLongsAtOffset(long byteOffset, long[] values)` Write an array of long values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setLongsAtOffset(long byteOffset, long[] values, int valuesOffset, int length)` Write an array of long values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
`Pointer<T>`	`setLongsAtOffset(long byteOffset, LongBuffer values)` Write a buffer of long values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setLongsAtOffset(long byteOffset, LongBuffer values, long valuesOffset, long length)` Write a buffer of long values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
`<O extends NativeObject> Pointer<T>`	`setNativeObject(O value, Type type)` Write a native object value to the pointed memory location
`Pointer<T>`	`setPointer(Pointer<?> value)` Write a pointer value to the pointed memory location
`Pointer<T>`	`setPointerAtIndex(long valueIndex, Pointer<?> value)` Write the nth contiguous pointer value to the pointed memory location.
`Pointer<T>`	`setPointerAtOffset(long byteOffset, Pointer<?> value)` Write a pointer value to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setPointers(Pointer<?>[] values)` Write an array of pointer values to the pointed memory location
`Pointer<T>`	`setPointersAtOffset(long byteOffset, Pointer<?>[] values)` Write an array of pointer values to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setPointersAtOffset(long byteOffset, Pointer<?>[] values, int valuesOffset, int length)` Write length pointer values from the given array (starting at the given value offset) to the pointed memory location shifted by a byte offset
`abstract Pointer<T>`	`setShort(short value)` Write a short value to the pointed memory location
`Pointer<T>`	`setShortAtIndex(long valueIndex, short value)` Write the nth contiguous short value to the pointed memory location.
`abstract Pointer<T>`	`setShortAtOffset(long byteOffset, short value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setShort(short)` over this method.
`Pointer<T>`	`setShorts(short[] values)` Write an array of short values of the specified length to the pointed memory location
`Pointer<T>`	`setShorts(ShortBuffer values)` Write a buffer of short values of the specified length to the pointed memory location
`Pointer<T>`	`setShortsAtOffset(long byteOffset, short[] values)` Write an array of short values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setShortsAtOffset(long byteOffset, short[] values, int valuesOffset, int length)` Write an array of short values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
`Pointer<T>`	`setShortsAtOffset(long byteOffset, ShortBuffer values)` Write a buffer of short values of the specified length to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setShortsAtOffset(long byteOffset, ShortBuffer values, long valuesOffset, long length)` Write a buffer of short values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
`Pointer<T>`	`setSizeT(long value)` Write a SizeT value to the pointed memory location
`Pointer<T>`	`setSizeT(SizeT value)` Write a SizeT value to the pointed memory location
`Pointer<T>`	`setSizeTAtIndex(long valueIndex, long value)` Write the nth contiguous SizeT value to the pointed memory location.
`Pointer<T>`	`setSizeTAtOffset(long byteOffset, long value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setSizeT(long)` over this method.
`Pointer<T>`	`setSizeTAtOffset(long byteOffset, SizeT value)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setSizeT(SizeT)` over this method.
`Pointer<T>`	`setSizeTs(int[] values)` Write an array of SizeT values to the pointed memory location
`Pointer<T>`	`setSizeTs(long[] values)` Write an array of SizeT values to the pointed memory location
`Pointer<T>`	`setSizeTs(SizeT[] values)` Write an array of SizeT values to the pointed memory location
`abstract Pointer<T>`	`setSizeTsAtOffset(long byteOffset, int[] values)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setSizeTs(int[])` over this method.
`Pointer<T>`	`setSizeTsAtOffset(long byteOffset, long[] values)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setSizeTs(long[])` over this method.
`abstract Pointer<T>`	`setSizeTsAtOffset(long byteOffset, long[] values, int valuesOffset, int length)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setSizeTs(long[])` over this method.
`Pointer<T>`	`setSizeTsAtOffset(long byteOffset, SizeT... values)` Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour `setSizeTs(SizeT...)` over this method.
`Pointer<T>`	`setString(String s, Pointer.StringType type)` Write a native string to the pointed memory location using the default charset.
`Pointer<T>`	`setStringAtOffset(long byteOffset, String s, Pointer.StringType type, Charset charset)` Write a native string to the pointed memory location shifted by a byte offset, using the provided charset or the system's default if not provided.
`Pointer<T>`	`setValues(Buffer values)` Copy values from an NIO buffer to the pointed memory location
`Pointer<T>`	`setValuesAtOffset(long byteOffset, Buffer values)` Copy all values from an NIO buffer to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setValuesAtOffset(long byteOffset, Buffer values, int valuesOffset, int length)` Copy length values from an NIO buffer (beginning at element at valuesOffset index) to the pointed memory location shifted by a byte offset
`Pointer<T>`	`setWideCString(String s)` Write a WideC string using the default charset to the pointed memory location (see `Pointer.StringType.WideC`).
`Pointer<T>`	`setWideCStringAtOffset(long byteOffset, String s)` Write a WideC string using the default charset to the pointed memory location shifted by a byte offset (see `Pointer.StringType.WideC`).
`T[]`	`toArray()` Create an array with all the values in the bounded memory area.
`<U> U[]`	`toArray(U[] array)` Create an array with all the values in the bounded memory area, reusing the provided array if its type is compatible and its size is big enough.
`String`	`toString()`
`void`	`update(long index, T element)` Alias for `set(long, Object)` defined for more natural use from the Scala language.
`void`	`updateBuffer(Buffer buffer)` When a pointer was created with `pointerToBuffer(Buffer)` on a non-direct buffer, a native copy of the buffer data was made.
`Pointer<T>`	`validBytes(long byteCount)` Creates a pointer that has the given number of valid bytes ahead.
`Pointer<T>`	`validElements(long elementCount)` Creates a pointer that has the given number of valid elements ahead.
`Pointer<T>`	`withoutValidityInformation()` Deprecated. Pointers obtained via this method are faster but unsafe and are likely to cause crashes hard to debug if your logic is wrong.
`Pointer<T>`	`withReleaser(Pointer.Releaser beforeDeallocation)` Deprecated. This method can easily be misused and is reserved to advanced users.

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
 - NULL
```
public static final Pointer<?> NULL
```
 The NULL pointer is always Java's null value
 - SIZE
```
public static final int SIZE
```
 Size of a pointer in bytes.
 This is 4 bytes in a 32 bits environment and 8 bytes in a 64 bits environment.
 Note that some 64 bits environments allow for 32 bits JVM execution (using the -d32 command line argument for Sun's JVM, for instance). In that case, Java programs will believe they're executed in a 32 bits environment.
 - defaultAlignment
```
public static final int defaultAlignment
```
 Default alignment used to allocate memory from the static factory methods in Pointer class (any value lower or equal to 1 means no alignment)
- Method Detail
 - pointerType
```
public static Type pointerType(Type targetType)
```
 Create a Pointer<T> type.
 For Instance, Pointer.pointerType(Integer.class) returns a type that represents Pointer<Integer>
 - intEnumType
```
public static <E extends Enum<E>> Type intEnumType(Class<? extends IntValuedEnum<E>> targetType)
```
 Create a IntValuedEnum<T> type.
 For Instance, Pointer.intEnumType(SomeEnum.class) returns a type that represents IntValuedEnum<SomeEnum>
 - release
```
public void release()
```
 Manually release the memory pointed by this pointer if it was allocated on the Java side.
 If the pointer is an offset version of another pointer (using offset(long) or next(long), for instance), this method tries to release the original pointer.
 If the memory was not allocated from the Java side, this method does nothing either.
 If the memory was already successfully released, this throws a RuntimeException.
 
 Throws:
 
 RuntimeException - if the pointer was already released
 - compareTo
```
public int compareTo(Pointer<?> p)
```
 Compare to another pointer based on pointed addresses.
 
 Specified by:
 
 compareTo in interface Comparable<Pointer<?>>
 
 Parameters:
 
 p - other pointer
 
 Returns:
 
 1 if this pointer's address is greater than p's (or if p is null), -1 if the opposite is true, 0 if this and p point to the same memory location.
 - compareBytes
```
public int compareBytes(Pointer<?> other,
 long byteCount)
```
 Compare the byteCount bytes at the memory location pointed by this pointer to the byteCount bytes at the memory location pointer by other using the C memcmp function.
 
 Returns:
 
 0 if the two memory blocks are equal, -1 if this pointer's memory is "less" than the other and 1 otherwise.
 - compareBytesAtOffset
```
public int compareBytesAtOffset(long byteOffset,
 Pointer<?> other,
 long otherByteOffset,
 long byteCount)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues)
 
 Compare the byteCount bytes at the memory location pointed by this pointer shifted by byteOffset to the byteCount bytes at the memory location pointer by other shifted by otherByteOffset using the C memcmp function.
 
 Returns:
 
 0 if the two memory blocks are equal, -1 if this pointer's memory is "less" than the other and 1 otherwise.
 - hashCode
```
public int hashCode()
```
 Compute a hash code based on pointed address.
 
 Overrides:
 
 hashCode in class Object
 - toString
```
public String toString()
```
 Overrides:
 
 toString in class Object
 - offset
```
public Pointer<T> offset(long byteOffset)
```
 Returns a pointer which address value was obtained by this pointer's by adding a byte offset.
 The returned pointer will prevent the memory associated to this pointer from being automatically reclaimed as long as it lives, unless Pointer.release() is called on the originally-allocated pointer.
 
 Parameters:
 
 byteOffset - offset in bytes of the new pointer vs. this pointer. The expression p.offset(byteOffset).getPeer() - p.getPeer() == byteOffset is always true.
 - validBytes
```
public Pointer<T> validBytes(long byteCount)
```
 Creates a pointer that has the given number of valid bytes ahead.
 If the pointer was already bound, the valid bytes must be lower or equal to the current getValidBytes() value.
 - withoutValidityInformation
```
@Deprecated
public Pointer<T> withoutValidityInformation()
```
 Deprecated. Pointers obtained via this method are faster but unsafe and are likely to cause crashes hard to debug if your logic is wrong.
 
 Creates a pointer that forgot any memory validity information.
 Such pointers are typically faster than validity-aware pointers, since they perform less checks at each operation, but they're more prone to crashes if misused.
 - clone
```
public Pointer<T> clone()
```
 Creates a copy of the pointed memory location (allocates a new area of memory) and returns a pointer to it.
 The pointer's bounds must be known (see getValidBytes(), validBytes(long) or validElements(long)).
 
 Overrides:
 
 clone in class Object
 - validElements
```
public Pointer<T> validElements(long elementCount)
```
 Creates a pointer that has the given number of valid elements ahead.
 If the pointer was already bound, elementCount must be lower or equal to the current getValidElements() value.
 - getReference
```
public Pointer<Pointer<T>> getReference()
```
 Returns a pointer to this pointer.
 It will only succeed if this pointer was dereferenced from another pointer.
 Let's take the following C++ code :
```
	int** pp = ...;
	int* p = pp[10];
	int** ref = &p;
	ASSERT(pp == ref);
	 
```
 Here is its equivalent Java code :
```
	Pointer<Pointer<Integer>> pp = ...;
	Pointer<Integer> p = pp.get(10);
	Pointer<Pointer<Integer>> ref = p.getReference();
	assert pp.equals(ref);
	 
```
 - getPeer
```
public final long getPeer()
```
 Get the address of the memory pointed to by this pointer ("cast this pointer to long", in C jargon).
 This is equivalent to the C code (size_t)&pointer
 
 Returns:
 
 Address of the memory pointed to by this pointer
 - allocateDynamicCallback
```
public static <R> Pointer<DynamicFunction<R>> allocateDynamicCallback(DynamicCallback<R> callback,
 Convention.Style callingConvention,
 Type returnType,
 Type... parameterTypes)
```
 Create a native callback which signature corresponds to the provided calling convention, return type and parameter types, and which redirects calls to the provided Java DynamicCallback handler.
 For instance, a callback of C signature double (*)(float, int) that adds its two arguments can be created with :
 Pointer callback = Pointer.allocateDynamicCallback( new DynamicCallback<Integer>() { public Double apply(Object... args) { float a = (Float)args[0]; int b = (Integer)args[1]; return (double)(a + b); } }, null, // Use the platform's default calling convention int.class, // return type float.class, double.class // parameter types );
 For the void return type, you can use Void :
 Pointer callback = Pointer.allocateDynamicCallback( new DynamicCallback<Void>() { public Void apply(Object... args) { ... return null; // Void cannot be instantiated anyway ;-) } }, null, // Use the platform's default calling convention int.class, // return type float.class, double.class // parameter types );
 
 Returns:
 
 Pointer to a native callback that redirects calls to the provided Java callback instance, and that will be destroyed whenever the pointer is released (make sure you keep a reference to it !)
 - as
```
public  Pointer as(PointerIO newIO)
```
 Cast this pointer to another pointer type
 
 Parameters:
 
 newIO -
 - order
```
public Pointer<T> order(ByteOrder order)
```
 Create a view of this pointer that has the byte order provided in argument, or return this if this pointer already uses the requested byte order.
 
 Parameters:
 
 order - byte order (endianness) of the returned pointer
 - order
```
public ByteOrder order()
```
 Get the byte order (endianness) of this pointer.
 - getIO
```
public final PointerIO<T> getIO()
```
 Get the PointerIO instance used by this pointer to get and set pointed values.
 - isOrdered
```
public abstract boolean isOrdered()
```
 Whether this pointer reads data in the system's native byte order or not. See order(), order(ByteOrder)
 - as
```
public  Pointer as(Type type)
```
 Cast this pointer to another pointer type
 Synonym of as(Class)
 The following C code :
 T* pointerT = ...; U* pointerU = (U*)pointerT;
 Can be translated to the following Java code :
 Pointer<T> pointerT = ...; Pointer pointerU = pointerT.as(U.class);
 
 Type Parameters:
 
 U - type of the elements pointed by the returned pointer
 
 Parameters:
 
 type - type of the elements pointed by the returned pointer
 
 Returns:
 
 pointer to type U elements at the same address as this pointer
 - as
```
public  Pointer as(Class type)
```
 Cast this pointer to another pointer type.
 Synonym of as(Type)
 The following C code :
 T* pointerT = ...; U* pointerU = (U*)pointerT;
 Can be translated to the following Java code :
 Pointer<T> pointerT = ...; Pointer pointerU = pointerT.as(U.class); // or pointerT.as(U.class);
 
 Type Parameters:
 
 U - type of the elements pointed by the returned pointer
 
 Parameters:
 
 type - type of the elements pointed by the returned pointer
 
 Returns:
 
 pointer to type U elements at the same address as this pointer
 - asDynamicFunction
```
public <R> DynamicFunction<R> asDynamicFunction(Convention.Style callingConvention,
 Type returnType,
 Type... parameterTypes)
```
 Cast this pointer as a function pointer to a function that returns the specified return type and takes the specified parameter types.
 See for instance the following C code that uses a function pointer :
```
	 double (*ptr)(int, const char*) = someAddress;
 double result = ptr(10, "hello");
 
```
 Its Java equivalent with BridJ is the following :
```
	 DynamicFunction ptr = someAddress.asDynamicFunction(null, double.class, int.class, Pointer.class);
 double result = (Double)ptr.apply(10, pointerToCString("hello"));
 
```
 Also see CRuntime.getDynamicFunctionFactory(org.bridj.NativeLibrary, org.bridj.ann.Convention.Style, java.lang.reflect.Type, java.lang.reflect.Type[]) for more options.
 Parameters:
 
 callingConvention - calling convention used by the function (if null, default is typically Convention.Style.CDecl)
 
 returnType - return type of the function
 
 parameterTypes - parameter types of the function
 - asUntyped
```
public Pointer<?> asUntyped()
```
 Cast this pointer to an untyped pointer.
 Synonym of ptr.as((Class<?>)null).
 See as(Class)
 The following C code :
 T* pointerT = ...; void* pointer = (void*)pointerT;
 Can be translated to the following Java code :
 Pointer<T> pointerT = ...; Pointer<?> pointer = pointerT.asUntyped(); // or pointerT.as((Class<?>)null);
 
 Returns:
 
 untyped pointer pointing to the same address as this pointer
 - getValidBytes
```
public long getValidBytes()
```
 Get the amount of memory known to be valid from this pointer, or -1 if it is unknown.
 Memory validity information is available when the pointer was allocated by BridJ (with allocateBytes(long), for instance), created out of another pointer which memory validity information is available (with offset(long), next(), next(long)) or created from a direct NIO buffer (pointerToBuffer(Buffer), pointerToInts(IntBuffer)...)
 
 Returns:
 
 amount of bytes that can be safely read or written from this pointer, or -1 if this amount is unknown
 - getValidElements
```
public long getValidElements()
```
 Get the amount of memory known to be valid from this pointer (expressed in elements of the target type, see getTargetType()) or -1 if it is unknown.
 Memory validity information is available when the pointer was allocated by BridJ (with allocateBytes(long), for instance), created out of another pointer which memory validity information is available (with offset(long), next(), next(long)) or created from a direct NIO buffer (pointerToBuffer(Buffer), pointerToInts(IntBuffer)...)
 
 Returns:
 
 amount of elements that can be safely read or written from this pointer, or -1 if this amount is unknown
 - iterator
```
public ListIterator<T> iterator()
```
 Returns an iterator over the elements pointed by this pointer.
 If this pointer was allocated from Java with the allocateXXX, pointerToXXX methods (or is a view or a clone of such a pointer), the iteration is safely bounded.
 If this iterator is just a wrapper for a native-allocated pointer (or a view / clone of such a pointer), iteration will go forever (until illegal areas of memory are reached and cause a JVM crash).
 
 Specified by:
 
 iterator in interface Iterable<T>
 - pointerToEnum
```
public static <E extends Enum<E>> Pointer<IntValuedEnum<E>> pointerToEnum(IntValuedEnum<E> instance)
```
 Get a pointer to an enum.
 - pointerTo
```
@Deprecated
public static <N extends NativeObject> Pointer<N> pointerTo(N instance)
```
 Deprecated. Will be removed in a future version, please use getPointer(NativeObject) instead.
 - getPointer
```
public static <N extends NativeObject> Pointer<N> getPointer(N instance)
```
 Get a pointer to a native object (C++ or ObjectiveC class, struct, union, callback...)
 - getPointer
```
public static <N extends NativeObjectInterface> Pointer<N> getPointer(N instance)
```
 Get a pointer to a native object (C++ or ObjectiveC class, struct, union, callback...)
 - getPointer
```
public static <R extends NativeObject> Pointer<R> getPointer(NativeObject instance,
 Type targetType)
```
 Get a pointer to a native object, specifying the type of the pointer's target.
 In C++, the address of the pointer to an object as its canonical class is not always the same as the address of the pointer to the same object cast to one of its parent classes.
 - getAddress
```
public static long getAddress(NativeObject instance,
 Class targetType)
```
 Get the address of a native object, specifying the type of the pointer's target (same as getPointer(instance, targetType).getPeer(), see getPointer(NativeObject, Type)).
 In C++, the address of the pointer to an object as its canonical class is not always the same as the address of the pointer to the same object cast to one of its parent classes.
 - getNativeObjectAtOffset
```
public <O extends NativeObject> O getNativeObjectAtOffset(long byteOffset,
 Type type)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getNativeObject(Type) over this method.
 
 Read a native object value from the pointed memory location shifted by a byte offset
 - setNativeObject
```
public <O extends NativeObject> Pointer<T> setNativeObject(O value,
 Type type)
```
 Write a native object value to the pointed memory location
 - getNativeObjectAtOffset
```
public <O extends NativeObject> O getNativeObjectAtOffset(long byteOffset,
 Class<O> type)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getNativeObject(Class) over this method.
 
 Read a native object value from the pointed memory location shifted by a byte offset
 - getNativeObject
```
public <O extends NativeObject> O getNativeObject(Class<O> type)
```
 Read a native object value from the pointed memory location
 - getNativeObject
```
public <O extends NativeObject> O getNativeObject(Type type)
```
 Read a native object value from the pointed memory location
 - isAligned
```
public boolean isAligned()
```
 Check that the pointer's peer is aligned to the target type alignment.
 
 Returns:
 
 getPeer() % alignment == 0
 
 Throws:
 
 RuntimeException - If the target type of this pointer is unknown
 - isAligned
```
public boolean isAligned(long alignment)
```
 Check that the pointer's peer is aligned to the given alignment. If the pointer has no peer, this method returns true.
 
 Returns:
 
 getPeer() % alignment == 0
 - get
```
public T get()
```
 Dereference this pointer (*ptr).
 Take the following C++ code fragment :
```
 int* array = new int[10];
 for (int index = 0; index < 10; index++, array++) 
 	printf("%i\n", *array);
 
```
 Here is its equivalent in Java :
```
 import static org.bridj.Pointer.*;
 ...
 Pointer<Integer> array = allocateInts(10);
 for (int index = 0; index < 10; index++) { 
 	System.out.println("%i\n".format(array.get()));
 	array = array.next();
	 }
 
```
 Here is a simpler equivalent in Java :
```
 import static org.bridj.Pointer.*;
 ...
 Pointer<Integer> array = allocateInts(10);
 for (int value : array) // array knows its size, so we can iterate on it
 	System.out.println("%i\n".format(value));
 
```
 Throws:
 
 RuntimeException - if called on an untyped Pointer<?> instance (see getTargetType())
 - get
```
public static <T> T get(Pointer<T> pointer)
```
 Returns null if pointer is null, otherwise dereferences the pointer (calls pointer.get()).
 - get
```
public T get(long index)
```
 Gets the n-th element from this pointer.
 This is equivalent to the C/C++ square bracket syntax.
 Take the following C++ code fragment :
```
	int* array = new int[10];
	int index = 5;
	int value = array[index];
 
```
 Here is its equivalent in Java :
```
	import static org.bridj.Pointer.*;
	...
	Pointer<Integer> array = allocateInts(10);
	int index = 5;
	int value = array.get(index);
 
```
 Parameters:
 
 index - offset in pointed elements at which the value should be copied. Can be negative if the pointer was offset and the memory before it is valid.
 
 Throws:
 
 RuntimeException - if called on an untyped Pointer<?> instance (getTargetType())
 - set
```
public T set(T value)
```
 Assign a value to the pointed memory location, and return it (different behaviour from List.set(int, Object) which returns the old value of that element !!!).
 Take the following C++ code fragment :
```
	int* array = new int[10];
	for (int index = 0; index < 10; index++, array++) { 
		int value = index;
array = value;
	}
 
```
 Here is its equivalent in Java :
```
	import static org.bridj.Pointer.*;
	...
	Pointer<Integer> array = allocateInts(10);
	for (int index = 0; index < 10; index++) {
		int value = index;
		array.set(value);
		array = array.next();
	}
 
```
 Returns:
 
 The value that was given (not the old value as in List.set(int, Object) !!!)
 
 Throws:
 
 RuntimeException - if called on a raw and untyped Pointer instance (see asUntyped() and getTargetType())
 - set
```
public T set(long index,
 T value)
```
 Sets the n-th element from this pointer, and return it (different behaviour from List.set(int, Object) which returns the old value of that element !!!).
 This is equivalent to the C/C++ square bracket assignment syntax.
 Take the following C++ code fragment :
```
 float* array = new float[10];
 int index = 5;
 float value = 12;
 array[index] = value;
 
```
 Here is its equivalent in Java :
```
 import static org.bridj.Pointer.*;
 ...
 Pointer<Float> array = allocateFloats(10);
 int index = 5;
 float value = 12;
 array.set(index, value);
 
```
 Parameters:
 
 index - offset in pointed elements at which the value should be copied. Can be negative if the pointer was offset and the memory before it is valid.
 
 value - value to set at pointed memory location
 
 Returns:
 
 The value that was given (not the old value as in List.set(int, Object) !!!)
 
 Throws:
 
 RuntimeException - if called on a raw and untyped Pointer instance (see asUntyped() and getTargetType())
 - getPeer
```
public static long getPeer(Pointer<?> pointer)
```
 Get a pointer's peer (see getPeer()), or zero if the pointer is null.
 - getTargetSize
```
public long getTargetSize()
```
 Get the unitary size of the pointed elements in bytes.
 
 Throws:
 
 RuntimeException - if the target type is unknown (see getTargetType())
 - next
```
public Pointer<T> next()
```
 Returns a pointer to the next target. Same as incrementing a C pointer of delta elements, but creates a new pointer instance.
 
 Returns:
 
 next(1)
 - next
```
public Pointer<T> next(long delta)
```
 Returns a pointer to the n-th next (or previous) target. Same as incrementing a C pointer of delta elements, but creates a new pointer instance.
 
 Returns:
 
 offset(getTargetSize() * delta)
 - release
```
public static void release(Pointer... pointers)
```
 Release pointers, if they're not null (see release()).
 - equals
```
public boolean equals(Object obj)
```
 Test equality of the pointer using the address.
 
 Overrides:
 
 equals in class Object
 
 Returns:
 
 true if and only if obj is a Pointer instance and obj.getPeer() == this.getPeer()
 - pointerToAddress
```
@Deprecated
public static Pointer<?> pointerToAddress(long peer)
```
 Deprecated.
 
 Create a pointer out of a native memory address
 
 Parameters:
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == address
 - pointerToAddress
```
@Deprecated
public static Pointer<?> pointerToAddress(long peer,
 long size)
```
 Deprecated.
 
 Create a pointer out of a native memory address
 
 Parameters:
 
 size - number of bytes known to be readable at the pointed address
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == peer
 - pointerToAddress
```
public static  Pointer pointerToAddress(long peer,
 Class targetClass,
 Pointer.Releaser releaser)
```
 Create a pointer out of a native memory address
 
 Parameters:
 
 targetClass - type of the elements pointed by the resulting pointer
 
 releaser - object responsible for reclaiming the native memory once whenever the returned pointer is garbage-collected
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == peer
 - pointerToAddress
```
public static  Pointer pointerToAddress(long peer,
 Type targetType,
 Pointer.Releaser releaser)
```
 Create a pointer out of a native memory address
 
 Parameters:
 
 targetType - type of the elements pointed by the resulting pointer
 
 releaser - object responsible for reclaiming the native memory once whenever the returned pointer is garbage-collected
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == peer
 - pointerToAddress
```
public static  Pointer pointerToAddress(long peer,
 PointerIO io)
```
 Create a pointer out of a native memory address
 
 Parameters:
 
 io - PointerIO instance that knows how to read the elements pointed by the resulting pointer
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == peer
 - pointerToAddress
```
@Deprecated
public static Pointer<?> pointerToAddress(long peer,
 Pointer.Releaser releaser)
```
 Deprecated.
 
 Create a pointer out of a native memory address
 
 Parameters:
 
 releaser - object responsible for reclaiming the native memory once whenever the returned pointer is garbage-collected
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == peer
 - pointerToAddress
```
public static Pointer<?> pointerToAddress(long peer,
 long size,
 Pointer.Releaser releaser)
```
 Create a pointer out of a native memory address
 
 Parameters:
 
 releaser - object responsible for reclaiming the native memory once whenever the returned pointer is garbage-collected
 
 size - number of bytes known to be readable at the pointed address
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == peer
 - pointerToAddress
```
public static  Pointer pointerToAddress(long peer,
 long size,
 PointerIO io,
 Pointer.Releaser releaser)
```
 Create a pointer out of a native memory address
 
 Parameters:
 
 io - PointerIO instance that knows how to read the elements pointed by the resulting pointer
 
 releaser - object responsible for reclaiming the native memory once whenever the returned pointer is garbage-collected
 
 size - number of bytes known to be readable at the pointed address
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == peer
 - pointerToAddress
```
@Deprecated
public static  Pointer pointerToAddress(long peer,
 Class targetClass)
```
 Deprecated.
 
 Create a pointer out of a native memory address
 
 Parameters:
 
 targetClass - type of the elements pointed by the resulting pointer
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == peer
 - pointerToAddress
```
@Deprecated
public static  Pointer pointerToAddress(long peer,
 Type targetType)
```
 Deprecated.
 
 Create a pointer out of a native memory address
 
 Parameters:
 
 targetType - type of the elements pointed by the resulting pointer
 
 peer - native memory address that is to be converted to a pointer
 
 Returns:
 
 a pointer with the provided address : pointer.getPeer() == peer
 - allocateTypedPointer
```
public static  Pointer allocateTypedPointer(Class type)
```
 Allocate enough memory for a typed pointer value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized typed pointer value
 - allocateTypedPointers
```
public static  Pointer allocateTypedPointers(Class type,
 long arrayLength)
```
 Allocate enough memory for arrayLength typed pointer values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized typed pointer consecutive values
 - allocatePointer
```
public static  Pointer<Pointer> allocatePointer(Class targetType)
```
 Create a memory area large enough to hold a pointer.
 
 Parameters:
 
 targetType - target type of the pointer values to be stored in the allocated memory
 
 Returns:
 
 a pointer to a new memory area large enough to hold a single typed pointer
 - allocatePointer
```
public static  Pointer<Pointer> allocatePointer(Type targetType)
```
 Create a memory area large enough to hold a pointer.
 
 Parameters:
 
 targetType - target type of the pointer values to be stored in the allocated memory
 
 Returns:
 
 a pointer to a new memory area large enough to hold a single typed pointer
 - allocatePointerPointer
```
public static  Pointer<Pointer<Pointer>> allocatePointerPointer(Type targetType)
```
 Create a memory area large enough to hold a pointer to a pointer
 
 Parameters:
 
 targetType - target type of the values pointed by the pointer values to be stored in the allocated memory
 
 Returns:
 
 a pointer to a new memory area large enough to hold a single typed pointer
 - allocatePointerPointer
```
public static  Pointer<Pointer<Pointer>> allocatePointerPointer(Class targetType)
```
 Create a memory area large enough to hold a pointer to a pointer
 
 Parameters:
 
 targetType - target type of the values pointed by the pointer values to be stored in the allocated memory
 
 Returns:
 
 a pointer to a new memory area large enough to hold a single typed pointer
 - allocatePointer
```
public static <V> Pointer<Pointer<?>> allocatePointer()
```
 Create a memory area large enough to hold an untyped pointer.
 
 Returns:
 
 a pointer to a new memory area large enough to hold a single untyped pointer
 - allocatePointers
```
public static Pointer<Pointer<?>> allocatePointers(int arrayLength)
```
 Allocate enough memory for arrayLength untyped pointer values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Pointer<?>> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized untyped pointer consecutive values
 - allocatePointers
```
public static  Pointer<Pointer> allocatePointers(Class targetType,
 int arrayLength)
```
 Create a memory area large enough to hold an array of arrayLength typed pointers.
 
 Parameters:
 
 targetType - target type of element pointers in the resulting pointer array.
 
 arrayLength - size of the allocated array, in elements
 
 Returns:
 
 a pointer to a new memory area large enough to hold an array of arrayLength typed pointers
 - allocatePointers
```
public static  Pointer<Pointer> allocatePointers(Type targetType,
 int arrayLength)
```
 Create a memory area large enough to hold an array of arrayLength typed pointers.
 
 Parameters:
 
 targetType - target type of element pointers in the resulting pointer array.
 
 arrayLength - size of the allocated array, in elements
 
 Returns:
 
 a pointer to a new memory area large enough to hold an array of arrayLength typed pointers
 - allocate
```
public static <V> Pointer<V> allocate(Class<V> elementClass)
```
 Create a memory area large enough to a single items of type elementClass.
 
 Parameters:
 
 elementClass - type of the array elements
 
 Returns:
 
 a pointer to a new memory area large enough to hold a single item of type elementClass.
 - allocate
```
public static <V> Pointer<V> allocate(Type elementClass)
```
 Create a memory area large enough to a single items of type elementClass.
 
 Parameters:
 
 elementClass - type of the array elements
 
 Returns:
 
 a pointer to a new memory area large enough to hold a single item of type elementClass.
 - allocate
```
public static <V> Pointer<V> allocate(PointerIO<V> io)
```
 Create a memory area large enough to hold one item of the type associated to the provided PointerIO instance (see PointerIO.getTargetType())
 
 Parameters:
 
 io - PointerIO instance able to store and retrieve the element
 
 Returns:
 
 a pointer to a new memory area large enough to hold one item of the type associated to the provided PointerIO instance (see PointerIO.getTargetType())
 - allocateArray
```
public static <V> Pointer<V> allocateArray(PointerIO<V> io,
 long arrayLength)
```
 Create a memory area large enough to hold arrayLength items of the type associated to the provided PointerIO instance (see PointerIO.getTargetType())
 
 Parameters:
 
 io - PointerIO instance able to store and retrieve elements of the array
 
 arrayLength - length of the array in elements
 
 Returns:
 
 a pointer to a new memory area large enough to hold arrayLength items of the type associated to the provided PointerIO instance (see PointerIO.getTargetType())
 - allocateArray
```
public static <V> Pointer<V> allocateArray(PointerIO<V> io,
 long arrayLength,
 Pointer.Releaser beforeDeallocation)
```
 Create a memory area large enough to hold arrayLength items of the type associated to the provided PointerIO instance (see PointerIO.getTargetType())
 
 Parameters:
 
 io - PointerIO instance able to store and retrieve elements of the array
 
 arrayLength - length of the array in elements
 
 beforeDeallocation - fake releaser that should be run just before the memory is actually released, for instance in order to call some object destructor
 
 Returns:
 
 a pointer to a new memory area large enough to hold arrayLength items of the type associated to the provided PointerIO instance (see PointerIO.getTargetType())
 - allocateBytes
```
public static <V> Pointer<V> allocateBytes(PointerIO<V> io,
 long byteSize,
 Pointer.Releaser beforeDeallocation)
```
 Create a memory area large enough to hold byteSize consecutive bytes and return a pointer to elements of the type associated to the provided PointerIO instance (see PointerIO.getTargetType())
 
 Parameters:
 
 io - PointerIO instance able to store and retrieve elements of the array
 
 byteSize - length of the array in bytes
 
 beforeDeallocation - fake releaser that should be run just before the memory is actually released, for instance in order to call some object destructor
 
 Returns:
 
 a pointer to a new memory area large enough to hold byteSize consecutive bytes
 - allocateAlignedBytes
```
public static <V> Pointer<V> allocateAlignedBytes(PointerIO<V> io,
 long byteSize,
 int alignment,
 Pointer.Releaser beforeDeallocation)
```
 Create a memory area large enough to hold byteSize consecutive bytes and return a pointer to elements of the type associated to the provided PointerIO instance (see PointerIO.getTargetType()), ensuring the pointer to the memory is aligned to the provided boundary.
 
 Parameters:
 
 io - PointerIO instance able to store and retrieve elements of the array
 
 byteSize - length of the array in bytes
 
 alignment - boundary to which the returned pointer should be aligned
 
 beforeDeallocation - fake releaser that should be run just before the memory is actually released, for instance in order to call some object destructor
 
 Returns:
 
 a pointer to a new memory area large enough to hold byteSize consecutive bytes
 - withReleaser
```
@Deprecated
public Pointer<T> withReleaser(Pointer.Releaser beforeDeallocation)
```
 Deprecated. This method can easily be misused and is reserved to advanced users.
 
 Create a pointer that depends on this pointer and will call a releaser prior to release this pointer, when it is GC'd.
 This pointer MUST NOT be used anymore.
 
 Parameters:
 
 beforeDeallocation - releaser that should be run before this pointer's releaser (if any).
 
 Returns:
 
 a new pointer to the same memory location as this pointer
 - allocateArray
```
public static <V> Pointer<V> allocateArray(Class<V> elementClass,
 long arrayLength)
```
 Create a memory area large enough to hold arrayLength items of type elementClass.
 
 Parameters:
 
 elementClass - type of the array elements
 
 arrayLength - length of the array in elements
 
 Returns:
 
 a pointer to a new memory area large enough to hold arrayLength items of type elementClass.
 - allocateArray
```
public static <V> Pointer<V> allocateArray(Type elementClass,
 long arrayLength)
```
 Create a memory area large enough to hold arrayLength items of type elementClass.
 
 Parameters:
 
 elementClass - type of the array elements
 
 arrayLength - length of the array in elements
 
 Returns:
 
 a pointer to a new memory area large enough to hold arrayLength items of type elementClass.
 - allocateAlignedArray
```
public static <V> Pointer<V> allocateAlignedArray(Class<V> elementClass,
 long arrayLength,
 int alignment)
```
 Create a memory area large enough to hold arrayLength items of type elementClass, ensuring the pointer to the memory is aligned to the provided boundary.
 
 Parameters:
 
 elementClass - type of the array elements
 
 arrayLength - length of the array in elements
 
 alignment - boundary to which the returned pointer should be aligned
 
 Returns:
 
 a pointer to a new memory area large enough to hold arrayLength items of type elementClass.
 - allocateAlignedArray
```
public static <V> Pointer<V> allocateAlignedArray(Type elementClass,
 long arrayLength,
 int alignment)
```
 Create a memory area large enough to hold arrayLength items of type elementClass, ensuring the pointer to the memory is aligned to the provided boundary.
 
 Parameters:
 
 elementClass - type of the array elements
 
 arrayLength - length of the array in elements
 
 alignment - boundary to which the returned pointer should be aligned
 
 Returns:
 
 a pointer to a new memory area large enough to hold arrayLength items of type elementClass.
 - pointerToBuffer
```
public static Pointer<?> pointerToBuffer(Buffer buffer)
```
 Create a pointer to the memory location used by a direct NIO buffer.
 If the NIO buffer is not direct, then its backing Java array is copied to some native memory and will never be updated by changes to the native memory (calls pointerToArray(Object)), unless a call to updateBuffer(Buffer) is made manually.
 The returned pointer (and its subsequent views returned by offset(long) or next(long)) can be used safely : it retains a reference to the original NIO buffer, so that this latter cannot be garbage collected before the pointer.
 - updateBuffer
```
public void updateBuffer(Buffer buffer)
```
 When a pointer was created with pointerToBuffer(Buffer) on a non-direct buffer, a native copy of the buffer data was made. This method updates the original buffer with the native memory, and does nothing if the buffer is direct and points to the same memory location as this pointer.
 
 Throws:
 
 IllegalArgumentException - if buffer is direct and does not point to the exact same location as this Pointer instance
 - pointerToInt
```
public static Pointer<Integer> pointerToInt(int value)
```
 Allocate enough memory for a single int value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the int value given in argument
 - pointerToInts
```
public static Pointer<Integer> pointerToInts(int... values)
```
 Allocate enough memory for values.length int values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Integer> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the int consecutive values provided in argument
 - pointerToInts
```
public static Pointer<Pointer<Integer>> pointerToInts(int[][] values)
```
 Allocate enough memory for all the values in the 2D int array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the int values provided in argument packed as a 2D C array would be
 - pointerToInts
```
public static Pointer<Pointer<Pointer<Integer>>> pointerToInts(int[][][] values)
```
 Allocate enough memory for all the values in the 3D int array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the int values provided in argument packed as a 3D C array would be
 - allocateInt
```
public static Pointer<Integer> allocateInt()
```
 Allocate enough memory for a int value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized int value
 - allocateInts
```
public static Pointer<Integer> allocateInts(long arrayLength)
```
 Allocate enough memory for arrayLength int values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Integer> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized int consecutive values
 - allocateInts
```
public static Pointer<Pointer<Integer>> allocateInts(long dim1,
 long dim2)
```
 Allocate enough memory for dim1 * dim2 int values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 zero-initialized int consecutive values
 - allocateInts
```
public static Pointer<Pointer<Pointer<Integer>>> allocateInts(long dim1,
 long dim2,
 long dim3)
```
 Allocate enough memory for dim1 * dim2 * dim3 int values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 * dim3 zero-initialized int consecutive values
 - pointerToLong
```
public static Pointer<Long> pointerToLong(long value)
```
 Allocate enough memory for a single long value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the long value given in argument
 - pointerToLongs
```
public static Pointer<Long> pointerToLongs(long... values)
```
 Allocate enough memory for values.length long values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Long> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the long consecutive values provided in argument
 - pointerToLongs
```
public static Pointer<Pointer<Long>> pointerToLongs(long[][] values)
```
 Allocate enough memory for all the values in the 2D long array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the long values provided in argument packed as a 2D C array would be
 - pointerToLongs
```
public static Pointer<Pointer<Pointer<Long>>> pointerToLongs(long[][][] values)
```
 Allocate enough memory for all the values in the 3D long array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the long values provided in argument packed as a 3D C array would be
 - allocateLong
```
public static Pointer<Long> allocateLong()
```
 Allocate enough memory for a long value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized long value
 - allocateLongs
```
public static Pointer<Long> allocateLongs(long arrayLength)
```
 Allocate enough memory for arrayLength long values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Long> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized long consecutive values
 - allocateLongs
```
public static Pointer<Pointer<Long>> allocateLongs(long dim1,
 long dim2)
```
 Allocate enough memory for dim1 * dim2 long values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 zero-initialized long consecutive values
 - allocateLongs
```
public static Pointer<Pointer<Pointer<Long>>> allocateLongs(long dim1,
 long dim2,
 long dim3)
```
 Allocate enough memory for dim1 * dim2 * dim3 long values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 * dim3 zero-initialized long consecutive values
 - pointerToShort
```
public static Pointer<Short> pointerToShort(short value)
```
 Allocate enough memory for a single short value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the short value given in argument
 - pointerToShorts
```
public static Pointer<Short> pointerToShorts(short... values)
```
 Allocate enough memory for values.length short values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Short> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the short consecutive values provided in argument
 - pointerToShorts
```
public static Pointer<Pointer<Short>> pointerToShorts(short[][] values)
```
 Allocate enough memory for all the values in the 2D short array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the short values provided in argument packed as a 2D C array would be
 - pointerToShorts
```
public static Pointer<Pointer<Pointer<Short>>> pointerToShorts(short[][][] values)
```
 Allocate enough memory for all the values in the 3D short array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the short values provided in argument packed as a 3D C array would be
 - allocateShort
```
public static Pointer<Short> allocateShort()
```
 Allocate enough memory for a short value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized short value
 - allocateShorts
```
public static Pointer<Short> allocateShorts(long arrayLength)
```
 Allocate enough memory for arrayLength short values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Short> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized short consecutive values
 - allocateShorts
```
public static Pointer<Pointer<Short>> allocateShorts(long dim1,
 long dim2)
```
 Allocate enough memory for dim1 * dim2 short values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 zero-initialized short consecutive values
 - allocateShorts
```
public static Pointer<Pointer<Pointer<Short>>> allocateShorts(long dim1,
 long dim2,
 long dim3)
```
 Allocate enough memory for dim1 * dim2 * dim3 short values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 * dim3 zero-initialized short consecutive values
 - pointerToByte
```
public static Pointer<Byte> pointerToByte(byte value)
```
 Allocate enough memory for a single byte value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the byte value given in argument
 - pointerToBytes
```
public static Pointer<Byte> pointerToBytes(byte... values)
```
 Allocate enough memory for values.length byte values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Byte> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the byte consecutive values provided in argument
 - pointerToBytes
```
public static Pointer<Pointer<Byte>> pointerToBytes(byte[][] values)
```
 Allocate enough memory for all the values in the 2D byte array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the byte values provided in argument packed as a 2D C array would be
 - pointerToBytes
```
public static Pointer<Pointer<Pointer<Byte>>> pointerToBytes(byte[][][] values)
```
 Allocate enough memory for all the values in the 3D byte array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the byte values provided in argument packed as a 3D C array would be
 - allocateByte
```
public static Pointer<Byte> allocateByte()
```
 Allocate enough memory for a byte value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized byte value
 - allocateBytes
```
public static Pointer<Byte> allocateBytes(long arrayLength)
```
 Allocate enough memory for arrayLength byte values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Byte> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized byte consecutive values
 - allocateBytes
```
public static Pointer<Pointer<Byte>> allocateBytes(long dim1,
 long dim2)
```
 Allocate enough memory for dim1 * dim2 byte values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 zero-initialized byte consecutive values
 - allocateBytes
```
public static Pointer<Pointer<Pointer<Byte>>> allocateBytes(long dim1,
 long dim2,
 long dim3)
```
 Allocate enough memory for dim1 * dim2 * dim3 byte values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 * dim3 zero-initialized byte consecutive values
 - pointerToChar
```
public static Pointer<Character> pointerToChar(char value)
```
 Allocate enough memory for a single char value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the char value given in argument
 - pointerToChars
```
public static Pointer<Character> pointerToChars(char... values)
```
 Allocate enough memory for values.length char values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Character> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the char consecutive values provided in argument
 - pointerToChars
```
public static Pointer<Pointer<Character>> pointerToChars(char[][] values)
```
 Allocate enough memory for all the values in the 2D char array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the char values provided in argument packed as a 2D C array would be
 - pointerToChars
```
public static Pointer<Pointer<Pointer<Character>>> pointerToChars(char[][][] values)
```
 Allocate enough memory for all the values in the 3D char array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the char values provided in argument packed as a 3D C array would be
 - allocateChar
```
public static Pointer<Character> allocateChar()
```
 Allocate enough memory for a char value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized char value
 - allocateChars
```
public static Pointer<Character> allocateChars(long arrayLength)
```
 Allocate enough memory for arrayLength char values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Character> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized char consecutive values
 - allocateChars
```
public static Pointer<Pointer<Character>> allocateChars(long dim1,
 long dim2)
```
 Allocate enough memory for dim1 * dim2 char values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 zero-initialized char consecutive values
 - allocateChars
```
public static Pointer<Pointer<Pointer<Character>>> allocateChars(long dim1,
 long dim2,
 long dim3)
```
 Allocate enough memory for dim1 * dim2 * dim3 char values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 * dim3 zero-initialized char consecutive values
 - pointerToFloat
```
public static Pointer<Float> pointerToFloat(float value)
```
 Allocate enough memory for a single float value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the float value given in argument
 - pointerToFloats
```
public static Pointer<Float> pointerToFloats(float... values)
```
 Allocate enough memory for values.length float values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Float> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the float consecutive values provided in argument
 - pointerToFloats
```
public static Pointer<Pointer<Float>> pointerToFloats(float[][] values)
```
 Allocate enough memory for all the values in the 2D float array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the float values provided in argument packed as a 2D C array would be
 - pointerToFloats
```
public static Pointer<Pointer<Pointer<Float>>> pointerToFloats(float[][][] values)
```
 Allocate enough memory for all the values in the 3D float array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the float values provided in argument packed as a 3D C array would be
 - allocateFloat
```
public static Pointer<Float> allocateFloat()
```
 Allocate enough memory for a float value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized float value
 - allocateFloats
```
public static Pointer<Float> allocateFloats(long arrayLength)
```
 Allocate enough memory for arrayLength float values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Float> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized float consecutive values
 - allocateFloats
```
public static Pointer<Pointer<Float>> allocateFloats(long dim1,
 long dim2)
```
 Allocate enough memory for dim1 * dim2 float values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 zero-initialized float consecutive values
 - allocateFloats
```
public static Pointer<Pointer<Pointer<Float>>> allocateFloats(long dim1,
 long dim2,
 long dim3)
```
 Allocate enough memory for dim1 * dim2 * dim3 float values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 * dim3 zero-initialized float consecutive values
 - pointerToDouble
```
public static Pointer<Double> pointerToDouble(double value)
```
 Allocate enough memory for a single double value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the double value given in argument
 - pointerToDoubles
```
public static Pointer<Double> pointerToDoubles(double... values)
```
 Allocate enough memory for values.length double values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Double> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the double consecutive values provided in argument
 - pointerToDoubles
```
public static Pointer<Pointer<Double>> pointerToDoubles(double[][] values)
```
 Allocate enough memory for all the values in the 2D double array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the double values provided in argument packed as a 2D C array would be
 - pointerToDoubles
```
public static Pointer<Pointer<Pointer<Double>>> pointerToDoubles(double[][][] values)
```
 Allocate enough memory for all the values in the 3D double array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the double values provided in argument packed as a 3D C array would be
 - allocateDouble
```
public static Pointer<Double> allocateDouble()
```
 Allocate enough memory for a double value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized double value
 - allocateDoubles
```
public static Pointer<Double> allocateDoubles(long arrayLength)
```
 Allocate enough memory for arrayLength double values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Double> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized double consecutive values
 - allocateDoubles
```
public static Pointer<Pointer<Double>> allocateDoubles(long dim1,
 long dim2)
```
 Allocate enough memory for dim1 * dim2 double values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 zero-initialized double consecutive values
 - allocateDoubles
```
public static Pointer<Pointer<Pointer<Double>>> allocateDoubles(long dim1,
 long dim2,
 long dim3)
```
 Allocate enough memory for dim1 * dim2 * dim3 double values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 * dim3 zero-initialized double consecutive values
 - pointerToBoolean
```
public static Pointer<Boolean> pointerToBoolean(boolean value)
```
 Allocate enough memory for a single boolean value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the boolean value given in argument
 - pointerToBooleans
```
public static Pointer<Boolean> pointerToBooleans(boolean... values)
```
 Allocate enough memory for values.length boolean values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Boolean> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the boolean consecutive values provided in argument
 - pointerToBooleans
```
public static Pointer<Pointer<Boolean>> pointerToBooleans(boolean[][] values)
```
 Allocate enough memory for all the values in the 2D boolean array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the boolean values provided in argument packed as a 2D C array would be
 - pointerToBooleans
```
public static Pointer<Pointer<Pointer<Boolean>>> pointerToBooleans(boolean[][][] values)
```
 Allocate enough memory for all the values in the 3D boolean array, copy the values provided as argument into it as packed multi-dimensional C array and return a pointer to that memory.
 Assumes that all of the subarrays of the provided array are non null and have the same size.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the boolean values provided in argument packed as a 3D C array would be
 - allocateBoolean
```
public static Pointer<Boolean> allocateBoolean()
```
 Allocate enough memory for a boolean value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized boolean value
 - allocateBooleans
```
public static Pointer<Boolean> allocateBooleans(long arrayLength)
```
 Allocate enough memory for arrayLength boolean values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Boolean> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized boolean consecutive values
 - allocateBooleans
```
public static Pointer<Pointer<Boolean>> allocateBooleans(long dim1,
 long dim2)
```
 Allocate enough memory for dim1 * dim2 boolean values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 zero-initialized boolean consecutive values
 - allocateBooleans
```
public static Pointer<Pointer<Pointer<Boolean>>> allocateBooleans(long dim1,
 long dim2,
 long dim3)
```
 Allocate enough memory for dim1 * dim2 * dim3 boolean values in a packed multi-dimensional C array and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Returns:
 
 pointer to dim1 * dim2 * dim3 zero-initialized boolean consecutive values
 - pointerToInts
```
public static Pointer<Integer> pointerToInts(IntBuffer buffer)
```
 Create a pointer to the memory location used by a direct NIO IntBuffer.
 If the NIO IntBuffer is not direct, then its backing Java array is copied to some native memory and will never be updated by changes to the native memory (calls pointerToInts(int[])), unless a call to updateBuffer(Buffer) is made manually.
 The returned pointer (and its subsequent views returned by offset(long) or next(long)) can be used safely : it retains a reference to the original NIO buffer, so that this latter cannot be garbage collected before the pointer.
 - pointerToLongs
```
public static Pointer<Long> pointerToLongs(LongBuffer buffer)
```
 Create a pointer to the memory location used by a direct NIO LongBuffer.
 If the NIO LongBuffer is not direct, then its backing Java array is copied to some native memory and will never be updated by changes to the native memory (calls pointerToLongs(long[])), unless a call to updateBuffer(Buffer) is made manually.
 The returned pointer (and its subsequent views returned by offset(long) or next(long)) can be used safely : it retains a reference to the original NIO buffer, so that this latter cannot be garbage collected before the pointer.
 - pointerToShorts
```
public static Pointer<Short> pointerToShorts(ShortBuffer buffer)
```
 Create a pointer to the memory location used by a direct NIO ShortBuffer.
 If the NIO ShortBuffer is not direct, then its backing Java array is copied to some native memory and will never be updated by changes to the native memory (calls pointerToShorts(short[])), unless a call to updateBuffer(Buffer) is made manually.
 The returned pointer (and its subsequent views returned by offset(long) or next(long)) can be used safely : it retains a reference to the original NIO buffer, so that this latter cannot be garbage collected before the pointer.
 - pointerToBytes
```
public static Pointer<Byte> pointerToBytes(ByteBuffer buffer)
```
 Create a pointer to the memory location used by a direct NIO ByteBuffer.
 If the NIO ByteBuffer is not direct, then its backing Java array is copied to some native memory and will never be updated by changes to the native memory (calls pointerToBytes(byte[])), unless a call to updateBuffer(Buffer) is made manually.
 The returned pointer (and its subsequent views returned by offset(long) or next(long)) can be used safely : it retains a reference to the original NIO buffer, so that this latter cannot be garbage collected before the pointer.
 - pointerToChars
```
public static Pointer<Character> pointerToChars(CharBuffer buffer)
```
 Create a pointer to the memory location used by a direct NIO CharBuffer.
 If the NIO CharBuffer is not direct, then its backing Java array is copied to some native memory and will never be updated by changes to the native memory (calls pointerToChars(char[])), unless a call to updateBuffer(Buffer) is made manually.
 The returned pointer (and its subsequent views returned by offset(long) or next(long)) can be used safely : it retains a reference to the original NIO buffer, so that this latter cannot be garbage collected before the pointer.
 - pointerToFloats
```
public static Pointer<Float> pointerToFloats(FloatBuffer buffer)
```
 Create a pointer to the memory location used by a direct NIO FloatBuffer.
 If the NIO FloatBuffer is not direct, then its backing Java array is copied to some native memory and will never be updated by changes to the native memory (calls pointerToFloats(float[])), unless a call to updateBuffer(Buffer) is made manually.
 The returned pointer (and its subsequent views returned by offset(long) or next(long)) can be used safely : it retains a reference to the original NIO buffer, so that this latter cannot be garbage collected before the pointer.
 - pointerToDoubles
```
public static Pointer<Double> pointerToDoubles(DoubleBuffer buffer)
```
 Create a pointer to the memory location used by a direct NIO DoubleBuffer.
 If the NIO DoubleBuffer is not direct, then its backing Java array is copied to some native memory and will never be updated by changes to the native memory (calls pointerToDoubles(double[])), unless a call to updateBuffer(Buffer) is made manually.
 The returned pointer (and its subsequent views returned by offset(long) or next(long)) can be used safely : it retains a reference to the original NIO buffer, so that this latter cannot be garbage collected before the pointer.
 - getTargetType
```
public Type getTargetType()
```
 Get the type of pointed elements.
 - getPointer
```
@Deprecated
public Pointer<?> getPointer()
```
 Deprecated. Avoid using untyped pointers, if possible.
 
 Read an untyped pointer value from the pointed memory location
 - getPointerAtOffset
```
public Pointer<?> getPointerAtOffset(long byteOffset)
```
 Read a pointer value from the pointed memory location shifted by a byte offset
 - getPointerAtIndex
```
public Pointer<?> getPointerAtIndex(long valueIndex)
```
 Read the nth contiguous pointer value from the pointed memory location.
 Equivalent to getPointerAtOffset(valueIndex * Pointer.SIZE).
 
 Parameters:
 
 valueIndex - index of the value to read
 - getPointer
```
public  Pointer getPointer(Class c)
```
 Read a pointer value from the pointed memory location.
 
 Parameters:
 
 c - class of the elements pointed by the resulting pointer
 - getPointer
```
public  Pointer getPointer(PointerIO pio)
```
 Read a pointer value from the pointed memory location
 
 Parameters:
 
 pio - PointerIO instance that knows how to read the elements pointed by the resulting pointer
 - getPointerAtOffset
```
public  Pointer getPointerAtOffset(long byteOffset,
 Class c)
```
 Read a pointer value from the pointed memory location shifted by a byte offset
 
 Parameters:
 
 c - class of the elements pointed by the resulting pointer
 - getPointerAtOffset
```
public  Pointer getPointerAtOffset(long byteOffset,
 Type t)
```
 Read a pointer value from the pointed memory location shifted by a byte offset
 
 Parameters:
 
 t - type of the elements pointed by the resulting pointer
 - getPointerAtOffset
```
public  Pointer getPointerAtOffset(long byteOffset,
 PointerIO pio)
```
 Read a pointer value from the pointed memory location shifted by a byte offset
 
 Parameters:
 
 pio - PointerIO instance that knows how to read the elements pointed by the resulting pointer
 - setPointer
```
public Pointer<T> setPointer(Pointer<?> value)
```
 Write a pointer value to the pointed memory location
 - setPointerAtOffset
```
public Pointer<T> setPointerAtOffset(long byteOffset,
 Pointer<?> value)
```
 Write a pointer value to the pointed memory location shifted by a byte offset
 - setPointerAtIndex
```
public Pointer<T> setPointerAtIndex(long valueIndex,
 Pointer<?> value)
```
 Write the nth contiguous pointer value to the pointed memory location.
 Equivalent to setPointerAtOffset(valueIndex * Pointer.SIZE, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - pointer value to write
 - getPointersAtOffset
```
public Pointer<?>[] getPointersAtOffset(long byteOffset,
 int arrayLength)
```
 Deprecated. Use a typed version instead : getPointersAtOffset(long, int, Type), getPointersAtOffset(long, int, Class) or getPointersAtOffset(long, int, PointerIO)
 
 Read an array of untyped pointer values from the pointed memory location shifted by a byte offset
 - getPointers
```
@Deprecated
public Pointer<?>[] getPointers()
```
 Deprecated. Use a typed version instead : getPointersAtOffset(long, int, Type), getPointersAtOffset(long, int, Class) or getPointersAtOffset(long, int, PointerIO)
 
 Read the array of remaining untyped pointer values from the pointed memory location
 - getPointers
```
@Deprecated
public Pointer<?>[] getPointers(int arrayLength)
```
 Deprecated. Use a typed version instead : getPointersAtOffset(long, int, Type), getPointersAtOffset(long, int, Class) or getPointersAtOffset(long, int, PointerIO)
 
 Read an array of untyped pointer values from the pointed memory location
 - getPointersAtOffset
```
public  Pointer[] getPointersAtOffset(long byteOffset,
 int arrayLength,
 Type t)
```
 Read an array of pointer values from the pointed memory location shifted by a byte offset
 
 Parameters:
 
 t - type of the elements pointed by the resulting pointer
 - getPointersAtOffset
```
public  Pointer[] getPointersAtOffset(long byteOffset,
 int arrayLength,
 Class t)
```
 Read an array of pointer values from the pointed memory location shifted by a byte offset
 
 Parameters:
 
 t - class of the elements pointed by the resulting pointer
 - getPointersAtOffset
```
public  Pointer[] getPointersAtOffset(long byteOffset,
 int arrayLength,
 PointerIO pio)
```
 Read an array of pointer values from the pointed memory location shifted by a byte offset
 
 Parameters:
 
 pio - PointerIO instance that knows how to read the elements pointed by the resulting pointer
 - setPointersAtOffset
```
public Pointer<T> setPointersAtOffset(long byteOffset,
 Pointer<?>[] values)
```
 Write an array of pointer values to the pointed memory location shifted by a byte offset
 - setPointersAtOffset
```
public Pointer<T> setPointersAtOffset(long byteOffset,
 Pointer<?>[] values,
 int valuesOffset,
 int length)
```
 Write length pointer values from the given array (starting at the given value offset) to the pointed memory location shifted by a byte offset
 - setPointers
```
public Pointer<T> setPointers(Pointer<?>[] values)
```
 Write an array of pointer values to the pointed memory location
 - getArrayAtOffset
```
public Object getArrayAtOffset(long byteOffset,
 int length)
```
 Read an array of elements from the pointed memory location shifted by a byte offset.
 For pointers to primitive types (e.g. Pointer<Integer> ), this method returns primitive arrays (e.g. int[] ), unlike toArray() (which returns arrays of objects so primitives end up being boxed, e.g. Integer[] )
 
 Returns:
 
 an array of values of the requested length. The array is an array of primitives if the pointer's target type is a primitive or a boxed primitive type
 - getArray
```
public Object getArray(int length)
```
 Read an array of elements from the pointed memory location.
 For pointers to primitive types (e.g. Pointer<Integer> ), this method returns primitive arrays (e.g. int[] ), unlike toArray() (which returns arrays of objects so primitives end up being boxed, e.g. Integer[] )
 
 Returns:
 
 an array of values of the requested length. The array is an array of primitives if the pointer's target type is a primitive or a boxed primitive type
 - getArray
```
public Object getArray()
```
 Read the array of remaining elements from the pointed memory location.
 For pointers to primitive types (e.g. Pointer<Integer> ), this method returns primitive arrays (e.g. int[] ), unlike toArray() (which returns arrays of objects so primitives end up being boxed, e.g. Integer[] )
 
 Returns:
 
 an array of values of the requested length. The array is an array of primitives if the pointer's target type is a primitive or a boxed primitive type
 - getBufferAtOffset
```
public  B getBufferAtOffset(long byteOffset,
 int length)
```
 Read an NIO Buffer of elements from the pointed memory location shifted by a byte offset.
 
 Returns:
 
 an NIO Buffer of values of the requested length.
 
 Throws:
 
 UnsupportedOperationException - if this pointer's target type is not a Java primitive type with a corresponding NIO Buffer class.
 - getBuffer
```
public  B getBuffer(int length)
```
 Read an NIO Buffer of elements from the pointed memory location.
 
 Returns:
 
 an NIO Buffer of values of the requested length.
 
 Throws:
 
 UnsupportedOperationException - if this pointer's target type is not a Java primitive type with a corresponding NIO Buffer class.
 - getBuffer
```
public  B getBuffer()
```
 Read the NIO Buffer of remaining elements from the pointed memory location.
 
 Returns:
 
 an array of values of the requested length.
 
 Throws:
 
 UnsupportedOperationException - if this pointer's target type is not a Java primitive type with a corresponding NIO Buffer class.
 - setArrayAtOffset
```
public Pointer<T> setArrayAtOffset(long byteOffset,
 Object array)
```
 Write an array of elements to the pointed memory location shifted by a byte offset.
 For pointers to primitive types (e.g. Pointer<Integer> ), this method accepts primitive arrays (e.g. int[] ) instead of arrays of boxed primitives (e.g. Integer[] )
 - pointerToArray
```
public static <T> Pointer<T> pointerToArray(Object array)
```
 Allocate enough memory for array.length values, copy the values of the array provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 For pointers to primitive types (e.g. Pointer<Integer> ), this method accepts primitive arrays (e.g. int[] ) instead of arrays of boxed primitives (e.g. Integer[] )
 
 Parameters:
 
 array - primitive array containing the initial values for the created memory area
 
 Returns:
 
 pointer to a new memory location that initially contains the consecutive values provided in argument
 - setArray
```
public Pointer<T> setArray(Object array)
```
 Write an array of elements to the pointed memory location.
 For pointers to primitive types (e.g. Pointer<Integer> ), this method accepts primitive arrays (e.g. int[] ) instead of arrays of boxed primitives (e.g. Integer[] )
 - pointerToSizeT
```
public static Pointer<SizeT> pointerToSizeT(long value)
```
 Allocate enough memory for a single SizeT value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the SizeT value given in argument
 - pointerToSizeT
```
public static Pointer<SizeT> pointerToSizeT(SizeT value)
```
 Allocate enough memory for a single SizeT value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the SizeT value given in argument
 - pointerToSizeTs
```
public static Pointer<SizeT> pointerToSizeTs(long... values)
```
 Allocate enough memory for values.length SizeT values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<SizeT> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the SizeT consecutive values provided in argument
 - pointerToSizeTs
```
public static Pointer<SizeT> pointerToSizeTs(SizeT... values)
```
 Allocate enough memory for values.length SizeT values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<SizeT> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the SizeT consecutive values provided in argument
 - pointerToSizeTs
```
public static Pointer<SizeT> pointerToSizeTs(int[] values)
```
 Allocate enough memory for values.length SizeT values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<SizeT> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the SizeT consecutive values provided in argument
 - allocateSizeTs
```
public static Pointer<SizeT> allocateSizeTs(long arrayLength)
```
 Allocate enough memory for arrayLength SizeT values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<SizeT> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized SizeT consecutive values
 - allocateSizeT
```
public static Pointer<SizeT> allocateSizeT()
```
 Allocate enough memory for a SizeT value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized SizeT value
 - getSizeT
```
public long getSizeT()
```
 Read a SizeT value from the pointed memory location
 - getSizeTAtOffset
```
public long getSizeTAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getSizeT() over this method.
 
 Read a SizeT value from the pointed memory location shifted by a byte offset
 - getSizeTAtIndex
```
public long getSizeTAtIndex(long valueIndex)
```
 Read the nth contiguous SizeT value from the pointed memory location.
 Equivalent to getSizeTAtOffset(valueIndex * SizeT.SIZE.
 
 Parameters:
 
 valueIndex - index of the value to read
 - getSizeTs
```
public long[] getSizeTs()
```
 Read the array of remaining SizeT values from the pointed memory location
 - getSizeTs
```
public long[] getSizeTs(int arrayLength)
```
 Read an array of SizeT values of the specified length from the pointed memory location
 - getSizeTsAtOffset
```
public long[] getSizeTsAtOffset(long byteOffset,
 int arrayLength)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getSizeTs(int) over this method.
 
 Read an array of SizeT values of the specified length from the pointed memory location shifted by a byte offset
 - setSizeT
```
public Pointer<T> setSizeT(long value)
```
 Write a SizeT value to the pointed memory location
 - setSizeT
```
public Pointer<T> setSizeT(SizeT value)
```
 Write a SizeT value to the pointed memory location
 - setSizeTAtOffset
```
public Pointer<T> setSizeTAtOffset(long byteOffset,
 long value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setSizeT(long) over this method.
 
 Write a SizeT value to the pointed memory location shifted by a byte offset
 - setSizeTAtIndex
```
public Pointer<T> setSizeTAtIndex(long valueIndex,
 long value)
```
 Write the nth contiguous SizeT value to the pointed memory location.
 Equivalent to setSizeTAtOffset(valueIndex * SizeT.SIZE, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - SizeT value to write
 - setSizeTAtOffset
```
public Pointer<T> setSizeTAtOffset(long byteOffset,
 SizeT value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setSizeT(SizeT) over this method.
 
 Write a SizeT value to the pointed memory location shifted by a byte offset
 - setSizeTs
```
public Pointer<T> setSizeTs(long[] values)
```
 Write an array of SizeT values to the pointed memory location
 - setSizeTs
```
public Pointer<T> setSizeTs(int[] values)
```
 Write an array of SizeT values to the pointed memory location
 - setSizeTs
```
public Pointer<T> setSizeTs(SizeT[] values)
```
 Write an array of SizeT values to the pointed memory location
 - setSizeTsAtOffset
```
public Pointer<T> setSizeTsAtOffset(long byteOffset,
 long[] values)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setSizeTs(long[]) over this method.
 
 Write an array of SizeT values to the pointed memory location shifted by a byte offset
 - setSizeTsAtOffset
```
public abstract Pointer<T> setSizeTsAtOffset(long byteOffset,
 long[] values,
 int valuesOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setSizeTs(long[]) over this method.
 
 Write an array of SizeT values to the pointed memory location shifted by a byte offset
 - setSizeTsAtOffset
```
public Pointer<T> setSizeTsAtOffset(long byteOffset,
 SizeT... values)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setSizeTs(SizeT...) over this method.
 
 Write an array of SizeT values to the pointed memory location shifted by a byte offset
 - setSizeTsAtOffset
```
public abstract Pointer<T> setSizeTsAtOffset(long byteOffset,
 int[] values)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setSizeTs(int[]) over this method.
 
 Write an array of SizeT values to the pointed memory location shifted by a byte offset
 - pointerToCLong
```
public static Pointer<CLong> pointerToCLong(long value)
```
 Allocate enough memory for a single CLong value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the CLong value given in argument
 - pointerToCLong
```
public static Pointer<CLong> pointerToCLong(CLong value)
```
 Allocate enough memory for a single CLong value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the CLong value given in argument
 - pointerToCLongs
```
public static Pointer<CLong> pointerToCLongs(long... values)
```
 Allocate enough memory for values.length CLong values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<CLong> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the CLong consecutive values provided in argument
 - pointerToCLongs
```
public static Pointer<CLong> pointerToCLongs(CLong... values)
```
 Allocate enough memory for values.length CLong values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<CLong> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the CLong consecutive values provided in argument
 - pointerToCLongs
```
public static Pointer<CLong> pointerToCLongs(int[] values)
```
 Allocate enough memory for values.length CLong values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<CLong> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the CLong consecutive values provided in argument
 - allocateCLongs
```
public static Pointer<CLong> allocateCLongs(long arrayLength)
```
 Allocate enough memory for arrayLength CLong values and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<CLong> instance that can be safely iterated upon.
 
 Returns:
 
 pointer to arrayLength zero-initialized CLong consecutive values
 - allocateCLong
```
public static Pointer<CLong> allocateCLong()
```
 Allocate enough memory for a CLong value and return a pointer to it.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 
 Returns:
 
 pointer to a single zero-initialized CLong value
 - getCLong
```
public long getCLong()
```
 Read a CLong value from the pointed memory location
 - getCLongAtOffset
```
public long getCLongAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getCLong() over this method.
 
 Read a CLong value from the pointed memory location shifted by a byte offset
 - getCLongAtIndex
```
public long getCLongAtIndex(long valueIndex)
```
 Read the nth contiguous CLong value from the pointed memory location.
 Equivalent to getCLongAtOffset(valueIndex * CLong.SIZE.
 
 Parameters:
 
 valueIndex - index of the value to read
 - getCLongs
```
public long[] getCLongs()
```
 Read the array of remaining CLong values from the pointed memory location
 - getCLongs
```
public long[] getCLongs(int arrayLength)
```
 Read an array of CLong values of the specified length from the pointed memory location
 - getCLongsAtOffset
```
public long[] getCLongsAtOffset(long byteOffset,
 int arrayLength)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getCLongs(int) over this method.
 
 Read an array of CLong values of the specified length from the pointed memory location shifted by a byte offset
 - setCLong
```
public Pointer<T> setCLong(long value)
```
 Write a CLong value to the pointed memory location
 - setCLong
```
public Pointer<T> setCLong(CLong value)
```
 Write a CLong value to the pointed memory location
 - setCLongAtOffset
```
public Pointer<T> setCLongAtOffset(long byteOffset,
 long value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setCLong(long) over this method.
 
 Write a CLong value to the pointed memory location shifted by a byte offset
 - setCLongAtIndex
```
public Pointer<T> setCLongAtIndex(long valueIndex,
 long value)
```
 Write the nth contiguous CLong value to the pointed memory location.
 Equivalent to setCLongAtOffset(valueIndex * CLong.SIZE, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - CLong value to write
 - setCLongAtOffset
```
public Pointer<T> setCLongAtOffset(long byteOffset,
 CLong value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setCLong(CLong) over this method.
 
 Write a CLong value to the pointed memory location shifted by a byte offset
 - setCLongs
```
public Pointer<T> setCLongs(long[] values)
```
 Write an array of CLong values to the pointed memory location
 - setCLongs
```
public Pointer<T> setCLongs(int[] values)
```
 Write an array of CLong values to the pointed memory location
 - setCLongs
```
public Pointer<T> setCLongs(CLong[] values)
```
 Write an array of CLong values to the pointed memory location
 - setCLongsAtOffset
```
public Pointer<T> setCLongsAtOffset(long byteOffset,
 long[] values)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setCLongs(long[]) over this method.
 
 Write an array of CLong values to the pointed memory location shifted by a byte offset
 - setCLongsAtOffset
```
public abstract Pointer<T> setCLongsAtOffset(long byteOffset,
 long[] values,
 int valuesOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setCLongs(long[]) over this method.
 
 Write an array of CLong values to the pointed memory location shifted by a byte offset
 - setCLongsAtOffset
```
public Pointer<T> setCLongsAtOffset(long byteOffset,
 CLong... values)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setCLongs(CLong...) over this method.
 
 Write an array of CLong values to the pointed memory location shifted by a byte offset
 - setCLongsAtOffset
```
public abstract Pointer<T> setCLongsAtOffset(long byteOffset,
 int[] values)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setCLongs(int[]) over this method.
 
 Write an array of CLong values to the pointed memory location shifted by a byte offset
 - pointerToPointer
```
public static <T> Pointer<Pointer<T>> pointerToPointer(Pointer<T> value)
```
 Allocate enough memory for a single pointer value, copy the value provided in argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 
 Parameters:
 
 value - initial value for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the pointer value given in argument
 - pointerToPointers
```
public static <T> Pointer<Pointer<T>> pointerToPointers(Pointer<T>... values)
```
 Allocate enough memory for values.length pointer values, copy the values provided as argument into it and return a pointer to that memory.
 The memory will be automatically be freed when the pointer is garbage-collected or upon manual calls to release().
 The pointer won't be garbage-collected until all its views are garbage-collected themselves (offset(long), next(long), next()).
 The returned pointer is also an Iterable<Pointer> instance that can be safely iterated upon :
```
 for (float f : pointerToFloats(1f, 2f, 3.3f))
 	System.out.println(f); 
```
 Parameters:
 
 values - initial values for the created memory location
 
 Returns:
 
 pointer to a new memory location that initially contains the pointer consecutive values provided in argument
 - setValuesAtOffset
```
public Pointer<T> setValuesAtOffset(long byteOffset,
 Buffer values)
```
 Copy all values from an NIO buffer to the pointed memory location shifted by a byte offset
 - setValuesAtOffset
```
public Pointer<T> setValuesAtOffset(long byteOffset,
 Buffer values,
 int valuesOffset,
 int length)
```
 Copy length values from an NIO buffer (beginning at element at valuesOffset index) to the pointed memory location shifted by a byte offset
 - setValues
```
public Pointer<T> setValues(Buffer values)
```
 Copy values from an NIO buffer to the pointed memory location
 - copyBytesAtOffsetTo
```
@Deprecated
public Pointer<T> copyBytesAtOffsetTo(long byteOffset,
 Pointer<?> destination,
 long byteOffsetInDestination,
 long byteCount)
```
 Deprecated.
 
 Copy bytes from the memory location indicated by this pointer to that of another pointer (with byte offsets for both the source and the destination), using the memcpy C function.
 If the destination and source memory locations are likely to overlap, moveBytesAtOffsetTo(long, Pointer, long, long) must be used instead.
 - copyBytesTo
```
@Deprecated
public Pointer<T> copyBytesTo(Pointer<?> destination,
 long byteCount)
```
 Deprecated.
 
 Copy bytes from the memory location indicated by this pointer to that of another pointer using the memcpy C function.
 If the destination and source memory locations are likely to overlap, moveBytesAtOffsetTo(long, Pointer, long, long) must be used instead.
 See copyBytesAtOffsetTo(long, Pointer, long, long) for more options.
 - moveBytesAtOffsetTo
```
@Deprecated
public Pointer<T> moveBytesAtOffsetTo(long byteOffset,
 Pointer<?> destination,
 long byteOffsetInDestination,
 long byteCount)
```
 Deprecated.
 
 Copy bytes from the memory location indicated by this pointer to that of another pointer (with byte offsets for both the source and the destination), using the memmove C function.
 Works even if the destination and source memory locations are overlapping.
 - moveBytesTo
```
public Pointer<T> moveBytesTo(Pointer<?> destination,
 long byteCount)
```
 Copy bytes from the memory location indicated by this pointer to that of another pointer, using the memmove C function.
 Works even if the destination and source memory locations are overlapping.
 - moveBytesTo
```
public Pointer<T> moveBytesTo(Pointer<?> destination)
```
 Copy all valid bytes from the memory location indicated by this pointer to that of another pointer, using the memmove C function.
 Works even if the destination and source memory locations are overlapping.
 - copyTo
```
public Pointer<T> copyTo(Pointer<?> destination)
```
 Copy remaining bytes from this pointer to a destination using the memcpy C function (see copyBytesTo(Pointer, long), getValidBytes())
 - copyTo
```
public Pointer<T> copyTo(Pointer<?> destination,
 long elementCount)
```
 Copy remaining elements from this pointer to a destination using the memcpy C function (see copyBytesAtOffsetTo(long, Pointer, long, long), getValidBytes())
 - find
```
public Pointer<T> find(Pointer<?> needle)
```
 Find the first appearance of the sequence of valid bytes pointed by needle in the memory area pointed to by this bounded pointer (behaviour equivalent to memmem, which is used underneath on platforms where it is available)
 - findLast
```
public Pointer<T> findLast(Pointer<?> needle)
```
 Find the last appearance of the sequence of valid bytes pointed by needle in the memory area pointed to by this bounded pointer (also see find(Pointer)).
 - setInt
```
public abstract Pointer<T> setInt(int value)
```
 Write a int value to the pointed memory location
 - setIntAtOffset
```
public abstract Pointer<T> setIntAtOffset(long byteOffset,
 int value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setInt(int) over this method.
 
 Write a int value to the pointed memory location shifted by a byte offset
 - setIntAtIndex
```
public Pointer<T> setIntAtIndex(long valueIndex,
 int value)
```
 Write the nth contiguous int value to the pointed memory location.
 Equivalent to setIntAtOffset(valueIndex * 4, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - int value to write
 - setInts
```
public Pointer<T> setInts(int[] values)
```
 Write an array of int values of the specified length to the pointed memory location
 - setIntsAtOffset
```
public Pointer<T> setIntsAtOffset(long byteOffset,
 int[] values)
```
 Write an array of int values of the specified length to the pointed memory location shifted by a byte offset
 - setIntsAtOffset
```
public Pointer<T> setIntsAtOffset(long byteOffset,
 int[] values,
 int valuesOffset,
 int length)
```
 Write an array of int values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
 - getInt
```
public abstract int getInt()
```
 Read a int value from the pointed memory location
 - getIntAtOffset
```
public abstract int getIntAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getInt() over this method.
 
 Read a int value from the pointed memory location shifted by a byte offset
 - getIntAtIndex
```
public int getIntAtIndex(long valueIndex)
```
 Read the nth contiguous int value from the pointed memory location.
 Equivalent to getIntAtOffset(valueIndex * 4).
 
 Parameters:
 
 valueIndex - index of the value to read
 - getInts
```
public int[] getInts(int length)
```
 Read an array of int values of the specified length from the pointed memory location
 - getInts
```
public int[] getInts()
```
 Read the array of remaining int values from the pointed memory location
 - getIntsAtOffset
```
public int[] getIntsAtOffset(long byteOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getInts(int) over this method.
 
 Read an array of int values of the specified length from the pointed memory location shifted by a byte offset
 - setLong
```
public abstract Pointer<T> setLong(long value)
```
 Write a long value to the pointed memory location
 - setLongAtOffset
```
public abstract Pointer<T> setLongAtOffset(long byteOffset,
 long value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setLong(long) over this method.
 
 Write a long value to the pointed memory location shifted by a byte offset
 - setLongAtIndex
```
public Pointer<T> setLongAtIndex(long valueIndex,
 long value)
```
 Write the nth contiguous long value to the pointed memory location.
 Equivalent to setLongAtOffset(valueIndex * 8, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - long value to write
 - setLongs
```
public Pointer<T> setLongs(long[] values)
```
 Write an array of long values of the specified length to the pointed memory location
 - setLongsAtOffset
```
public Pointer<T> setLongsAtOffset(long byteOffset,
 long[] values)
```
 Write an array of long values of the specified length to the pointed memory location shifted by a byte offset
 - setLongsAtOffset
```
public Pointer<T> setLongsAtOffset(long byteOffset,
 long[] values,
 int valuesOffset,
 int length)
```
 Write an array of long values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
 - getLong
```
public abstract long getLong()
```
 Read a long value from the pointed memory location
 - getLongAtOffset
```
public abstract long getLongAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getLong() over this method.
 
 Read a long value from the pointed memory location shifted by a byte offset
 - getLongAtIndex
```
public long getLongAtIndex(long valueIndex)
```
 Read the nth contiguous long value from the pointed memory location.
 Equivalent to getLongAtOffset(valueIndex * 8).
 
 Parameters:
 
 valueIndex - index of the value to read
 - getLongs
```
public long[] getLongs(int length)
```
 Read an array of long values of the specified length from the pointed memory location
 - getLongs
```
public long[] getLongs()
```
 Read the array of remaining long values from the pointed memory location
 - getLongsAtOffset
```
public long[] getLongsAtOffset(long byteOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getLongs(int) over this method.
 
 Read an array of long values of the specified length from the pointed memory location shifted by a byte offset
 - setShort
```
public abstract Pointer<T> setShort(short value)
```
 Write a short value to the pointed memory location
 - setShortAtOffset
```
public abstract Pointer<T> setShortAtOffset(long byteOffset,
 short value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setShort(short) over this method.
 
 Write a short value to the pointed memory location shifted by a byte offset
 - setShortAtIndex
```
public Pointer<T> setShortAtIndex(long valueIndex,
 short value)
```
 Write the nth contiguous short value to the pointed memory location.
 Equivalent to setShortAtOffset(valueIndex * 2, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - short value to write
 - setShorts
```
public Pointer<T> setShorts(short[] values)
```
 Write an array of short values of the specified length to the pointed memory location
 - setShortsAtOffset
```
public Pointer<T> setShortsAtOffset(long byteOffset,
 short[] values)
```
 Write an array of short values of the specified length to the pointed memory location shifted by a byte offset
 - setShortsAtOffset
```
public Pointer<T> setShortsAtOffset(long byteOffset,
 short[] values,
 int valuesOffset,
 int length)
```
 Write an array of short values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
 - getShort
```
public abstract short getShort()
```
 Read a short value from the pointed memory location
 - getShortAtOffset
```
public abstract short getShortAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getShort() over this method.
 
 Read a short value from the pointed memory location shifted by a byte offset
 - getShortAtIndex
```
public short getShortAtIndex(long valueIndex)
```
 Read the nth contiguous short value from the pointed memory location.
 Equivalent to getShortAtOffset(valueIndex * 2).
 
 Parameters:
 
 valueIndex - index of the value to read
 - getShorts
```
public short[] getShorts(int length)
```
 Read an array of short values of the specified length from the pointed memory location
 - getShorts
```
public short[] getShorts()
```
 Read the array of remaining short values from the pointed memory location
 - getShortsAtOffset
```
public short[] getShortsAtOffset(long byteOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getShorts(int) over this method.
 
 Read an array of short values of the specified length from the pointed memory location shifted by a byte offset
 - setByte
```
public abstract Pointer<T> setByte(byte value)
```
 Write a byte value to the pointed memory location
 - setByteAtOffset
```
public abstract Pointer<T> setByteAtOffset(long byteOffset,
 byte value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setByte(byte) over this method.
 
 Write a byte value to the pointed memory location shifted by a byte offset
 - setByteAtIndex
```
public Pointer<T> setByteAtIndex(long valueIndex,
 byte value)
```
 Write the nth contiguous byte value to the pointed memory location.
 Equivalent to setByteAtOffset(valueIndex * 1, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - byte value to write
 - setBytes
```
public Pointer<T> setBytes(byte[] values)
```
 Write an array of byte values of the specified length to the pointed memory location
 - setBytesAtOffset
```
public Pointer<T> setBytesAtOffset(long byteOffset,
 byte[] values)
```
 Write an array of byte values of the specified length to the pointed memory location shifted by a byte offset
 - setBytesAtOffset
```
public Pointer<T> setBytesAtOffset(long byteOffset,
 byte[] values,
 int valuesOffset,
 int length)
```
 Write an array of byte values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
 - getByte
```
public abstract byte getByte()
```
 Read a byte value from the pointed memory location
 - getByteAtOffset
```
public abstract byte getByteAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getByte() over this method.
 
 Read a byte value from the pointed memory location shifted by a byte offset
 - getByteAtIndex
```
public byte getByteAtIndex(long valueIndex)
```
 Read the nth contiguous byte value from the pointed memory location.
 Equivalent to getByteAtOffset(valueIndex * 1).
 
 Parameters:
 
 valueIndex - index of the value to read
 - getBytes
```
public byte[] getBytes(int length)
```
 Read an array of byte values of the specified length from the pointed memory location
 - getBytes
```
public byte[] getBytes()
```
 Read the array of remaining byte values from the pointed memory location
 - getBytesAtOffset
```
public byte[] getBytesAtOffset(long byteOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getBytes(int) over this method.
 
 Read an array of byte values of the specified length from the pointed memory location shifted by a byte offset
 - setChar
```
public abstract Pointer<T> setChar(char value)
```
 Write a char value to the pointed memory location
 - setCharAtOffset
```
public abstract Pointer<T> setCharAtOffset(long byteOffset,
 char value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setChar(char) over this method.
 
 Write a char value to the pointed memory location shifted by a byte offset
 - setCharAtIndex
```
public Pointer<T> setCharAtIndex(long valueIndex,
 char value)
```
 Write the nth contiguous char value to the pointed memory location.
 Equivalent to setCharAtOffset(valueIndex * Platform.WCHAR_T_SIZE, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - char value to write
 - setChars
```
public Pointer<T> setChars(char[] values)
```
 Write an array of char values of the specified length to the pointed memory location
 - setCharsAtOffset
```
public Pointer<T> setCharsAtOffset(long byteOffset,
 char[] values)
```
 Write an array of char values of the specified length to the pointed memory location shifted by a byte offset
 - setCharsAtOffset
```
public Pointer<T> setCharsAtOffset(long byteOffset,
 char[] values,
 int valuesOffset,
 int length)
```
 Write an array of char values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
 - getChar
```
public abstract char getChar()
```
 Read a char value from the pointed memory location
 - getCharAtOffset
```
public abstract char getCharAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getChar() over this method.
 
 Read a char value from the pointed memory location shifted by a byte offset
 - getCharAtIndex
```
public char getCharAtIndex(long valueIndex)
```
 Read the nth contiguous char value from the pointed memory location.
 Equivalent to getCharAtOffset(valueIndex * Platform.WCHAR_T_SIZE).
 
 Parameters:
 
 valueIndex - index of the value to read
 - getChars
```
public char[] getChars(int length)
```
 Read an array of char values of the specified length from the pointed memory location
 - getChars
```
public char[] getChars()
```
 Read the array of remaining char values from the pointed memory location
 - getCharsAtOffset
```
public char[] getCharsAtOffset(long byteOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getChars(int) over this method.
 
 Read an array of char values of the specified length from the pointed memory location shifted by a byte offset
 - setFloat
```
public abstract Pointer<T> setFloat(float value)
```
 Write a float value to the pointed memory location
 - setFloatAtOffset
```
public abstract Pointer<T> setFloatAtOffset(long byteOffset,
 float value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setFloat(float) over this method.
 
 Write a float value to the pointed memory location shifted by a byte offset
 - setFloatAtIndex
```
public Pointer<T> setFloatAtIndex(long valueIndex,
 float value)
```
 Write the nth contiguous float value to the pointed memory location.
 Equivalent to setFloatAtOffset(valueIndex * 4, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - float value to write
 - setFloats
```
public Pointer<T> setFloats(float[] values)
```
 Write an array of float values of the specified length to the pointed memory location
 - setFloatsAtOffset
```
public Pointer<T> setFloatsAtOffset(long byteOffset,
 float[] values)
```
 Write an array of float values of the specified length to the pointed memory location shifted by a byte offset
 - setFloatsAtOffset
```
public Pointer<T> setFloatsAtOffset(long byteOffset,
 float[] values,
 int valuesOffset,
 int length)
```
 Write an array of float values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
 - getFloat
```
public abstract float getFloat()
```
 Read a float value from the pointed memory location
 - getFloatAtOffset
```
public abstract float getFloatAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getFloat() over this method.
 
 Read a float value from the pointed memory location shifted by a byte offset
 - getFloatAtIndex
```
public float getFloatAtIndex(long valueIndex)
```
 Read the nth contiguous float value from the pointed memory location.
 Equivalent to getFloatAtOffset(valueIndex * 4).
 
 Parameters:
 
 valueIndex - index of the value to read
 - getFloats
```
public float[] getFloats(int length)
```
 Read an array of float values of the specified length from the pointed memory location
 - getFloats
```
public float[] getFloats()
```
 Read the array of remaining float values from the pointed memory location
 - getFloatsAtOffset
```
public float[] getFloatsAtOffset(long byteOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getFloats(int) over this method.
 
 Read an array of float values of the specified length from the pointed memory location shifted by a byte offset
 - setDouble
```
public abstract Pointer<T> setDouble(double value)
```
 Write a double value to the pointed memory location
 - setDoubleAtOffset
```
public abstract Pointer<T> setDoubleAtOffset(long byteOffset,
 double value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setDouble(double) over this method.
 
 Write a double value to the pointed memory location shifted by a byte offset
 - setDoubleAtIndex
```
public Pointer<T> setDoubleAtIndex(long valueIndex,
 double value)
```
 Write the nth contiguous double value to the pointed memory location.
 Equivalent to setDoubleAtOffset(valueIndex * 8, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - double value to write
 - setDoubles
```
public Pointer<T> setDoubles(double[] values)
```
 Write an array of double values of the specified length to the pointed memory location
 - setDoublesAtOffset
```
public Pointer<T> setDoublesAtOffset(long byteOffset,
 double[] values)
```
 Write an array of double values of the specified length to the pointed memory location shifted by a byte offset
 - setDoublesAtOffset
```
public Pointer<T> setDoublesAtOffset(long byteOffset,
 double[] values,
 int valuesOffset,
 int length)
```
 Write an array of double values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
 - getDouble
```
public abstract double getDouble()
```
 Read a double value from the pointed memory location
 - getDoubleAtOffset
```
public abstract double getDoubleAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getDouble() over this method.
 
 Read a double value from the pointed memory location shifted by a byte offset
 - getDoubleAtIndex
```
public double getDoubleAtIndex(long valueIndex)
```
 Read the nth contiguous double value from the pointed memory location.
 Equivalent to getDoubleAtOffset(valueIndex * 8).
 
 Parameters:
 
 valueIndex - index of the value to read
 - getDoubles
```
public double[] getDoubles(int length)
```
 Read an array of double values of the specified length from the pointed memory location
 - getDoubles
```
public double[] getDoubles()
```
 Read the array of remaining double values from the pointed memory location
 - getDoublesAtOffset
```
public double[] getDoublesAtOffset(long byteOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getDoubles(int) over this method.
 
 Read an array of double values of the specified length from the pointed memory location shifted by a byte offset
 - setBoolean
```
public abstract Pointer<T> setBoolean(boolean value)
```
 Write a boolean value to the pointed memory location
 - setBooleanAtOffset
```
public abstract Pointer<T> setBooleanAtOffset(long byteOffset,
 boolean value)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour setBoolean(boolean) over this method.
 
 Write a boolean value to the pointed memory location shifted by a byte offset
 - setBooleanAtIndex
```
public Pointer<T> setBooleanAtIndex(long valueIndex,
 boolean value)
```
 Write the nth contiguous boolean value to the pointed memory location.
 Equivalent to setBooleanAtOffset(valueIndex * 1, value).
 
 Parameters:
 
 valueIndex - index of the value to write
 
 value - boolean value to write
 - setBooleans
```
public Pointer<T> setBooleans(boolean[] values)
```
 Write an array of boolean values of the specified length to the pointed memory location
 - setBooleansAtOffset
```
public Pointer<T> setBooleansAtOffset(long byteOffset,
 boolean[] values)
```
 Write an array of boolean values of the specified length to the pointed memory location shifted by a byte offset
 - setBooleansAtOffset
```
public Pointer<T> setBooleansAtOffset(long byteOffset,
 boolean[] values,
 int valuesOffset,
 int length)
```
 Write an array of boolean values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given array offset and for the given length from the provided array.
 - getBoolean
```
public abstract boolean getBoolean()
```
 Read a boolean value from the pointed memory location
 - getBooleanAtOffset
```
public abstract boolean getBooleanAtOffset(long byteOffset)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getBoolean() over this method.
 
 Read a boolean value from the pointed memory location shifted by a byte offset
 - getBooleanAtIndex
```
public boolean getBooleanAtIndex(long valueIndex)
```
 Read the nth contiguous boolean value from the pointed memory location.
 Equivalent to getBooleanAtOffset(valueIndex * 1).
 
 Parameters:
 
 valueIndex - index of the value to read
 - getBooleans
```
public boolean[] getBooleans(int length)
```
 Read an array of boolean values of the specified length from the pointed memory location
 - getBooleans
```
public boolean[] getBooleans()
```
 Read the array of remaining boolean values from the pointed memory location
 - getBooleansAtOffset
```
public boolean[] getBooleansAtOffset(long byteOffset,
 int length)
```
 Deprecated. Avoid using the byte offset methods variants unless you know what you're doing (may cause alignment issues). Please favour getBooleans(int) over this method.
 
 Read an array of boolean values of the specified length from the pointed memory location shifted by a byte offset
 - getInts
```
public void getInts(int[] dest)
```
 Read int values into the specified destination array from the pointed memory location
 - getInts
```
public void getInts(IntBuffer dest)
```
 Read int values into the specified destination buffer from the pointed memory location
 - getIntsAtOffset
```
public void getIntsAtOffset(long byteOffset,
 int[] dest,
 int destOffset,
 int length)
```
 Read length int values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
 - setInts
```
public Pointer<T> setInts(IntBuffer values)
```
 Write a buffer of int values of the specified length to the pointed memory location
 - setIntsAtOffset
```
public Pointer<T> setIntsAtOffset(long byteOffset,
 IntBuffer values)
```
 Write a buffer of int values of the specified length to the pointed memory location shifted by a byte offset
 - setIntsAtOffset
```
public Pointer<T> setIntsAtOffset(long byteOffset,
 IntBuffer values,
 long valuesOffset,
 long length)
```
 Write a buffer of int values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
 - getIntBuffer
```
public IntBuffer getIntBuffer(long length)
```
 Get a direct buffer of int values of the specified length that points to this pointer's target memory location
 - getIntBuffer
```
public IntBuffer getIntBuffer()
```
 Get a direct buffer of int values that points to this pointer's target memory locations
 - getIntBufferAtOffset
```
public IntBuffer getIntBufferAtOffset(long byteOffset,
 long length)
```
 Get a direct buffer of int values of the specified length that points to this pointer's target memory location shifted by a byte offset
 - getLongs
```
public void getLongs(long[] dest)
```
 Read long values into the specified destination array from the pointed memory location
 - getLongs
```
public void getLongs(LongBuffer dest)
```
 Read long values into the specified destination buffer from the pointed memory location
 - getLongsAtOffset
```
public void getLongsAtOffset(long byteOffset,
 long[] dest,
 int destOffset,
 int length)
```
 Read length long values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
 - setLongs
```
public Pointer<T> setLongs(LongBuffer values)
```
 Write a buffer of long values of the specified length to the pointed memory location
 - setLongsAtOffset
```
public Pointer<T> setLongsAtOffset(long byteOffset,
 LongBuffer values)
```
 Write a buffer of long values of the specified length to the pointed memory location shifted by a byte offset
 - setLongsAtOffset
```
public Pointer<T> setLongsAtOffset(long byteOffset,
 LongBuffer values,
 long valuesOffset,
 long length)
```
 Write a buffer of long values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
 - getLongBuffer
```
public LongBuffer getLongBuffer(long length)
```
 Get a direct buffer of long values of the specified length that points to this pointer's target memory location
 - getLongBuffer
```
public LongBuffer getLongBuffer()
```
 Get a direct buffer of long values that points to this pointer's target memory locations
 - getLongBufferAtOffset
```
public LongBuffer getLongBufferAtOffset(long byteOffset,
 long length)
```
 Get a direct buffer of long values of the specified length that points to this pointer's target memory location shifted by a byte offset
 - getShorts
```
public void getShorts(short[] dest)
```
 Read short values into the specified destination array from the pointed memory location
 - getShorts
```
public void getShorts(ShortBuffer dest)
```
 Read short values into the specified destination buffer from the pointed memory location
 - getShortsAtOffset
```
public void getShortsAtOffset(long byteOffset,
 short[] dest,
 int destOffset,
 int length)
```
 Read length short values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
 - setShorts
```
public Pointer<T> setShorts(ShortBuffer values)
```
 Write a buffer of short values of the specified length to the pointed memory location
 - setShortsAtOffset
```
public Pointer<T> setShortsAtOffset(long byteOffset,
 ShortBuffer values)
```
 Write a buffer of short values of the specified length to the pointed memory location shifted by a byte offset
 - setShortsAtOffset
```
public Pointer<T> setShortsAtOffset(long byteOffset,
 ShortBuffer values,
 long valuesOffset,
 long length)
```
 Write a buffer of short values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
 - getShortBuffer
```
public ShortBuffer getShortBuffer(long length)
```
 Get a direct buffer of short values of the specified length that points to this pointer's target memory location
 - getShortBuffer
```
public ShortBuffer getShortBuffer()
```
 Get a direct buffer of short values that points to this pointer's target memory locations
 - getShortBufferAtOffset
```
public ShortBuffer getShortBufferAtOffset(long byteOffset,
 long length)
```
 Get a direct buffer of short values of the specified length that points to this pointer's target memory location shifted by a byte offset
 - getBytes
```
public void getBytes(byte[] dest)
```
 Read byte values into the specified destination array from the pointed memory location
 - getBytes
```
public void getBytes(ByteBuffer dest)
```
 Read byte values into the specified destination buffer from the pointed memory location
 - getBytesAtOffset
```
public void getBytesAtOffset(long byteOffset,
 byte[] dest,
 int destOffset,
 int length)
```
 Read length byte values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
 - setBytes
```
public Pointer<T> setBytes(ByteBuffer values)
```
 Write a buffer of byte values of the specified length to the pointed memory location
 - setBytesAtOffset
```
public Pointer<T> setBytesAtOffset(long byteOffset,
 ByteBuffer values)
```
 Write a buffer of byte values of the specified length to the pointed memory location shifted by a byte offset
 - setBytesAtOffset
```
public Pointer<T> setBytesAtOffset(long byteOffset,
 ByteBuffer values,
 long valuesOffset,
 long length)
```
 Write a buffer of byte values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
 - getByteBuffer
```
public ByteBuffer getByteBuffer(long length)
```
 Get a direct buffer of byte values of the specified length that points to this pointer's target memory location
 - getByteBuffer
```
public ByteBuffer getByteBuffer()
```
 Get a direct buffer of byte values that points to this pointer's target memory locations
 - getByteBufferAtOffset
```
public ByteBuffer getByteBufferAtOffset(long byteOffset,
 long length)
```
 Get a direct buffer of byte values of the specified length that points to this pointer's target memory location shifted by a byte offset
 - setChars
```
public Pointer<T> setChars(CharBuffer values)
```
 Write a buffer of char values of the specified length to the pointed memory location
 - setCharsAtOffset
```
public Pointer<T> setCharsAtOffset(long byteOffset,
 CharBuffer values)
```
 Write a buffer of char values of the specified length to the pointed memory location shifted by a byte offset
 - setCharsAtOffset
```
public Pointer<T> setCharsAtOffset(long byteOffset,
 CharBuffer values,
 long valuesOffset,
 long length)
```
 Write a buffer of char values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
 - getFloats
```
public void getFloats(float[] dest)
```
 Read float values into the specified destination array from the pointed memory location
 - getFloats
```
public void getFloats(FloatBuffer dest)
```
 Read float values into the specified destination buffer from the pointed memory location
 - getFloatsAtOffset
```
public void getFloatsAtOffset(long byteOffset,
 float[] dest,
 int destOffset,
 int length)
```
 Read length float values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
 - setFloats
```
public Pointer<T> setFloats(FloatBuffer values)
```
 Write a buffer of float values of the specified length to the pointed memory location
 - setFloatsAtOffset
```
public Pointer<T> setFloatsAtOffset(long byteOffset,
 FloatBuffer values)
```
 Write a buffer of float values of the specified length to the pointed memory location shifted by a byte offset
 - setFloatsAtOffset
```
public Pointer<T> setFloatsAtOffset(long byteOffset,
 FloatBuffer values,
 long valuesOffset,
 long length)
```
 Write a buffer of float values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
 - getFloatBuffer
```
public FloatBuffer getFloatBuffer(long length)
```
 Get a direct buffer of float values of the specified length that points to this pointer's target memory location
 - getFloatBuffer
```
public FloatBuffer getFloatBuffer()
```
 Get a direct buffer of float values that points to this pointer's target memory locations
 - getFloatBufferAtOffset
```
public FloatBuffer getFloatBufferAtOffset(long byteOffset,
 long length)
```
 Get a direct buffer of float values of the specified length that points to this pointer's target memory location shifted by a byte offset
 - getDoubles
```
public void getDoubles(double[] dest)
```
 Read double values into the specified destination array from the pointed memory location
 - getDoubles
```
public void getDoubles(DoubleBuffer dest)
```
 Read double values into the specified destination buffer from the pointed memory location
 - getDoublesAtOffset
```
public void getDoublesAtOffset(long byteOffset,
 double[] dest,
 int destOffset,
 int length)
```
 Read length double values into the specified destination array from the pointed memory location shifted by a byte offset, storing values after the provided destination offset.
 - setDoubles
```
public Pointer<T> setDoubles(DoubleBuffer values)
```
 Write a buffer of double values of the specified length to the pointed memory location
 - setDoublesAtOffset
```
public Pointer<T> setDoublesAtOffset(long byteOffset,
 DoubleBuffer values)
```
 Write a buffer of double values of the specified length to the pointed memory location shifted by a byte offset
 - setDoublesAtOffset
```
public Pointer<T> setDoublesAtOffset(long byteOffset,
 DoubleBuffer values,
 long valuesOffset,
 long length)
```
 Write a buffer of double values of the specified length to the pointed memory location shifted by a byte offset, reading values at the given buffer offset and for the given length from the provided buffer.
 - getDoubleBuffer
```
public DoubleBuffer getDoubleBuffer(long length)
```
 Get a direct buffer of double values of the specified length that points to this pointer's target memory location
 - getDoubleBuffer
```
public DoubleBuffer getDoubleBuffer()
```
 Get a direct buffer of double values that points to this pointer's target memory locations
 - getDoubleBufferAtOffset
```
public DoubleBuffer getDoubleBufferAtOffset(long byteOffset,
 long length)
```
 Get a direct buffer of double values of the specified length that points to this pointer's target memory location shifted by a byte offset
 - getString
```
public String getString(Pointer.StringType type)
```
 Read a native string from the pointed memory location using the default charset.
 See getStringAtOffset(long, StringType, Charset) for more options.
 
 Parameters:
 
 type - Type of the native String to read. See Pointer.StringType for details on the supported types.
 
 Returns:
 
 string read from native memory
 - getString
```
public String getString(Pointer.StringType type,
 Charset charset)
```
 Read a native string from the pointed memory location, using the provided charset or the system's default if not provided. See getStringAtOffset(long, StringType, Charset) for more options.
 
 Parameters:
 
 type - Type of the native String to read. See Pointer.StringType for details on the supported types.
 
 charset - Character set used to convert bytes to String characters. If null, Charset.defaultCharset() will be used
 
 Returns:
 
 string read from native memory
 - getStringAtOffset
```
public String getStringAtOffset(long byteOffset,
 Pointer.StringType type,
 Charset charset)
```
 Read a native string from the pointed memory location shifted by a byte offset, using the provided charset or the system's default if not provided.
 
 Parameters:
 
 byteOffset -
 
 charset - Character set used to convert bytes to String characters. If null, Charset.defaultCharset() will be used
 
 type - Type of the native String to read. See Pointer.StringType for details on the supported types.
 
 Returns:
 
 string read from native memory
 - setString
```
public Pointer<T> setString(String s,
 Pointer.StringType type)
```
 Write a native string to the pointed memory location using the default charset.
 See setStringAtOffset(long, String, StringType, Charset) for more options.
 
 Parameters:
 
 s - string to write
 
 type - Type of the native String to write. See Pointer.StringType for details on the supported types.
 
 Returns:
 
 this
 - setStringAtOffset
```
public Pointer<T> setStringAtOffset(long byteOffset,
 String s,
 Pointer.StringType type,
 Charset charset)
```
 Write a native string to the pointed memory location shifted by a byte offset, using the provided charset or the system's default if not provided.
 
 Parameters:
 
 byteOffset -
 
 s - string to write
 
 charset - Character set used to convert String characters to bytes. If null, Charset.defaultCharset() will be used
 
 type - Type of the native String to write. See Pointer.StringType for details on the supported types.
 
 Returns:
 
 this
 - pointerToString
```
public static Pointer<?> pointerToString(String string,
 Pointer.StringType type,
 Charset charset)
```
 Allocate memory and write a string to it, using the system's default charset to convert the string (See Pointer.StringType for details on the supported types).
 See setString(String, StringType), getString(StringType).
 
 Parameters:
 
 charset - Character set used to convert String characters to bytes. If null, Charset.defaultCharset() will be used
 
 type - Type of the native String to create.
 - pointerToCString
```
public static Pointer<Byte> pointerToCString(String string)
```
 Allocate memory and write a C string to it, using the system's default charset to convert the string. (see Pointer.StringType.C).
 See setCString(String), getCString().
 See pointerToString(String, StringType, Charset) for choice of the String type or Charset.
 - pointerToCStrings
```
public static Pointer<Pointer<Byte>> pointerToCStrings(String... strings)
```
 Allocate an array of pointers to strings.
 - pointerToWideCString
```
public static Pointer<Character> pointerToWideCString(String string)
```
 Allocate memory and write a WideC string to it, using the system's default charset to convert the string. (see Pointer.StringType.WideC).
 See setWideCString(String), getWideCString().
 See pointerToString(String, StringType, Charset) for choice of the String type or Charset.
 - pointerToWideCStrings
```
public static Pointer<Pointer<Character>> pointerToWideCStrings(String... strings)
```
 Allocate an array of pointers to strings.
 - getCString
```
public String getCString()
```
 Read a C string using the default charset from the pointed memory location (see Pointer.StringType.C).
 See getCStringAtOffset(long), getString(StringType) and getStringAtOffset(long, StringType, Charset) for more options
 - getCStringAtOffset
```
public String getCStringAtOffset(long byteOffset)
```
 Read a C string using the default charset from the pointed memory location shifted by a byte offset (see Pointer.StringType.C).
 See getStringAtOffset(long, StringType, Charset) for more options
 - setCString
```
public Pointer<T> setCString(String s)
```
 Write a C string using the default charset to the pointed memory location (see Pointer.StringType.C).
 See setCStringAtOffset(long, String) and setStringAtOffset(long, String, StringType, Charset) for more options
 - setCStringAtOffset
```
public Pointer<T> setCStringAtOffset(long byteOffset,
 String s)
```
 Write a C string using the default charset to the pointed memory location shifted by a byte offset (see Pointer.StringType.C).
 See setStringAtOffset(long, String, StringType, Charset) for more options
 - getWideCString
```
public String getWideCString()
```
 Read a WideC string using the default charset from the pointed memory location (see Pointer.StringType.WideC).
 See getWideCStringAtOffset(long), getString(StringType) and getStringAtOffset(long, StringType, Charset) for more options
 - getWideCStringAtOffset
```
public String getWideCStringAtOffset(long byteOffset)
```
 Read a WideC string using the default charset from the pointed memory location shifted by a byte offset (see Pointer.StringType.WideC).
 See getStringAtOffset(long, StringType, Charset) for more options
 - setWideCString
```
public Pointer<T> setWideCString(String s)
```
 Write a WideC string using the default charset to the pointed memory location (see Pointer.StringType.WideC).
 See setWideCStringAtOffset(long, String) and setStringAtOffset(long, String, StringType, Charset) for more options
 - setWideCStringAtOffset
```
public Pointer<T> setWideCStringAtOffset(long byteOffset,
 String s)
```
 Write a WideC string using the default charset to the pointed memory location shifted by a byte offset (see Pointer.StringType.WideC).
 See setStringAtOffset(long, String, StringType, Charset) for more options
 - clearValidBytes
```
public void clearValidBytes()
```
 Write zero bytes to all of the valid bytes pointed by this pointer
 - clearBytes
```
public void clearBytes(long length)
```
 Write zero bytes to the first length bytes pointed by this pointer
 - clearBytesAtOffset
```
public void clearBytesAtOffset(long byteOffset,
 long length,
 byte value)
```
 Write a byte value to each of the length bytes at the address pointed to by this pointer shifted by a byteOffset
 - findByte
```
public Pointer<T> findByte(long byteOffset,
 byte value,
 long searchLength)
```
 Find the first occurrence of a value in the memory block of length searchLength bytes pointed by this pointer shifted by a byteOffset
 - apply
```
public final T apply(long index)
```
 Alias for get(long) defined for more natural use from the Scala language.
 - update
```
public final void update(long index,
 T element)
```
 Alias for set(long, Object) defined for more natural use from the Scala language.
 - toArray
```
public T[] toArray()
```
 Create an array with all the values in the bounded memory area.
 Note that if you wish to get an array of primitives (if T is boolean, char or a numeric type), then you need to call getArray().
 
 Throws:
 
 IndexOutOfBoundsException - if this pointer's bounds are unknown
 - toArray
```
public  U[] toArray(U[] array)
```
 Create an array with all the values in the bounded memory area, reusing the provided array if its type is compatible and its size is big enough.
 Note that if you wish to get an array of primitives (if T is boolean, char or a numeric type), then you need to call getArray().
 
 Throws:
 
 IndexOutOfBoundsException - if this pointer's bounds are unknown
 - asList
```
public NativeList<T> asList()
```
 Create a Pointer.ListType.FixedCapacity native list that uses this pointer as storage (and has this pointer's pointed valid elements as initial content).
 Same as asList(ListType)(Pointer.ListType.FixedCapacity).
 - asList
```
public NativeList<T> asList(Pointer.ListType type)
```
 Create a native list that uses this pointer as initial storage (and has this pointer's pointed valid elements as initial content).
 If the list is Pointer.ListType.Dynamic and if its capacity is grown at some point, this pointer will probably no longer point to the native memory storage of the list, so you need to get back the pointer with NativeList.getPointer() when you're done mutating the list.
 - allocateList
```
public static <E> NativeList<E> allocateList(PointerIO<E> io,
 long capacity)
```
 Create a Pointer.ListType.Dynamic list with the provided initial capacity (see Pointer.ListType.Dynamic).
 
 Parameters:
 
 io - Type of the elements of the list
 
 capacity - Initial capacity of the list
 - allocateList
```
public static <E> NativeList<E> allocateList(Class<E> type,
 long capacity)
```
 Create a Pointer.ListType.Dynamic list with the provided initial capacity (see Pointer.ListType.Dynamic).
 
 Parameters:
 
 type - Type of the elements of the list
 
 capacity - Initial capacity of the list
 - allocateList
```
public static <E> NativeList<E> allocateList(Type type,
 long capacity)
```
 Create a Pointer.ListType.Dynamic list with the provided initial capacity (see Pointer.ListType.Dynamic).
 
 Parameters:
 
 type - Type of the elements of the list
 
 capacity - Initial capacity of the list
 - setIntegralAtOffset
```
public Pointer<T> setIntegralAtOffset(long byteOffset,
 org.bridj.AbstractIntegral value)
```
 - getIntegralAtOffset
```
public long getIntegralAtOffset(long byteOffset,
 int integralSize)
```

Class Pointer<T>

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

NULL

SIZE

defaultAlignment

Method Detail

pointerType

intEnumType

release

compareTo

compareBytes

compareBytesAtOffset

hashCode

toString

offset

validBytes

withoutValidityInformation

clone

validElements

getReference

getPeer

allocateDynamicCallback

as

order

order

getIO

isOrdered

as

as

asDynamicFunction

asUntyped

getValidBytes

getValidElements

iterator

pointerToEnum

pointerTo

getPointer

getPointer

getPointer

getAddress

getNativeObjectAtOffset

setNativeObject

getNativeObjectAtOffset

getNativeObject

getNativeObject

isAligned

isAligned

get

get

get

set

set

getPeer

getTargetSize

next

next

release

equals

pointerToAddress

pointerToAddress

pointerToAddress

pointerToAddress

pointerToAddress

pointerToAddress

pointerToAddress

pointerToAddress

pointerToAddress

pointerToAddress

allocateTypedPointer

allocateTypedPointers

allocatePointer

allocatePointer

allocatePointerPointer

allocatePointerPointer

allocatePointer