org.bytedeco.arrow

Class ArrowBuffer

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.arrow.ArrowBuffer

All Implemented Interfaces:

AutoCloseable

Direct Known Subclasses:

MutableBuffer

@Name(value="arrow::Buffer")
 @NoOffset
 @Properties(inherit=arrow.class)
public class ArrowBuffer
extends Pointer

\class Buffer \brief Object containing a pointer to a piece of contiguous memory with a particular size. Buffers have two related notions of length: size and capacity. Size is the number of bytes that might have valid data. Capacity is the number of bytes that were allocated for the buffer in total. The Buffer base class does not own its memory, but subclasses often do. The following invariant is always true: Size <= Capacity

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
ArrowBuffer(ArrowBuffer parent, long offset, long size) An offset into data that is owned by another buffer, but we want to be able to retain a valid pointer to it even after other shared_ptr's to the parent buffer have been destroyed This method makes no assertions about alignment or padding of the buffer but in general we expected buffers to be aligned and padded to 64 bytes.
ArrowBuffer(byte[] data, long size)
ArrowBuffer(ByteBuffer data, long size)
ArrowBuffer(BytePointer data, long size) \brief Construct from buffer and size without copying memory
ArrowBuffer(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
long	_capacity() \brief Return the buffer's capacity (number of allocated bytes)
Status	Copy(long start, long nbytes, ArrowBuffer out) Copy a section of the buffer using the default memory pool into a new Buffer.
Status	Copy(long start, long nbytes, MemoryPool pool, ArrowBuffer out) Copy a section of the buffer into a new Buffer.
BytePointer	data() \brief Return a pointer to the buffer's data
boolean	Equals(ArrowBuffer other) Return true if both buffers are the same size and contain the same bytes
boolean	Equals(ArrowBuffer other, long nbytes) Return true if both buffers are the same size and contain the same bytes up to the number of compared bytes
static ArrowBuffer	FromString(BytePointer data) \brief Construct an immutable buffer that takes ownership of the contents of an std::string
static Status	FromString(BytePointer data, ArrowBuffer out)
static Status	FromString(BytePointer data, MemoryPool pool, ArrowBuffer out)
static ArrowBuffer	FromString(String data)
static Status	FromString(String data, ArrowBuffer out) \brief Construct a new buffer that owns its memory from a std::string using the default memory pool
static Status	FromString(String data, MemoryPool pool, ArrowBuffer out) \brief Construct a new buffer that owns its memory from a std::string
byte	get(long i)
boolean	is_mutable()
BytePointer	mutable_data() \brief Return a writable pointer to the buffer's data The buffer has to be mutable.
ArrowBuffer	parent()
long	size() \brief Return the buffer's size in bytes
String	ToHexString() \brief Construct a new std::string with a hexadecimal representation of the buffer.
String	ToString() \brief Copy buffer contents into a new std::string
void	ZeroPadding() Zero bytes in padding, i.e.

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

ArrowBuffer

public ArrowBuffer(Pointer p)

Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

ArrowBuffer

public ArrowBuffer(@Cast(value="const uint8_t*")
                   BytePointer data,
                   @Cast(value="int64_t")
                   long size)

\brief Construct from buffer and size without copying memory

Parameters:

data - [in] a memory buffer

size - [in] buffer size \note The passed memory must be kept alive through some other means

ArrowBuffer

public ArrowBuffer(@Cast(value="const uint8_t*")
                   ByteBuffer data,
                   @Cast(value="int64_t")
                   long size)

ArrowBuffer

public ArrowBuffer(@Cast(value="const uint8_t*")
                   byte[] data,
                   @Cast(value="int64_t")
                   long size)

ArrowBuffer

public ArrowBuffer(@SharedPtr
                   ArrowBuffer parent,
                   @Cast(value="const int64_t")
                   long offset,
                   @Cast(value="const int64_t")
                   long size)

An offset into data that is owned by another buffer, but we want to be able to retain a valid pointer to it even after other shared_ptr's to the parent buffer have been destroyed This method makes no assertions about alignment or padding of the buffer but in general we expected buffers to be aligned and padded to 64 bytes. In the future we might add utility methods to help determine if a buffer satisfies this contract.

Method Detail

get

@Cast(value="uint8_t")
 @Name(value="operator []")
public byte get(@Cast(value="std::size_t")
                                                                   long i)

is_mutable

@Cast(value="bool")
public boolean is_mutable()

ToHexString

@StdString
public String ToHexString()

\brief Construct a new std::string with a hexadecimal representation of the buffer.

Returns:

std::string

Equals

@Cast(value="bool")
public boolean Equals(@Const @ByRef
                                          ArrowBuffer other,
                                          @Cast(value="int64_t")
                                          long nbytes)

Return true if both buffers are the same size and contain the same bytes up to the number of compared bytes

Equals

@Cast(value="bool")
public boolean Equals(@Const @ByRef
                                          ArrowBuffer other)

Return true if both buffers are the same size and contain the same bytes

Copy

@ByVal
public Status Copy(@Cast(value="const int64_t")
                          long start,
                          @Cast(value="const int64_t")
                          long nbytes,
                          MemoryPool pool,
                          @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                          ArrowBuffer out)

Copy a section of the buffer into a new Buffer.

Copy

@ByVal
public Status Copy(@Cast(value="const int64_t")
                          long start,
                          @Cast(value="const int64_t")
                          long nbytes,
                          @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                          ArrowBuffer out)

Copy a section of the buffer using the default memory pool into a new Buffer.

ZeroPadding

public void ZeroPadding()

Zero bytes in padding, i.e. bytes between size_ and capacity_.

FromString

@ByVal
public static Status FromString(@StdString
                                       String data,
                                       MemoryPool pool,
                                       @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                       ArrowBuffer out)

\brief Construct a new buffer that owns its memory from a std::string

Parameters:

data - [in] a std::string object

pool - [in] a memory pool

out - [out] the created buffer

Returns:

Status message

FromString

@ByVal
public static Status FromString(@StdString
                                       BytePointer data,
                                       MemoryPool pool,
                                       @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                       ArrowBuffer out)

FromString

@ByVal
public static Status FromString(@StdString
                                       String data,
                                       @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                       ArrowBuffer out)

\brief Construct a new buffer that owns its memory from a std::string using the default memory pool

FromString

@ByVal
public static Status FromString(@StdString
                                       BytePointer data,
                                       @SharedPtr @Cast(value={"","std::shared_ptr<arrow::Buffer>*"})
                                       ArrowBuffer out)

FromString

@SharedPtr
 @ByVal
public static ArrowBuffer FromString(@Cast(value={"","std::string&&"}) @StdString
                                                        BytePointer data)

\brief Construct an immutable buffer that takes ownership of the contents of an std::string

Parameters:

data - [in] an rvalue-reference of a string

Returns:

a new Buffer instance

FromString

@SharedPtr
 @ByVal
public static ArrowBuffer FromString(@Cast(value={"","std::string&&"}) @StdString
                                                        String data)

ToString

@StdString
public String ToString()

\brief Copy buffer contents into a new std::string

Returns:

std::string \note Can throw std::bad_alloc if buffer is large

data

@Cast(value="const uint8_t*")
public BytePointer data()

\brief Return a pointer to the buffer's data

mutable_data

@Cast(value="uint8_t*")
public BytePointer mutable_data()

\brief Return a writable pointer to the buffer's data The buffer has to be mutable. Otherwise, an assertion may be thrown or a null pointer may be returned.

size

@Cast(value="int64_t")
public long size()

\brief Return the buffer's size in bytes

_capacity

@Cast(value="int64_t")
 @Name(value="capacity")
public long _capacity()

\brief Return the buffer's capacity (number of allocated bytes)

parent

@SharedPtr
public ArrowBuffer parent()