#include <FlatBuffer.h>

Classes
struct	BaseWorker

struct	GeoPoint

struct	GeoPointWorker

struct	NestedArray

struct	NestedArrayItem

struct	NestedArrayWorker

Public Types
enum	ValueType { Bool8, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Float32, Float64, PointInt32, PointFloat64 }

enum	Status { Success = 0, IndexError, SubIndexError, SizeError, FlatbufferSizeError, ItemAlreadySpecifiedError, ItemUnspecifiedError, UnexpectedNullItemError, ValuesBufferTooSmallError, SizesBufferTooSmallError, CompressedIndices2BufferTooSmallError, MemoryError, NotImplementedError, NotSupportedFormatError, InvalidUserDataError, DimensionalityError, TypeError, UserDataError, InconsistentSizesError, UnknownFormatError }

typedef int32_t	sizes_t

typedef int64_t	offsets_t

Public Member Functions
int64_t	getBufferSize () const

HOST DEVICE bool	isNestedArray () const

HOST DEVICE size_t	getValueSize () const

HOST DEVICE size_t	getValuesBufferSize () const

HOST DEVICE const int8_t *	getValuesBuffer () const

size_t	getValuesCount () const

HOST DEVICE FlatBufferFormat	format () const

HOST DEVICE int64_t	itemsCount () const

HOST DEVICE int64_t	valueByteSize () const

HOST DEVICE int64_t	dtypeSize () const

HOST DEVICE BaseWorker *	getBaseWorker ()

HOST DEVICE const BaseWorker *	getBaseWorker () const

	FLATBUFFER_MANAGER_FORMAT_TOOLS (GeoPoint)

	FLATBUFFER_MANAGER_FORMAT_TOOLS (NestedArray)

Status	initializeNestedArray (int64_t ndims, int64_t total_items_count, int64_t total_sizes_count, int64_t total_values_count, ValueType value_type, const int8_t null_value_ptr, const int8_t user_data_ptr, size_t user_data_size)

void	initialize (FlatBufferFormat format_id, const int8_t *format_metadata_ptr)

HOST DEVICE size_t	getNDims () const

int64_t	get_max_nof_values () const

HOST DEVICE int64_t &	get_storage_count ()

const int64_t &	get_storage_count () const

int64_t	get_values_buffer_size () const

HOST DEVICE int8_t *	get_values ()

HOST DEVICE const int8_t *	get_values () const

	FLATBUFFER_GET_BUFFER_METHODS (user_data_buffer, int8_t)

	FLATBUFFER_GET_BUFFER_METHODS (values_buffer, int8_t)

	FLATBUFFER_GET_BUFFER_METHODS (sizes_buffer, sizes_t)

	FLATBUFFER_GET_BUFFER_METHODS (values_offsets, offsets_t)

	FLATBUFFER_GET_BUFFER_METHODS (sizes_offsets, offsets_t)

HOST DEVICE const int8_t *	getNullValuePtr () const

HOST DEVICE bool	containsNullValue (const int8_t *value_ptr) const

HOST DEVICE sizes_t *	get_storage_indices ()

HOST DEVICE const sizes_t *	get_storage_indices () const

HOST DEVICE sizes_t	get_storage_index (const int64_t index) const

template<size_t NDIM>
HOST DEVICE Status	isNull (const int64_t index[NDIM], const size_t n, bool &is_null)

template<size_t NDIM = 1>
HOST DEVICE Status	getLength (const int64_t index, size_t &length)

template<size_t NDIM>
HOST DEVICE Status	getLength (const int64_t index[NDIM], const size_t n, size_t &length) const

template<size_t NDIM>
HOST DEVICE Status	getItemWorker (const int64_t index[NDIM], const size_t n, int8_t &values, int32_t &nof_values, int32_t sizes_buffers[NDIM], int32_t sizes_lengths[NDIM], int32_t &nof_sizes, bool &is_null)

template<size_t NDIM>
HOST DEVICE Status	getItem (const int64_t index, NestedArrayItem< NDIM > &result)

template<size_t NDIM>
HOST DEVICE Status	getItem (const int64_t index[NDIM], const size_t n, NestedArrayItem< NDIM > &result)

template<size_t NDIM, bool check_sizes = true>
HOST DEVICE Status	setItemWorker (const int64_t index, const int8_t values, const int32_t nof_values, const int32_t const sizes_buffers[NDIM], const int32_t sizes_lengths[NDIM], const int32_t nof_sizes)

template<size_t NDIM, bool check_sizes = true>
HOST DEVICE Status	concatItemWorker (const int64_t index, const int8_t values, const int32_t nof_values, const int32_t const sizes_buffers[NDIM], const int32_t sizes_lengths[NDIM], const int32_t nof_sizes)

template<size_t NDIM = 1, bool check_sizes = true>
HOST DEVICE Status	setItem (const int64_t index, const int8_t *values_buf, const int32_t nof_values)

template<size_t NDIM = 1, bool check_sizes = true>
HOST DEVICE Status	setItem (const int64_t index, const int8_t values_buf, const int32_t nof_values, const int32_t sizes_buf, const int32_t nof_sizes)

template<size_t NDIM = 2, bool check_sizes = true>
HOST DEVICE Status	setItem (const int64_t index, const int8_t values_buf, const int32_t nof_values, const int32_t sizes_buf, const int32_t nof_sizes, const int32_t *sizes_of_sizes_buf, const int32_t nof_sizes_of_sizes)

template<size_t NDIM = 1, bool check_sizes = true>
HOST DEVICE Status	setItem (const int64_t index, const NestedArrayItem< NDIM > &item)

template<size_t NDIM = 0, bool check_sizes = true>
HOST DEVICE Status	concatItem (const int64_t index, const int8_t *values_buf, const int32_t nof_values)

template<size_t NDIM = 1, bool check_sizes = true>
HOST DEVICE Status	concatItem (const int64_t index, const NestedArrayItem< NDIM > &item)

Status	getItem (const int64_t index, std::string &s, bool &is_null)

template<typename CT >
Status	getItem (const int64_t index, std::vector< CT > &values, std::vector< int32_t > &sizes, bool &is_null)

template<typename CT >
Status	getItem (const int64_t index, std::vector< CT > &values, std::vector< int32_t > &sizes, std::vector< int32_t > &sizes_of_sizes, bool &is_null)

Status	setItem (const int64_t index, const std::string &s)

template<typename CT , size_t NDIM = 0>
Status	setItem (const int64_t index, const std::vector< CT > &arr)

template<typename CT , size_t NDIM = 1, bool check_sizes = false>
Status	setItem (const int64_t index, const std::vector< std::vector< CT >> &item)

template<typename CT , size_t NDIM = 2, bool check_sizes = false>
Status	setItem (const int64_t index, const std::vector< std::vector< std::vector< CT >>> &item)

template<typename CT , size_t NDIM = 1, bool check_sizes = true>
Status	setItem (const int64_t index, const std::vector< CT > &values, const std::vector< int32_t > &sizes)

template<typename CT , size_t NDIM = 2, bool check_sizes = true>
Status	setItem (const int64_t index, const std::vector< CT > &values, const std::vector< int32_t > &sizes, const std::vector< int32_t > &sizes_of_sizes)

Status	setItemOld (const int64_t index, const int8_t src, const int64_t size, int8_t *dest=nullptr)

Status	setItemNoValidation (const int64_t index, const int8_t src, const int64_t size, int8_t *dest)

Status	setEmptyItemNoValidation (int64_t index, int64_t size, int8_t **dest)

HOST DEVICE bool	isSpecified (int64_t index) const

HOST DEVICE Status	setNull (int64_t index)

HOST DEVICE Status	setNullNoValidation (int64_t index)

HOST DEVICE Status	isNull (int64_t index, bool &is_null) const

HOST DEVICE Status	getItemOld (int64_t index, int64_t &size, int8_t *&dest, bool &is_null)

HOST DEVICE Status	getItemOld (int64_t index, size_t &size, int8_t *&dest, bool &is_null)

Static Public Member Functions
static size_t	get_size (ValueType type)

HOST static DEVICE bool	isFlatBuffer (const void *buffer)

static int64_t	getBufferSize (const void *buffer)

static int64_t	compute_flatbuffer_size (FlatBufferFormat format_id, const int8_t *format_metadata_ptr)

static int64_t	computeBufferSizeNestedArray (int64_t ndims, int64_t total_items_count, int64_t total_sizes_count, int64_t total_values_count, ValueType value_type, size_t user_data_size)

Public Attributes
int8_t *	buffer

Detailed Description

Definition at line 334 of file FlatBuffer.h.

Member Typedef Documentation

typedef int64_t FlatBufferManager::offsets_t

Definition at line 392 of file FlatBuffer.h.

typedef int32_t FlatBufferManager::sizes_t

Definition at line 391 of file FlatBuffer.h.

Member Enumeration Documentation

enum FlatBufferManager::Status

Enumerator
Success
IndexError
SubIndexError
SizeError
FlatbufferSizeError
ItemAlreadySpecifiedError
ItemUnspecifiedError
UnexpectedNullItemError
ValuesBufferTooSmallError
SizesBufferTooSmallError
CompressedIndices2BufferTooSmallError
MemoryError
NotImplementedError
NotSupportedFormatError
InvalidUserDataError
DimensionalityError
TypeError
UserDataError
InconsistentSizesError
UnknownFormatError

Definition at line 495 of file FlatBuffer.h.

               {
     Success = 0,
     IndexError,
     SubIndexError,
     SizeError,
     FlatbufferSizeError,
     ItemAlreadySpecifiedError,
     ItemUnspecifiedError,
     UnexpectedNullItemError,
     ValuesBufferTooSmallError,
     SizesBufferTooSmallError,
     CompressedIndices2BufferTooSmallError,
     MemoryError,
     NotImplementedError,
     NotSupportedFormatError,
     InvalidUserDataError,
     DimensionalityError,
     TypeError,
     UserDataError,
     InconsistentSizesError,
     UnknownFormatError
   };

enum FlatBufferManager::ValueType

Enumerator
Bool8
Int8
Int16
Int32
Int64
UInt8
UInt16
UInt32
UInt64
Float32
Float64
PointInt32
PointFloat64

Definition at line 335 of file FlatBuffer.h.

                  {
     Bool8,
     Int8,
     Int16,
     Int32,
     Int64,
     UInt8,
     UInt16,
     UInt32,
     UInt64,
     Float32,
     Float64,
     PointInt32,
     PointFloat64
   };

Member Function Documentation

static int64_t FlatBufferManager::compute_flatbuffer_size	(	FlatBufferFormat	format_id,
		const int8_t *	format_metadata_ptr
	)

inlinestatic

Definition at line 639 of file FlatBuffer.h.

References _align_to_int64(), FLATBUFFER_UNREACHABLE, and GeoPointFormatId.

Referenced by getFlatBufferSize(), and initialize().

                                                                             {
     int64_t flatbuffer_size = _align_to_int64(sizeof(FlatBufferManager::BaseWorker));
     switch (format_id) {
       case GeoPointFormatId: {
         const auto format_metadata =
             reinterpret_cast<const GeoPoint*>(format_metadata_ptr);
         flatbuffer_size += _align_to_int64(sizeof(GeoPoint));
         flatbuffer_size += _align_to_int64(sizeof(GeoPointWorker));
         const auto itemsize =
             2 * (format_metadata->is_geoint ? sizeof(int32_t) : sizeof(double));
         flatbuffer_size += _align_to_int64(
             itemsize * format_metadata->total_items_count);  // values buffer size
         break;
       }
       default:
         FLATBUFFER_UNREACHABLE();
     }
     flatbuffer_size += _align_to_int64(sizeof(int64_t));  // footer format id
     return flatbuffer_size;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static int64_t FlatBufferManager::computeBufferSizeNestedArray	(	int64_t	ndims,
		int64_t	total_items_count,
		int64_t	total_sizes_count,
		int64_t	total_values_count,
		ValueType	value_type,
		size_t	user_data_size
	)

inlinestatic

Definition at line 718 of file FlatBuffer.h.

References _align_to_int64(), and get_size().

Referenced by getFlatBufferSize(), and initializeNestedArray().

                                                                      {
     size_t value_size = get_size(value_type);
     offsets_t flatbuffer_size = _align_to_int64(sizeof(FlatBufferManager::BaseWorker));
     flatbuffer_size += _align_to_int64(sizeof(NestedArray));
     flatbuffer_size += _align_to_int64(sizeof(NestedArrayWorker));
     flatbuffer_size +=
         _align_to_int64(value_size * (total_values_count + 1));  // values buffer
     flatbuffer_size +=
         _align_to_int64(sizeof(sizes_t) * total_sizes_count);  // sizes buffer
     flatbuffer_size +=
         _align_to_int64(sizeof(offsets_t) * (total_items_count + 1));  // values offsets
     flatbuffer_size += _align_to_int64(sizeof(offsets_t) *
                                        (total_items_count * ndims + 1));  // sizes offsets
     flatbuffer_size += _align_to_int64(
         sizeof(sizes_t) * total_items_count);  // storage indices, must use signed type
     flatbuffer_size += _align_to_int64(user_data_size);   // user data
     flatbuffer_size += _align_to_int64(sizeof(int64_t));  // format id
     return flatbuffer_size;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

template<size_t NDIM = 0, bool check_sizes = true>

HOST DEVICE Status FlatBufferManager::concatItem	(	const int64_t	index,
		const int8_t *	values_buf,
		const int32_t	nof_values
	)

inline

Definition at line 1655 of file FlatBuffer.h.

                                               {
     const int32_t* const sizes_buffers[1] = {nullptr};
     int32_t sizes_lengths[1] = {0};
     return concatItemWorker<1, check_sizes>(index,
                                          values_buf,
                                          nof_values,
                                          sizes_buffers,
                                          sizes_lengths,
                                          0);
   }

template<size_t NDIM = 1, bool check_sizes = true>

HOST DEVICE Status FlatBufferManager::concatItem	(	const int64_t	index,
		const NestedArrayItem< NDIM > &	item
	)

inline

Definition at line 1669 of file FlatBuffer.h.

References FlatBufferManager::NestedArrayItem< NDIM >::is_null, FlatBufferManager::NestedArrayItem< NDIM >::nof_sizes, FlatBufferManager::NestedArrayItem< NDIM >::nof_values, FlatBufferManager::NestedArrayItem< NDIM >::sizes_buffers, FlatBufferManager::NestedArrayItem< NDIM >::sizes_lengths, Success, and FlatBufferManager::NestedArrayItem< NDIM >::values.

                                                                    {
     if (item.is_null) {
       return Success;
     }
     return concatItemWorker<NDIM, check_sizes>(index,
                                                item.values,
                                                item.nof_values,
                                                item.sizes_buffers,
                                                item.sizes_lengths,
                                                item.nof_sizes);
   }

template<size_t NDIM, bool check_sizes = true>

HOST DEVICE Status FlatBufferManager::concatItemWorker	(	const int64_t	index,
		const int8_t *	values,
		const int32_t	nof_values,
		const int32_t *const	sizes_buffers[NDIM],
		const int32_t	sizes_lengths[NDIM],
		const int32_t	nof_sizes
	)

inline

Definition at line 1498 of file FlatBuffer.h.

References DimensionalityError, FLATBUFFER_UNREACHABLE, format(), get_storage_indices(), getNDims(), getValueSize(), InconsistentSizesError, IndexError, itemsCount(), MemoryError, NestedArrayFormatId, NotImplementedError, NotSupportedFormatError, RETURN_ERROR, SizesBufferTooSmallError, Success, and ValuesBufferTooSmallError.

                                           {
     if (format() != NestedArrayFormatId) {
       RETURN_ERROR(NotSupportedFormatError);
     }
     if (index < 0 || index >= itemsCount()) {
       RETURN_ERROR(IndexError);
     }
     const int32_t ndims = getNDims();
     if (nof_sizes + 1 != ndims) {
       RETURN_ERROR(DimensionalityError);
     }
     auto* storage_indices = get_storage_indices();
     auto storage_index = storage_indices[index];
     if (storage_index == -1) {  // unspecified, so setting the item
       return setItemWorker<NDIM, check_sizes>(index,
                                               values,
                                               nof_values,
                                               sizes_buffers,
                                               sizes_lengths,
                                               nof_sizes);
     }
     auto* worker = getNestedArrayWorker();
     if (storage_index != worker->specified_items_count - 1) {
       // index does not correspond to the last item, only the last
       // item can be concatenated atm.
       // TODO: to support intermediate item concatenation, we'll need
       // to move the content of sizes and values buffers of the
       // following items to make extra room for the to-be concatenated
       // item buffers.
       RETURN_ERROR(NotImplementedError);
     }
     auto* values_offsets = get_values_offsets();
     auto values_offset = values_offsets[storage_index];
     if (values_offset < 0) {
       // TODO: support concat to null
       RETURN_ERROR(NotImplementedError);
     }
     auto* values_buffer = get_values_buffer();
     auto* sizes_offsets = get_sizes_offsets();
     auto* sizes_buffer = get_sizes_buffer();
     const auto sizes_offset = sizes_offsets[storage_index * ndims];
     const auto* metadata = getNestedArrayMetadata();
     const auto valuesize = getValueSize();
     values_offset += sizes_buffer[sizes_offset];
     if (values_offset + nof_values > metadata->total_values_count) {
       RETURN_ERROR(ValuesBufferTooSmallError);
     }
     switch (ndims) {
     case 1:
       sizes_buffer[sizes_offset] += nof_values;
       break;
     case 2: {
       const auto sizes2_offset = sizes_offset + 1;
       if (sizes2_offset + sizes_buffer[sizes_offset] + sizes_lengths[0] > metadata->total_sizes_count) {
         RETURN_ERROR(SizesBufferTooSmallError);
       }
       if constexpr (check_sizes) {
         // check consistency of sizes and nof_values
         int32_t sum_of_sizes = 0;
         for (int32_t i=0; i < sizes_lengths[0]; i++) {
           sum_of_sizes += sizes_buffers[0][i];
         }
         if (nof_values != sum_of_sizes) {
           RETURN_ERROR(InconsistentSizesError);
         }
       }
       if (memcpy(sizes_buffer + sizes2_offset + sizes_buffer[sizes_offset],
                  sizes_buffers[0],
                  sizes_lengths[0] * sizeof(sizes_t)) == nullptr) {
         RETURN_ERROR(MemoryError);
       }
       sizes_buffer[sizes_offset] += sizes_lengths[0];
       sizes_offsets[storage_index * ndims + 2] += sizes_lengths[0];
     }
       break;
     case 3: // TODO: concat multipolygons
       RETURN_ERROR(NotImplementedError);
     default:
       FLATBUFFER_UNREACHABLE();
       break;
     }
     if (nof_values > 0 && values != nullptr &&
         memcpy(values_buffer + values_offset * valuesize, values, nof_values * valuesize) == nullptr) {
       RETURN_ERROR(MemoryError);
     }
     values_offsets[storage_index + 1] += nof_values;
     return Success;
   }

Here is the call graph for this function:

HOST DEVICE bool FlatBufferManager::containsNullValue ( const int8_t * value_ptr ) const

inline

Definition at line 994 of file FlatBuffer.h.

References getNullValuePtr(), and getValueSize().

Referenced by getItemWorker().

                                                                            {
     const int8_t* null_value_ptr = getNullValuePtr();
     if (null_value_ptr != nullptr) {
       switch (getValueSize()) {
         case 1:
           return *null_value_ptr == *value_ptr;
         case 2:
           return *reinterpret_cast<const int16_t*>(null_value_ptr) ==
                  *reinterpret_cast<const int16_t*>(value_ptr);
         case 4:
           return *reinterpret_cast<const int32_t*>(null_value_ptr) ==
                  *reinterpret_cast<const int32_t*>(value_ptr);
         case 8:
           return *reinterpret_cast<const int64_t*>(null_value_ptr) ==
                  *reinterpret_cast<const int64_t*>(value_ptr);
         case 16:
           return (*reinterpret_cast<const int64_t*>(null_value_ptr) ==
                       *reinterpret_cast<const int64_t*>(value_ptr) &&
                   *(reinterpret_cast<const int64_t*>(null_value_ptr) + 1) ==
                       *(reinterpret_cast<const int64_t*>(value_ptr) + 1));
         default:
           break;
       }
     }
     return false;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST DEVICE int64_t FlatBufferManager::dtypeSize ( ) const

inline

Definition at line 628 of file FlatBuffer.h.

References format(), and GeoPointFormatId.

Referenced by getItemOld(), isNull(), setItemNoValidation(), setItemOld(), setNullNoValidation(), and writeBackCellGeoPoint().

                                                {  // TODO: use valueByteSize instead
     switch (format()) {
       case GeoPointFormatId:
         return 2 * (getGeoPointMetadata()->is_geoint ? sizeof(int32_t) : sizeof(double));
       default:
         break;
     }
     return -1;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

FlatBufferManager::FLATBUFFER_GET_BUFFER_METHODS	(	user_data_buffer	,
		int8_t
	)

FlatBufferManager::FLATBUFFER_GET_BUFFER_METHODS	(	values_buffer	,
		int8_t
	)

FlatBufferManager::FLATBUFFER_GET_BUFFER_METHODS	(	sizes_buffer	,
		sizes_t
	)

FlatBufferManager::FLATBUFFER_GET_BUFFER_METHODS	(	values_offsets	,
		offsets_t
	)

FlatBufferManager::FLATBUFFER_GET_BUFFER_METHODS	(	sizes_offsets	,
		offsets_t
	)

FlatBufferManager::FLATBUFFER_MANAGER_FORMAT_TOOLS ( GeoPoint )

FlatBufferManager::FLATBUFFER_MANAGER_FORMAT_TOOLS ( NestedArray )

HOST DEVICE FlatBufferFormat FlatBufferManager::format ( ) const

inline

Definition at line 598 of file FlatBuffer.h.

References buffer, and FlatBufferManager::BaseWorker::format_id.

Referenced by concatItemWorker(), dtypeSize(), get_max_nof_values(), get_storage_count(), get_storage_indices(), get_values(), get_values_buffer_size(), getItemOld(), isNestedArray(), isNull(), itemsCount(), setItemNoValidation(), setItemOld(), setItemWorker(), setNull(), setNullNoValidation(), and valueByteSize().

                                                      {
     const auto* base = reinterpret_cast<const BaseWorker*>(buffer);
     return base->format_id;
   }

Here is the caller graph for this function:

int64_t FlatBufferManager::get_max_nof_values ( ) const

inline

Definition at line 876 of file FlatBuffer.h.

References format(), and GeoPointFormatId.

                                             {
     switch (format()) {
       case GeoPointFormatId:
         return getGeoPointMetadata()->total_items_count;
       default:
         break;
     }
     return -1;
   }

Here is the call graph for this function:

static size_t FlatBufferManager::get_size ( ValueType type )

inlinestatic

Definition at line 355 of file FlatBuffer.h.

References Bool8, FLATBUFFER_UNREACHABLE, Float32, Float64, Int16, Int32, Int64, Int8, PointFloat64, PointInt32, UInt16, UInt32, UInt64, and UInt8.

Referenced by computeBufferSizeNestedArray(), and initializeNestedArray().

                                          {
     switch (type) {
       case Bool8:
       case Int8:
       case UInt8:
         return 1;
       case Int16:
       case UInt16:
         return 2;
       case Int32:
       case UInt32:
       case Float32:
         return 4;
       case Int64:
       case UInt64:
       case Float64:
       case PointInt32:
         return 8;
       case PointFloat64:
         return 16;
     }
     FLATBUFFER_UNREACHABLE();
     return 0;
   }

Here is the caller graph for this function:

HOST DEVICE int64_t& FlatBufferManager::get_storage_count ( )

inline

Definition at line 888 of file FlatBuffer.h.

References format(), and GeoPointFormatId.

                                                   {
     switch (format()) {
       case GeoPointFormatId:
         return getGeoPointMetadata()->total_items_count;
       default:
         break;
     }
     static int64_t dummy_storage_count = -1;
     return dummy_storage_count;
   }

Here is the call graph for this function:

const int64_t& FlatBufferManager::get_storage_count ( ) const

inline

Definition at line 900 of file FlatBuffer.h.

References format(), and GeoPointFormatId.

                                                   {
     switch (format()) {
       case GeoPointFormatId:
         return getGeoPointMetadata()->total_items_count;
       default:
         break;
     }
     static int64_t dummy = -1;
     return dummy;
   }

Here is the call graph for this function:

HOST DEVICE sizes_t FlatBufferManager::get_storage_index ( const int64_t index ) const

inline

Definition at line 1045 of file FlatBuffer.h.

References get_storage_indices().

Referenced by getItemWorker(), getLength(), and isNull().

                                                                           {
     return get_storage_indices()[index];
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST DEVICE sizes_t* FlatBufferManager::get_storage_indices ( )

inline

Definition at line 1021 of file FlatBuffer.h.

References buffer, format(), and NestedArrayFormatId.

Referenced by concatItemWorker(), get_storage_index(), initializeNestedArray(), isSpecified(), setItemWorker(), and setNull().

                                                     {
     offsets_t offset = 0;
     switch (format()) {
       case NestedArrayFormatId:
         offset = getNestedArrayWorker()->storage_indices_offset;
         break;
       default:
         return nullptr;
     }
     return reinterpret_cast<sizes_t*>(buffer + offset);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST DEVICE const sizes_t* FlatBufferManager::get_storage_indices ( ) const

inline

Definition at line 1033 of file FlatBuffer.h.

References buffer, format(), and NestedArrayFormatId.

                                                                 {
     offsets_t offset = 0;
     switch (format()) {
       case NestedArrayFormatId:
         offset = getNestedArrayWorker()->storage_indices_offset;
         break;
       default:
         return nullptr;
     }
     return reinterpret_cast<sizes_t*>(buffer + offset);
   }

Here is the call graph for this function:

HOST DEVICE int8_t* FlatBufferManager::get_values ( )

inline

Definition at line 930 of file FlatBuffer.h.

References buffer, format(), and GeoPointFormatId.

Referenced by getItemOld(), isNull(), setItemNoValidation(), and setNullNoValidation().

                                           {
     int64_t offset = 0;
     switch (format()) {
       case GeoPointFormatId:
         offset = getGeoPointWorker()->values_offset;
         break;
       default:
         return nullptr;
     }
     return buffer + offset;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST DEVICE const int8_t* FlatBufferManager::get_values ( ) const

inline

Definition at line 943 of file FlatBuffer.h.

References buffer, format(), and GeoPointFormatId.

                                                       {
     int64_t offset = 0;
     switch (format()) {
       case GeoPointFormatId:
         offset = getGeoPointWorker()->values_offset;
         break;
       default:
         return nullptr;
     }
     return buffer + offset;
   }

Here is the call graph for this function:

int64_t FlatBufferManager::get_values_buffer_size ( ) const

inline

Definition at line 913 of file FlatBuffer.h.

References _align_to_int64(), format(), and GeoPointFormatId.

                                                 {
     switch (format()) {
       case GeoPointFormatId: {
         const auto* metadata = getGeoPointMetadata();
         const auto itemsize =
             2 * (metadata->is_geoint ? sizeof(int32_t) : sizeof(double));
         return _align_to_int64(itemsize * metadata->total_items_count);
       }
       default:
         break;
     }
     static int64_t dummy = -1;
     return dummy;
   }

Here is the call graph for this function:

HOST DEVICE BaseWorker* FlatBufferManager::getBaseWorker ( )

inline

Definition at line 661 of file FlatBuffer.h.

References buffer.

Referenced by initialize(), and initializeNestedArray().

                                                  {
     return reinterpret_cast<FlatBufferManager::BaseWorker*>(buffer);
   }

Here is the caller graph for this function:

HOST DEVICE const BaseWorker* FlatBufferManager::getBaseWorker ( ) const

inline

Definition at line 664 of file FlatBuffer.h.

References buffer.

                                                              {
     return reinterpret_cast<const BaseWorker*>(buffer);
   }

static int64_t FlatBufferManager::getBufferSize ( const void * buffer )

inlinestatic

Definition at line 553 of file FlatBuffer.h.

References buffer, and isFlatBuffer().

Referenced by TableFunctionExecutionContext::launchCpuCode(), and synthesize_metadata_table_function().

                                                    {
     if (isFlatBuffer(buffer)) {
       return reinterpret_cast<const BaseWorker*>(buffer)->flatbuffer_size;
     } else {
       return -1;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t FlatBufferManager::getBufferSize ( ) const

inline

Definition at line 563 of file FlatBuffer.h.

References buffer.

Referenced by ColumnFetcher::transferColumnIfNeeded().

                                        {
     return reinterpret_cast<const BaseWorker*>(buffer)->flatbuffer_size;
   }

Here is the caller graph for this function:

template<size_t NDIM>

HOST DEVICE Status FlatBufferManager::getItem	(	const int64_t	index,
		NestedArrayItem< NDIM > &	result
	)

inline

Definition at line 1349 of file FlatBuffer.h.

References run_benchmark_import::result.

Referenced by getItem(), and writeBackCellArrayScalar().

                                                                                  {
     const int64_t index_[NDIM] = {index};
     return getItem<NDIM>(index_, 1, result);
   }

Here is the caller graph for this function:

template<size_t NDIM>

HOST DEVICE Status FlatBufferManager::getItem	(	const int64_t	index[NDIM],
		const size_t	n,
		NestedArrayItem< NDIM > &	result
	)

inline

Definition at line 1355 of file FlatBuffer.h.

References FlatBufferManager::NestedArrayItem< NDIM >::is_null, anonymous_namespace{Utm.h}::n, FlatBufferManager::NestedArrayItem< NDIM >::nof_sizes, FlatBufferManager::NestedArrayItem< NDIM >::nof_values, FlatBufferManager::NestedArrayItem< NDIM >::sizes_buffers, FlatBufferManager::NestedArrayItem< NDIM >::sizes_lengths, and FlatBufferManager::NestedArrayItem< NDIM >::values.

                                                                                                        {
     return getItemWorker<NDIM>(index, n,
                          result.values,
                          result.nof_values,
                          result.sizes_buffers,
                          result.sizes_lengths,
                          result.nof_sizes,
                          result.is_null);
   }

Status FlatBufferManager::getItem	(	const int64_t	index,
		std::string &	s,
		bool &	is_null
	)

inline

Definition at line 1682 of file FlatBuffer.h.

References getItem(), InconsistentSizesError, Int8, FlatBufferManager::NestedArrayItem< NDIM >::is_null, FlatBufferManager::NestedArrayItem< NDIM >::nof_sizes, FlatBufferManager::NestedArrayItem< NDIM >::nof_values, RETURN_ERROR, Success, TypeError, and FlatBufferManager::NestedArrayItem< NDIM >::values.

                                                                    {
     is_null = true;
     const auto* metadata = getNestedArrayMetadata();
     if (metadata->value_type != Int8) {
       RETURN_ERROR(TypeError);
     }
     NestedArrayItem<1> item;
     Status status = getItem(index, item);
     if (status != Success) {
       return status;
     }
     if (item.nof_sizes != 0) {
       RETURN_ERROR(InconsistentSizesError);
     }
     if (!item.is_null) {
       s.assign(reinterpret_cast<const char*>(item.values), static_cast<size_t>(item.nof_values));
       is_null = false;
     }
     return status;
   }

Here is the call graph for this function:

template<typename CT >

Status FlatBufferManager::getItem	(	const int64_t	index,
		std::vector< CT > &	values,
		std::vector< int32_t > &	sizes,
		bool &	is_null
	)

inline

Definition at line 1704 of file FlatBuffer.h.

References getItem(), getValueSize(), InconsistentSizesError, FlatBufferManager::NestedArrayItem< NDIM >::is_null, FlatBufferManager::NestedArrayItem< NDIM >::nof_sizes, FlatBufferManager::NestedArrayItem< NDIM >::nof_values, NotImplementedError, PointFloat64, PointInt32, RETURN_ERROR, FlatBufferManager::NestedArrayItem< NDIM >::sizes_buffers, FlatBufferManager::NestedArrayItem< NDIM >::sizes_lengths, Success, TypeError, and FlatBufferManager::NestedArrayItem< NDIM >::values.

                                 {
     if constexpr (!std::is_same<CT, uint8_t>::value) {
       if constexpr (std::is_same<CT, double>::value) {
         const auto* metadata = getNestedArrayMetadata();
         if (metadata->value_type != PointFloat64) {
           RETURN_ERROR(TypeError);
         }
       } else if constexpr (std::is_same<CT, int32_t>::value) {
         const auto* metadata = getNestedArrayMetadata();
         if (metadata->value_type != PointInt32) {
           RETURN_ERROR(TypeError);
         }
       } else {
         RETURN_ERROR(NotImplementedError);
       }
     }
     NestedArrayItem<2> item;
     Status status = getItem(index, item);
     if (status != Success) {
       return status;
     }
     if (item.is_null) {
       return Success;
     }
     if (item.nof_sizes != 1) {
       RETURN_ERROR(InconsistentSizesError);
     }
     const auto valuesize = getValueSize();
     const auto values_count = item.nof_values * valuesize / sizeof(CT);
     values.reserve(values_count);
     values.insert(values.end(),
                   reinterpret_cast<CT*>(item.values),
                   reinterpret_cast<CT*>(item.values) + values_count);
 
     sizes.reserve(item.sizes_lengths[0]);
     sizes.insert(sizes.end(),
                  reinterpret_cast<sizes_t*>(item.sizes_buffers[0]),
                  reinterpret_cast<sizes_t*>(item.sizes_buffers[0] + item.sizes_lengths[0] * sizeof(int32_t)));
   return Success;
   }

Here is the call graph for this function:

template<typename CT >

Status FlatBufferManager::getItem	(	const int64_t	index,
		std::vector< CT > &	values,
		std::vector< int32_t > &	sizes,
		std::vector< int32_t > &	sizes_of_sizes,
		bool &	is_null
	)

inline

Definition at line 1749 of file FlatBuffer.h.

References getItem(), getValueSize(), InconsistentSizesError, FlatBufferManager::NestedArrayItem< NDIM >::is_null, FlatBufferManager::NestedArrayItem< NDIM >::nof_sizes, FlatBufferManager::NestedArrayItem< NDIM >::nof_values, NotImplementedError, PointFloat64, PointInt32, RETURN_ERROR, FlatBufferManager::NestedArrayItem< NDIM >::sizes_buffers, FlatBufferManager::NestedArrayItem< NDIM >::sizes_lengths, Success, TypeError, and FlatBufferManager::NestedArrayItem< NDIM >::values.

                                 {
     if constexpr (!std::is_same<CT, uint8_t>::value) {
       if constexpr (std::is_same<CT, double>::value) {
         const auto* metadata = getNestedArrayMetadata();
         if (metadata->value_type != PointFloat64) {
           RETURN_ERROR(TypeError);
         }
       } else if constexpr (std::is_same<CT, int32_t>::value) {
         const auto* metadata = getNestedArrayMetadata();
         if (metadata->value_type != PointInt32) {
           RETURN_ERROR(TypeError);
         }
       } else {
         RETURN_ERROR(NotImplementedError);
       }
     }
     NestedArrayItem<3> item;
     Status status = getItem(index, item);
     if (status != Success) {
       return status;
     }
     if (item.is_null) {
       return Success;
     }
     if (item.nof_sizes != 2) {
       RETURN_ERROR(InconsistentSizesError);
     }
     const auto valuesize = getValueSize();
     const auto values_count = item.nof_values * valuesize / sizeof(CT);
     values.reserve(values_count);
     values.insert(values.end(),
                   reinterpret_cast<CT*>(item.values),
                   reinterpret_cast<CT*>(item.values) + values_count);
 
     sizes.reserve(item.sizes_lengths[1]);
     sizes.insert(sizes.end(),
                  reinterpret_cast<sizes_t*>(item.sizes_buffers[1]),
                  reinterpret_cast<sizes_t*>(item.sizes_buffers[1] + item.sizes_lengths[1] * sizeof(int32_t)));
 
     sizes_of_sizes.reserve(item.sizes_lengths[0]);
     sizes_of_sizes.insert(sizes_of_sizes.end(),
                           reinterpret_cast<sizes_t*>(item.sizes_buffers[0]),
                           reinterpret_cast<sizes_t*>(item.sizes_buffers[0] + item.sizes_lengths[0] * sizeof(int32_t)));
   return Success;
 
   }

Here is the call graph for this function:

HOST DEVICE Status FlatBufferManager::getItemOld	(	int64_t	index,
		int64_t &	size,
		int8_t *&	dest,
		bool &	is_null
	)

inline

Definition at line 2140 of file FlatBuffer.h.

References dtypeSize(), format(), GeoPointFormatId, get_values(), IndexError, itemsCount(), RETURN_ERROR, Success, and UnknownFormatError.

Referenced by getItemOld().

                                                                                             {
     if (index < 0 || index >= itemsCount()) {
       RETURN_ERROR(IndexError);
     }
     switch (format()) {
       case GeoPointFormatId: {
         int8_t* values = get_values();
         int64_t itemsize = dtypeSize();
         size = itemsize;
         dest = values + index * itemsize;
         is_null = false;
         return Success;
       }
       default:
         break;
     }
     RETURN_ERROR(UnknownFormatError);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST DEVICE Status FlatBufferManager::getItemOld	(	int64_t	index,
		size_t &	size,
		int8_t *&	dest,
		bool &	is_null
	)

inline

Definition at line 2160 of file FlatBuffer.h.

References getItemOld().

                                                                                            {
     int64_t sz{0};
     Status status = getItemOld(index, sz, dest, is_null);
     size = sz;
     return status;
   }

Here is the call graph for this function:

template<size_t NDIM>

HOST DEVICE Status FlatBufferManager::getItemWorker	(	const int64_t	index[NDIM],
		const size_t	n,
		int8_t *&	values,
		int32_t &	nof_values,
		int32_t *	sizes_buffers[NDIM],
		int32_t	sizes_lengths[NDIM],
		int32_t &	nof_sizes,
		bool &	is_null
	)

inline

Definition at line 1141 of file FlatBuffer.h.

References containsNullValue(), DimensionalityError, FLATBUFFER_UNREACHABLE, get_storage_index(), getNDims(), getValueSize(), IndexError, isNestedArray(), itemsCount(), ItemUnspecifiedError, anonymous_namespace{Utm.h}::n, NotImplementedError, NotSupportedFormatError, RETURN_ERROR, SubIndexError, and Success.

                                                   {
     values = nullptr;
     nof_values = 0;
     nof_sizes = 0;
     std::memset(sizes_buffers, 0, NDIM * sizeof(int32_t*));
     std::memset(sizes_lengths, 0, NDIM * sizeof(int32_t));
     is_null = true;
 
     if (!isNestedArray()) {
       RETURN_ERROR(NotSupportedFormatError);
     }
 
     const size_t ndims = getNDims();
     if (n <= 0 || n > ndims + 1) {
       RETURN_ERROR(DimensionalityError);
     }
     // clang-format off
     /*
       multipolygon (ndims == 3):
 
         n == 0 means return a column of multipolygons: flatbuffer, getLenght returns
           itemsCount()
 
         n == 1 means return a multipolygon: values, sizes(=sizes_buffers[1]),
           sizes_of_sizes(=sizes_buffers[0]), getLength returns
           len(sizes_of_sizes)(=sizes_lengths[0])
 
         n == 2 means return a polygon: values, sizes, getLength
           returns len(sizes)
 
         n == 3 means return a linestring: values, getLength returns
           len(values)
 
         n == 4 means return a point: value, getLength returns 0 [NOTIMPL]
 
       polygon/multilinestring (ndims == 2):
 
         n == 0 means return a column of polygons/multilinestring:
           flatbuffer, getLenght returns itemsCount()
 
         n == 1 means return a polygon/multilinestring: values, sizes,
           getLength returns len(sizes)
 
         n == 2 means return a linestring: values, getLength
           returns len(values)
 
         n == 3 means return a point: value, getLength returns 0 [NOTIMPL]
 
       linestring/multipoint/array of scalars/textencodingnone (ndims == 1):
 
         n == 0 means return a column of linestring/multipoint:
           flatbuffer, getLenght returns itemsCount()
 
         n == 1 means return a linestring: values, getLength returns
           len(values)
 
         n == 2 means return a point: value, getLength returns 0 [NOTIMPL]
     */
     // clang-format off
     if (index[0] < 0 || index[0] >= itemsCount()) {
       // Callers may interpret the IndexError as a NULL value return
       return IndexError;
     }
     const auto storage_index = get_storage_index(index[0]);
     if (storage_index < 0) {
       return ItemUnspecifiedError;
     }
     const auto* values_offsets = get_values_offsets();
     const auto values_offset = values_offsets[storage_index];
     if (values_offset < 0) {
       return Success;
     }
     is_null = false;
     const auto* sizes_offsets = get_sizes_offsets();
     auto* sizes_buffer = get_sizes_buffer();
     auto* values_buffer = get_values_buffer();
     const auto valuesize = getValueSize();
     const auto next_values_offset = values_offsets[storage_index + 1];
 
     const auto sizes_offset = sizes_offsets[storage_index * ndims];
     nof_sizes = ndims - n;
     switch (n) {
       case 1: {
         if (next_values_offset < 0) {
           nof_values = -(next_values_offset + 1) - values_offset;
         } else {
           nof_values = next_values_offset - values_offset;
         }
         values = values_buffer + values_offset * valuesize;
         switch (ndims) {
           case 3: {
             const auto sizes2_offset = sizes_offsets[storage_index * ndims + 1];
             const auto sizes3_offset = sizes_offsets[storage_index * ndims + 2];
             sizes_buffers[0] = sizes_buffer + sizes2_offset;
             sizes_buffers[1] = sizes_buffer + sizes3_offset;
             sizes_lengths[0] = sizes_buffer[sizes_offset];
             sizes_lengths[1] = sizes_offsets[storage_index * ndims + 3] - sizes3_offset;
             break;
           }
           case 2: {
             const auto sizes2_offset = sizes_offsets[storage_index * ndims + 1];
             sizes_buffers[0] = sizes_buffer + sizes2_offset;
             sizes_lengths[0] = sizes_buffer[sizes_offset];
             break;
           }
           case 1:
             break;
           default:
             FLATBUFFER_UNREACHABLE();
             break;
         }
         break;
       }
       case 2: {
         const auto sizes2_offset = sizes_offsets[storage_index * ndims + 1];
         if (index[1] < 0 || index[1] >= sizes_buffer[sizes_offset]) {
           RETURN_ERROR(SubIndexError);
         }
         offsets_t soffset = 0;
         for (int64_t i = 0; i < index[1]; i++) {
           soffset += sizes_buffer[sizes2_offset + i];
         }
         values = values_buffer + (values_offset + soffset) * valuesize;
         switch (ndims) {
           case 3: {
             const auto sizes3_offset = sizes_offsets[storage_index * ndims + 2];
             const sizes_t nsizes = sizes_buffer[sizes2_offset + index[1]];
             auto sizes_buf = sizes_buffer + sizes3_offset + soffset;
             sizes_buffers[0] = sizes_buf;
             sizes_lengths[0] = nsizes;
             nof_values = 0;
             for (int64_t i = 0; i < nsizes; i++) {
               nof_values += sizes_buf[i];
             }
             break;
           }
           case 2: {
             nof_values = sizes_buffer[sizes2_offset + index[1]];
             break;
           }
           case 1: {
             nof_values = 1;
             is_null = containsNullValue(values);
             break;
           }
           default:
             FLATBUFFER_UNREACHABLE();
             break;
         }
         break;
       }
       case 3: {
         if (ndims != 3) {
           RETURN_ERROR(NotImplementedError);
         }
         const auto sizes2_offset = sizes_offsets[storage_index * ndims + 1];
         const auto sizes3_offset = sizes_offsets[storage_index * ndims + 2];
         if (index[1] < 0 || index[1] >= sizes_buffer[sizes_offset]) {
           RETURN_ERROR(SubIndexError);
         }
         if (index[2] < 0 || index[2] >= sizes_buffer[sizes2_offset + index[1]]) {
           RETURN_ERROR(SubIndexError);
         }
 
         int64_t i3 = 0;
         int64_t soffset = 0;
         int64_t voffset = 0;
         for (int64_t i = 0; i < index[1]; i++) {
           auto size2 = sizes_buffer[sizes2_offset + i];
           soffset += size2;
           for (int64_t j = 0; j < size2; j++) {
             voffset += sizes_buffer[sizes3_offset + i3];
             i3++;
           }
         }
         for (int64_t j = 0; j < index[2]; j++) {
           voffset += sizes_buffer[sizes3_offset + i3];
           i3++;
         }
         values = values_buffer + (values_offset + voffset) * valuesize;
         nof_values = sizes_buffer[sizes3_offset + soffset + index[2]];
         break;
       }
       default:
         RETURN_ERROR(NotImplementedError);
         break;
     }
     return Success;
   }

Here is the call graph for this function:

template<size_t NDIM = 1>

HOST DEVICE Status FlatBufferManager::getLength	(	const int64_t	index,
		size_t &	length
	)

inline

Definition at line 1066 of file FlatBuffer.h.

                                                                     {
     const int64_t index_[NDIM] = {index};
     return getLength<NDIM>(index_, 1, length);
   }

template<size_t NDIM>

HOST DEVICE Status FlatBufferManager::getLength	(	const int64_t	index[NDIM],
		const size_t	n,
		size_t &	length
	)		const

inline

Definition at line 1074 of file FlatBuffer.h.

References DimensionalityError, get_storage_index(), getNDims(), IndexError, isNestedArray(), itemsCount(), ItemUnspecifiedError, NotImplementedError, NotSupportedFormatError, RETURN_ERROR, SubIndexError, and Success.

                                                      {
     if (!isNestedArray()) {
       RETURN_ERROR(NotSupportedFormatError);
     }
     const size_t ndims = getNDims();
     if (n == 0) {
       length = itemsCount();
       return Success;
     }
     if (n > ndims + 1) {
       RETURN_ERROR(DimensionalityError);
     }
     if (index[0] < 0 || index[0] >= itemsCount()) {
       // Callers may interpret the IndexError as a NULL value return
       return IndexError;
     }
     const auto storage_index = get_storage_index(index[0]);
     if (storage_index < 0) {
       return ItemUnspecifiedError;
     }
     const auto* values_offsets = get_values_offsets();
     const auto values_offset = values_offsets[storage_index];
     if (values_offset < 0) {  // NULL item
       length = 0;
       return Success;
     }
     const auto* sizes_offsets = get_sizes_offsets();
     const auto* sizes_buffer = get_sizes_buffer();
     const auto sizes_offset = sizes_offsets[storage_index * ndims];
     switch (n) {
       case 1: {
         length = sizes_buffer[sizes_offset];
       } break;
       case 2: {
         const auto sizes2_offset = sizes_offsets[storage_index * ndims + 1];
         if (index[1] < 0 || index[1] >= sizes_buffer[sizes_offset]) {
           RETURN_ERROR(SubIndexError);
         }
         length = sizes_buffer[sizes2_offset + index[1]];
       } break;
       case 3: {
         const auto sizes2_offset = sizes_offsets[storage_index * ndims + 1];
         const auto sizes3_offset = sizes_offsets[storage_index * ndims + 2];
         if (index[1] < 0 || index[1] >= sizes_buffer[sizes_offset]) {
           RETURN_ERROR(SubIndexError);
         }
         if (index[2] < 0 || index[2] >= sizes_buffer[sizes2_offset + index[1]]) {
           RETURN_ERROR(SubIndexError);
         }
         offsets_t soffset = 0;
         for (int64_t i = 0; i < index[1]; i++) {
           soffset += sizes_buffer[sizes2_offset + i];
         }
         length = sizes_buffer[sizes3_offset + soffset + index[2]];
       } break;
       default:
         RETURN_ERROR(NotImplementedError);
         break;
     }
     return Success;
   }

Here is the call graph for this function:

HOST DEVICE size_t FlatBufferManager::getNDims ( ) const

inline

Definition at line 866 of file FlatBuffer.h.

References FLATBUFFER_UNREACHABLE, and isNestedArray().

Referenced by concatItemWorker(), getItemWorker(), getLength(), setItem(), setItemWorker(), and setNull().

                                              {
     if (isNestedArray()) {
       return getNestedArrayMetadata()->ndims;
     }
     FLATBUFFER_UNREACHABLE();
     return 0;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST DEVICE const int8_t* FlatBufferManager::getNullValuePtr ( ) const

inline

Definition at line 987 of file FlatBuffer.h.

References getValuesBufferSize(), and isNestedArray().

Referenced by containsNullValue().

                                                            {
     if (isNestedArray()) {
       return get_values_buffer() + getValuesBufferSize();
     }
     return nullptr;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST DEVICE const int8_t* FlatBufferManager::getValuesBuffer ( ) const

inline

Definition at line 581 of file FlatBuffer.h.

References buffer.

                                                            {
     const auto offset = getNestedArrayWorker()->values_buffer_offset;
     return reinterpret_cast<const int8_t*>(buffer + offset);
   }

HOST DEVICE size_t FlatBufferManager::getValuesBufferSize ( ) const

inline

Definition at line 575 of file FlatBuffer.h.

Referenced by getNullValuePtr().

                                                         {
     const auto* metadata = getNestedArrayMetadata();
     const auto* worker = getNestedArrayWorker();
     return worker->value_size * metadata->total_values_count;
   }

Here is the caller graph for this function:

size_t FlatBufferManager::getValuesCount ( ) const

inline

Definition at line 586 of file FlatBuffer.h.

                                        {
     const auto* worker = getNestedArrayWorker();
     const auto* values_offsets = get_values_offsets();
     const auto storage_index = worker->specified_items_count;
     const auto values_offset = values_offsets[storage_index];
     if (values_offset < 0) {
       return -(values_offset + 1);
     }
     return values_offset;
   }

HOST DEVICE size_t FlatBufferManager::getValueSize ( ) const

inline

Definition at line 571 of file FlatBuffer.h.

Referenced by concatItemWorker(), containsNullValue(), getItem(), getItemWorker(), setItem(), and setItemWorker().

                                                  {
     return getNestedArrayWorker()->value_size;
   }

Here is the caller graph for this function:

void FlatBufferManager::initialize	(	FlatBufferFormat	format_id,
		const int8_t *	format_metadata_ptr
	)

inline

Definition at line 833 of file FlatBuffer.h.

References _align_to_int64(), buffer, compute_flatbuffer_size(), FLATBUFFER_UNREACHABLE, GeoPointFormatId, getBaseWorker(), and NestedArrayFormatId.

Referenced by initializeFlatBuffer().

                                                                                  {
     auto* base = getBaseWorker();
     base->format_id = format_id;
     base->flatbuffer_size = compute_flatbuffer_size(format_id, format_metadata_ptr);
     base->format_metadata_offset = _align_to_int64(sizeof(FlatBufferManager::BaseWorker));
     switch (format_id) {
       case NestedArrayFormatId:
         FLATBUFFER_UNREACHABLE();
         break;
       case GeoPointFormatId: {
         base->format_worker_offset =
             base->format_metadata_offset + _align_to_int64(sizeof(GeoPoint));
 
         const auto* format_metadata =
             reinterpret_cast<const GeoPoint*>(format_metadata_ptr);
         auto* this_metadata = getGeoPointMetadata();
         this_metadata->total_items_count = format_metadata->total_items_count;
         this_metadata->input_srid = format_metadata->input_srid;
         this_metadata->output_srid = format_metadata->output_srid;
         this_metadata->is_geoint = format_metadata->is_geoint;
 
         auto* this_worker = getGeoPointWorker();
         this_worker->values_offset =
             base->format_worker_offset + _align_to_int64(sizeof(GeoPointWorker));
         break;
       }
     }
     ((int64_t*)buffer)[base->flatbuffer_size / sizeof(int64_t) - 1] =
         static_cast<int64_t>(format_id);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Status FlatBufferManager::initializeNestedArray	(	int64_t	ndims,
		int64_t	total_items_count,
		int64_t	total_sizes_count,
		int64_t	total_values_count,
		ValueType	value_type,
		const int8_t *	null_value_ptr,
		const int8_t *	user_data_ptr,
		size_t	user_data_size
	)

inline

Definition at line 743 of file FlatBuffer.h.

References _align_to_int64(), buffer, computeBufferSizeNestedArray(), FLATBUFFER_MANAGER_SET_OFFSET, FlatbufferSizeError, get_size(), get_storage_indices(), getBaseWorker(), isFlatBuffer(), MemoryError, NestedArrayFormatId, RETURN_ERROR, Success, and UnknownFormatError.

Referenced by initializeFlatBuffer().

                                                       {
     auto* base = getBaseWorker();
     base->format_id = NestedArrayFormatId;
     size_t value_size = get_size(value_type);
     base->flatbuffer_size = computeBufferSizeNestedArray(ndims,
                                                          total_items_count,
                                                          total_sizes_count,
                                                          total_values_count,
                                                          value_type,
                                                          user_data_size);
     offsets_t offset = 0;
     size_t previous_size = sizeof(FlatBufferManager::BaseWorker);
     FLATBUFFER_MANAGER_SET_OFFSET(base, format_metadata, sizeof(NestedArray));
     FLATBUFFER_MANAGER_SET_OFFSET(base, format_worker, sizeof(NestedArrayWorker));
 
     auto* metadata = getNestedArrayMetadata();
     metadata->ndims = ndims;
     metadata->total_items_count = total_items_count;
     metadata->total_sizes_count = total_sizes_count;
     metadata->total_values_count = total_values_count;
     metadata->value_type = value_type;
     metadata->user_data_size = user_data_size;
 
     auto* worker = getNestedArrayWorker();
     worker->specified_items_count = 0;
     worker->value_size = value_size;
 
     FLATBUFFER_MANAGER_SET_OFFSET(
         worker, values_buffer, value_size * (total_values_count + 1));
     FLATBUFFER_MANAGER_SET_OFFSET(
         worker, sizes_buffer, sizeof(sizes_t) * total_sizes_count);
     FLATBUFFER_MANAGER_SET_OFFSET(
         worker, values_offsets, sizeof(offsets_t) * (total_items_count + 1));
     FLATBUFFER_MANAGER_SET_OFFSET(
         worker, sizes_offsets, sizeof(offsets_t) * (total_items_count * ndims + 1));
     FLATBUFFER_MANAGER_SET_OFFSET(
         worker, storage_indices, sizeof(sizes_t) * total_items_count);
     FLATBUFFER_MANAGER_SET_OFFSET(worker, user_data_buffer, user_data_size);
 
     if (base->flatbuffer_size !=
         offset + _align_to_int64(previous_size) + _align_to_int64(sizeof(int64_t))) {
       RETURN_ERROR(FlatbufferSizeError);
     }
 
     offsets_t* values_offsets = get_values_offsets();
     offsets_t* sizes_offsets = get_sizes_offsets();
     values_offsets[0] = 0;
     sizes_offsets[0] = 0;
     sizes_t* storage_indices = get_storage_indices();
     for (int i = 0; i < total_items_count; i++) {
       storage_indices[i] = -1;
     }
 
     // the last value in values_buffer stores a null value:
     int8_t* null_value_buffer = get_values_buffer() + value_size * total_values_count;
     if (null_value_ptr != nullptr) {
       if (memcpy(null_value_buffer, null_value_ptr, value_size) == nullptr) {
         RETURN_ERROR(MemoryError);
       }
     } else {
       if (memset(null_value_buffer, 0, value_size) == nullptr) {
         RETURN_ERROR(MemoryError);
       }
     }
 
     if (user_data_size > 0 && user_data_ptr != nullptr) {
       int8_t* user_data_buffer = get_user_data_buffer();
       if (memcpy(user_data_buffer, user_data_ptr, user_data_size) == nullptr) {
         RETURN_ERROR(MemoryError);
       }
     }
 
     ((int64_t*)buffer)[base->flatbuffer_size / sizeof(int64_t) - 1] =
         static_cast<int64_t>(base->format_id);
 
     if (isFlatBuffer(buffer)) {
       // make sure that initialization leads to a valid FlatBuffer
       return Success;
     }
     RETURN_ERROR(UnknownFormatError);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST static DEVICE bool FlatBufferManager::isFlatBuffer ( const void * buffer )

inlinestatic

Definition at line 528 of file FlatBuffer.h.

References buffer, FlatBufferManager::BaseWorker::format_id, GeoPointFormatId, and NestedArrayFormatId.

Referenced by TableFunctionManager::allocate_output_buffers(), ChunkIter_get_nth(), ChunkIter_get_nth_varlen(), getBufferSize(), ResultSet::getTargetValueFromBufferColwise(), getTargetValueFromFlatBuffer(), initializeNestedArray(), ResultSet::makeGeoTargetValue(), ResultSet::makeVarlenTargetValue(), synthesize_metadata_table_function(), ColumnFetcher::transferColumnIfNeeded(), and ColumnarResults::writeBackCell().

                                                            {
     if (buffer) {
       // warning: assume that buffer size is at least 8 bytes
       const auto* base = reinterpret_cast<const BaseWorker*>(buffer);
       FlatBufferFormat header_format = base->format_id;
       switch (header_format) {
         case NestedArrayFormatId:
         case GeoPointFormatId: {
           int64_t flatbuffer_size = base->flatbuffer_size;
           if (flatbuffer_size > 0) {
             FlatBufferFormat footer_format = static_cast<FlatBufferFormat>(
                 ((int64_t*)buffer)[flatbuffer_size / sizeof(int64_t) - 1]);
             return footer_format == header_format;
           }
           break;
         }
         default:
           break;
       }
     }
     return false;
   }

Here is the caller graph for this function:

HOST DEVICE bool FlatBufferManager::isNestedArray ( ) const

inline

Definition at line 567 of file FlatBuffer.h.

References format(), and NestedArrayFormatId.

Referenced by getItemWorker(), getLength(), getNDims(), getNullValuePtr(), isNull(), isSpecified(), and setNull().

                                                 {
     return format() == NestedArrayFormatId;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

template<size_t NDIM>

HOST DEVICE Status FlatBufferManager::isNull	(	const int64_t	index[NDIM],
		const size_t	n,
		bool &	is_null
	)

inline

Definition at line 1052 of file FlatBuffer.h.

References FlatBufferManager::NestedArrayItem< NDIM >::is_null, isNestedArray(), anonymous_namespace{Utm.h}::n, NotSupportedFormatError, RETURN_ERROR, and Success.

                                                                                       {
     if (isNestedArray()) {
       NestedArrayItem<NDIM> item;
       auto status = getItem<NDIM>(index, n, item);
       if (status != Success) {
         RETURN_ERROR(status);
       }
       is_null = item.is_null;
       return Success;
     }
     RETURN_ERROR(NotSupportedFormatError);
   }

Here is the call graph for this function:

HOST DEVICE Status FlatBufferManager::isNull	(	int64_t	index,
		bool &	is_null
	)		const

inline

Definition at line 2099 of file FlatBuffer.h.

References dtypeSize(), format(), GeoPointFormatId, get_storage_index(), get_values(), IndexError, isNestedArray(), itemsCount(), RETURN_ERROR, Success, and UnknownFormatError.

                                                                 {
     if (index < 0 || index >= itemsCount()) {
       RETURN_ERROR(IndexError);
     }
     if (isNestedArray()) {
       const auto storage_index = get_storage_index(index);
       const auto* values_offsets = get_values_offsets();
       const auto values_offset = values_offsets[storage_index];
       is_null = values_offset < 0;
       return Success;
     }
     if (index < 0 || index >= itemsCount()) {
       RETURN_ERROR(IndexError);
     }
     // To be deprecated in favor of NestedArray format:
     switch (format()) {
       case GeoPointFormatId: {
         const int8_t* values = get_values();
         const auto* metadata = getGeoPointMetadata();
         int64_t itemsize = dtypeSize();
         if (metadata->is_geoint) {
           // per Geospatial/CompressionRuntime.h:is_null_point_longitude_geoint32
           is_null = (*reinterpret_cast<const uint32_t*>(values + index * itemsize)) ==
                     0x80000000U;
         } else {
           // per Shared/InlineNullValues.h:NULL_ARRAY_DOUBLE
           is_null = (*reinterpret_cast<const double*>(values + index * itemsize)) ==
                     2 * DBL_MIN;
         }
         return Success;
       }
       default:
         break;
     }
     RETURN_ERROR(UnknownFormatError);
   }

Here is the call graph for this function:

HOST DEVICE bool FlatBufferManager::isSpecified ( int64_t index ) const

inline

Definition at line 2017 of file FlatBuffer.h.

References get_storage_indices(), isNestedArray(), and itemsCount().

                                                     {
     if (index < 0 || index >= itemsCount()) {
       return false;
     }
     if (isNestedArray()) {
       auto* storage_indices = get_storage_indices();
       return storage_indices[index] >= 0;
     }
     return false;
   }

Here is the call graph for this function:

HOST DEVICE int64_t FlatBufferManager::itemsCount ( ) const

inline

Definition at line 604 of file FlatBuffer.h.

References format(), GeoPointFormatId, and NestedArrayFormatId.

Referenced by concatItemWorker(), getItemOld(), getItemWorker(), getLength(), isNull(), isSpecified(), setItemOld(), setItemWorker(), and setNull().

                                                 {
     switch (format()) {
       case GeoPointFormatId:
         return getGeoPointMetadata()->total_items_count;
       case NestedArrayFormatId:
         return getNestedArrayMetadata()->total_items_count;
       default:
         break;
     }
     return -1;  // invalid value
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Status FlatBufferManager::setEmptyItemNoValidation	(	int64_t	index,
		int64_t	size,
		int8_t **	dest
	)

inline

Definition at line 2013 of file FlatBuffer.h.

References setItemNoValidation().

                                                                               {
     return setItemNoValidation(index, nullptr, size, dest);
   }

Here is the call graph for this function:

template<size_t NDIM = 1, bool check_sizes = true>

HOST DEVICE Status FlatBufferManager::setItem	(	const int64_t	index,
		const int8_t *	values_buf,
		const int32_t	nof_values
	)

inline

Definition at line 1593 of file FlatBuffer.h.

Referenced by writeBackCellArrayScalar(), writeBackCellGeoNestedArray(), and writeBackCellTextEncodingNone().

                                            {
     const int32_t* const sizes_buffers[1] = {nullptr};
     int32_t sizes_lengths[1] = {0};
     return setItemWorker<1, check_sizes>(index,
                                          values_buf,
                                          nof_values,
                                          sizes_buffers,
                                          sizes_lengths,
                                          0);
   }

Here is the caller graph for this function:

template<size_t NDIM = 1, bool check_sizes = true>

HOST DEVICE Status FlatBufferManager::setItem	(	const int64_t	index,
		const int8_t *	values_buf,
		const int32_t	nof_values,
		const int32_t *	sizes_buf,
		const int32_t	nof_sizes
	)

inline

Definition at line 1607 of file FlatBuffer.h.

                                           {
     const int32_t* const sizes_buffers[NDIM] = {sizes_buf};
     int32_t sizes_lengths[NDIM] = {nof_sizes};
     return setItemWorker<NDIM, check_sizes>(index,
                                             values_buf,
                                             nof_values,
                                             sizes_buffers,
                                             sizes_lengths,
                                             static_cast<int32_t>(NDIM));
   }

template<size_t NDIM = 2, bool check_sizes = true>

HOST DEVICE Status FlatBufferManager::setItem	(	const int64_t	index,
		const int8_t *	values_buf,
		const int32_t	nof_values,
		const int32_t *	sizes_buf,
		const int32_t	nof_sizes,
		const int32_t *	sizes_of_sizes_buf,
		const int32_t	nof_sizes_of_sizes
	)

inline

Definition at line 1623 of file FlatBuffer.h.

                                                    {
     const int32_t* const sizes_buffers[NDIM] = {sizes_of_sizes_buf, sizes_buf};
     int32_t sizes_lengths[NDIM] = {nof_sizes_of_sizes, nof_sizes};
     return setItemWorker<NDIM, check_sizes>(index,
                                             values_buf,
                                             nof_values,
                                             sizes_buffers,
                                             sizes_lengths,
                                             static_cast<int32_t>(NDIM));
   }

template<size_t NDIM = 1, bool check_sizes = true>

HOST DEVICE Status FlatBufferManager::setItem	(	const int64_t	index,
		const NestedArrayItem< NDIM > &	item
	)

inline

Definition at line 1641 of file FlatBuffer.h.

References FlatBufferManager::NestedArrayItem< NDIM >::is_null, FlatBufferManager::NestedArrayItem< NDIM >::nof_sizes, FlatBufferManager::NestedArrayItem< NDIM >::nof_values, FlatBufferManager::NestedArrayItem< NDIM >::sizes_buffers, FlatBufferManager::NestedArrayItem< NDIM >::sizes_lengths, Success, and FlatBufferManager::NestedArrayItem< NDIM >::values.

                                                                 {
     if (item.is_null) {
       return Success;
     }
     return setItemWorker<NDIM, check_sizes>(index,
                                             item.values,
                                             item.nof_values,
                                             item.sizes_buffers,
                                             item.sizes_lengths,
                                             item.nof_sizes);
   }

Status FlatBufferManager::setItem	(	const int64_t	index,
		const std::string &	s
	)

inline

Definition at line 1800 of file FlatBuffer.h.

References Int8, RETURN_ERROR, and TypeError.

                                                           {
     const auto* metadata = getNestedArrayMetadata();
     if (metadata->value_type != Int8) {
       RETURN_ERROR(TypeError);
     }
     return setItem<1, false>(index, reinterpret_cast<const int8_t*>(s.data()), s.size());
   }

template<typename CT , size_t NDIM = 0>

Status FlatBufferManager::setItem	(	const int64_t	index,
		const std::vector< CT > &	arr
	)

inline

Definition at line 1809 of file FlatBuffer.h.

References DimensionalityError, getNDims(), getValueSize(), NotImplementedError, PointFloat64, PointInt32, RETURN_ERROR, and TypeError.

                                                                 {
     if (getNDims() != NDIM + 1) {
       RETURN_ERROR(DimensionalityError);
     }
     if constexpr (!std::is_same<CT, uint8_t>::value) {
       if constexpr (std::is_same<CT, double>::value) {
         const auto* metadata = getNestedArrayMetadata();
         if (metadata->value_type != PointFloat64) {
           RETURN_ERROR(TypeError);
         }
       } else if constexpr (std::is_same<CT, int32_t>::value) {
         const auto* metadata = getNestedArrayMetadata();
         if (metadata->value_type != PointInt32) {
           RETURN_ERROR(TypeError);
         }
       } else {
         RETURN_ERROR(NotImplementedError);
       }
     }
     const auto valuesize = getValueSize();
     auto sz = (arr.size() * sizeof(CT)) / valuesize;
     const int32_t* const sizes_buffers[1] = {nullptr};
     int32_t sizes_lengths[1] = {0};
     return setItemWorker<1, false>(index,
                                 reinterpret_cast<const int8_t*>(arr.data()),
                                 sz,
                                 sizes_buffers,
                                 sizes_lengths,
                                 0);
   }

Here is the call graph for this function:

template<typename CT , size_t NDIM = 1, bool check_sizes = false>

Status FlatBufferManager::setItem	(	const int64_t	index,
		const std::vector< std::vector< CT >> &	item
	)

inline

Definition at line 1841 of file FlatBuffer.h.

References getValueSize().

                                                                             {
     const auto valuesize = getValueSize();
     std::vector<int32_t> sizes;
     sizes.reserve(item.size());
     int32_t nof_values = 0;
     size_t nof_elements = 0;
     for (const auto& subitem: item) {
       const auto sz = (subitem.size() * sizeof(CT)) / valuesize;
       sizes.push_back(sz);
       nof_values += sz;
       nof_elements += subitem.size();
     }
     std::vector<CT> flatitem;
     flatitem.reserve(nof_elements);
     for (const auto& subitem: item) {
       flatitem.insert(flatitem.end(), subitem.begin(), subitem.end());
     }
     return setItem<CT, NDIM, check_sizes>(index, flatitem, sizes);
   }

Here is the call graph for this function:

template<typename CT , size_t NDIM = 2, bool check_sizes = false>

Status FlatBufferManager::setItem	(	const int64_t	index,
		const std::vector< std::vector< std::vector< CT >>> &	item
	)

inline

Definition at line 1862 of file FlatBuffer.h.

References getValueSize().

                                                                   {
     const auto valuesize = getValueSize();
     std::vector<int32_t> sizes_of_sizes;
     std::vector<int32_t> sizes;
     std::vector<CT> flatitem;
     sizes_of_sizes.reserve(item.size());
     size_t nof_sizes_of_sizes = 0;
     for (const auto& subitem: item) {
       sizes_of_sizes.push_back(subitem.size());
       nof_sizes_of_sizes += subitem.size();
     }
     sizes.reserve(nof_sizes_of_sizes);
     int32_t nof_values = 0;
     size_t nof_elements = 0;
     for (const auto& subitem: item) {
       for (const auto& subitem1: subitem) {
         const auto sz = (subitem1.size() * sizeof(CT)) / valuesize;
         sizes.push_back(sz);
         nof_values += sz;
         nof_elements += subitem1.size();
       }
     }
     flatitem.reserve(nof_elements);
     for (const auto& subitem: item) {
       for (const auto& subitem1: subitem) {
         flatitem.insert(flatitem.end(), subitem1.begin(), subitem1.end());
       }
     }
     return setItem<CT, NDIM, check_sizes>(index, flatitem, sizes, sizes_of_sizes);
   }

Here is the call graph for this function:

template<typename CT , size_t NDIM = 1, bool check_sizes = true>

Status FlatBufferManager::setItem	(	const int64_t	index,
		const std::vector< CT > &	values,
		const std::vector< int32_t > &	sizes
	)

inline

Definition at line 1895 of file FlatBuffer.h.

References DimensionalityError, getNDims(), getValueSize(), NotImplementedError, PointFloat64, PointInt32, RETURN_ERROR, and TypeError.

                                                   {
     if (getNDims() != NDIM + 1) {
       RETURN_ERROR(DimensionalityError);
     }
     const auto* metadata = getNestedArrayMetadata();
     if constexpr (!std::is_same<CT, uint8_t>::value) {
       if constexpr (std::is_same<CT, double>::value) {
         if (metadata->value_type != PointFloat64) {
           RETURN_ERROR(TypeError);
         }
       } else if constexpr (std::is_same<CT, int32_t>::value) {
         if (metadata->value_type != PointInt32) {
           RETURN_ERROR(TypeError);
         }
       } else {
         RETURN_ERROR(NotImplementedError);
       }
     }
     const auto valuesize = getValueSize();
     const int32_t nof_values = (values.size() * sizeof(CT)) / valuesize;
     return setItem<NDIM, check_sizes>(index,
                                       reinterpret_cast<const int8_t*>(values.data()),
                                       nof_values,
                                       sizes.data(),
                                       sizes.size());
   }

Here is the call graph for this function:

template<typename CT , size_t NDIM = 2, bool check_sizes = true>

Status FlatBufferManager::setItem	(	const int64_t	index,
		const std::vector< CT > &	values,
		const std::vector< int32_t > &	sizes,
		const std::vector< int32_t > &	sizes_of_sizes
	)

inline

Definition at line 1925 of file FlatBuffer.h.

References DimensionalityError, getNDims(), getValueSize(), NotImplementedError, PointFloat64, PointInt32, RETURN_ERROR, and TypeError.

                                                            {
     if (getNDims() != NDIM + 1) {
       RETURN_ERROR(DimensionalityError);
     }
     const auto* metadata = getNestedArrayMetadata();
     if constexpr (!std::is_same<CT, uint8_t>::value) {
       if constexpr (std::is_same<CT, double>::value) {
         if (metadata->value_type != PointFloat64) {
           RETURN_ERROR(TypeError);
         }
       } else if constexpr (std::is_same<CT, int32_t>::value) {
         if (metadata->value_type != PointInt32) {
           RETURN_ERROR(TypeError);
         }
       } else {
         RETURN_ERROR(NotImplementedError);
       }
     }
     const auto valuesize = getValueSize();
     const auto nof_values = (values.size() * sizeof(CT)) / valuesize;
     return setItem<NDIM, check_sizes>(index,
                                       reinterpret_cast<const int8_t*>(values.data()),
                                       nof_values,
                                       sizes.data(),
                                       sizes.size(),
                                       sizes_of_sizes.data(),
                                       sizes_of_sizes.size()
                                       );
   }

Here is the call graph for this function:

Status FlatBufferManager::setItemNoValidation	(	const int64_t	index,
		const int8_t *	src,
		const int64_t	size,
		int8_t **	dest
	)

inline

Definition at line 1986 of file FlatBuffer.h.

References dtypeSize(), format(), GeoPointFormatId, get_values(), MemoryError, RETURN_ERROR, Success, and UnknownFormatError.

Referenced by setEmptyItemNoValidation(), and setItemOld().

                                             {
     switch (format()) {
       case GeoPointFormatId: {
         int8_t* values = get_values();
         const int64_t itemsize = dtypeSize();
         const int64_t csize = index * itemsize;
         if (src != nullptr && memcpy(values + csize, src, size) == nullptr) {
           RETURN_ERROR(MemoryError);
         }
         if (dest != nullptr) {
           *dest = values + csize;
         }
         break;
       }
       default:
         RETURN_ERROR(UnknownFormatError);
     }
 
     return Success;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Status FlatBufferManager::setItemOld	(	const int64_t	index,
		const int8_t *	src,
		const int64_t	size,
		int8_t **	dest = `nullptr`
	)

inline

Definition at line 1963 of file FlatBuffer.h.

References run_benchmark_import::dest, dtypeSize(), format(), GeoPointFormatId, IndexError, itemsCount(), RETURN_ERROR, setItemNoValidation(), SizeError, and UnknownFormatError.

Referenced by writeBackCellGeoPoint().

                                              {
     if (index < 0 || index >= itemsCount()) {
       RETURN_ERROR(IndexError);
     }
     switch (format()) {
       case GeoPointFormatId: {
         const int64_t itemsize = dtypeSize();
         if (size != itemsize) {
           RETURN_ERROR(SizeError);
         }
         break;
       }
       default:
         RETURN_ERROR(UnknownFormatError);
     }
     return setItemNoValidation(index, src, size, dest);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

template<size_t NDIM, bool check_sizes = true>

HOST DEVICE Status FlatBufferManager::setItemWorker	(	const int64_t	index,
		const int8_t *	values,
		const int32_t	nof_values,
		const int32_t *const	sizes_buffers[NDIM],
		const int32_t	sizes_lengths[NDIM],
		const int32_t	nof_sizes
	)

inline

Definition at line 1368 of file FlatBuffer.h.

References DimensionalityError, FLATBUFFER_UNREACHABLE, format(), get_storage_indices(), getNDims(), getValueSize(), InconsistentSizesError, IndexError, ItemAlreadySpecifiedError, itemsCount(), MemoryError, NestedArrayFormatId, NotSupportedFormatError, RETURN_ERROR, SizesBufferTooSmallError, Success, and ValuesBufferTooSmallError.

                                           {
     if (format() != NestedArrayFormatId) {
       RETURN_ERROR(NotSupportedFormatError);
     }
     if (index < 0 || index >= itemsCount()) {
       RETURN_ERROR(IndexError);
     }
     const int32_t ndims = getNDims();
     if (nof_sizes + 1 != ndims) {
       RETURN_ERROR(DimensionalityError);
     }
 
     auto* storage_indices = get_storage_indices();
     if (storage_indices[index] >= 0) {
       RETURN_ERROR(ItemAlreadySpecifiedError);
     }
     auto* worker = getNestedArrayWorker();
     const auto storage_index = worker->specified_items_count;
     storage_indices[index] = storage_index;
     worker->specified_items_count++;
 
     auto* values_offsets = get_values_offsets();
     auto* sizes_offsets = get_sizes_offsets();
     auto* sizes_buffer = get_sizes_buffer();
     auto* values_buffer = get_values_buffer();
     const auto* metadata = getNestedArrayMetadata();
     const auto valuesize = getValueSize();
 
     auto values_offset = values_offsets[storage_index];
     const auto sizes_offset = sizes_offsets[storage_index * ndims];
     if (values_offset + nof_values > metadata->total_values_count) {
       RETURN_ERROR(ValuesBufferTooSmallError);
     }
 
     switch (ndims) {
       case 1: {
         sizes_buffer[sizes_offset] = nof_values;
         sizes_offsets[storage_index * ndims + 1] = sizes_offset + 1;
       } break;
       case 2: {
         const auto sizes2_offset = sizes_offset + 1;
         if (sizes2_offset + sizes_lengths[0] > metadata->total_sizes_count) {
           RETURN_ERROR(SizesBufferTooSmallError);
         }
         sizes_buffer[sizes_offset] = sizes_lengths[0];
         if constexpr (check_sizes) {
           // check consistency of sizes and nof_values
           int32_t sum_of_sizes = 0;
           for (int32_t i=0; i < sizes_lengths[0]; i++) {
             sum_of_sizes += sizes_buffers[0][i];
           }
           if (nof_values != sum_of_sizes) {
             RETURN_ERROR(InconsistentSizesError);
           }
         }
         if (memcpy(sizes_buffer + sizes2_offset,
                    sizes_buffers[0],
                    sizes_lengths[0] * sizeof(sizes_t)) == nullptr) {
           RETURN_ERROR(MemoryError);
         }
         sizes_offsets[storage_index * ndims + 1] = sizes2_offset;
         sizes_offsets[storage_index * ndims + 2] = sizes2_offset + sizes_lengths[0];
       } break;
       case 3: {
         const auto sizes2_offset = sizes_offset + 1;
         const auto sizes3_offset = sizes2_offset + sizes_lengths[0];
         if (sizes2_offset + sizes_lengths[0] + sizes_lengths[1] >
             metadata->total_sizes_count) {
           RETURN_ERROR(SizesBufferTooSmallError);
         }
         sizes_buffer[sizes_offset] = sizes_lengths[0];
         if constexpr (check_sizes) {
           // check consistency of sizes of sizes and nof_sizes
           int32_t sum_of_sizes_of_sizes = 0;
           for (int32_t i=0; i < sizes_lengths[0]; i++) {
             sum_of_sizes_of_sizes += sizes_buffers[0][i];
           }
           if (sizes_lengths[1] != sum_of_sizes_of_sizes) {
             RETURN_ERROR(InconsistentSizesError);
           }
         }
         if (memcpy(sizes_buffer + sizes2_offset,
                    sizes_buffers[0],
                    sizes_lengths[0] * sizeof(sizes_t)) == nullptr) {
           RETURN_ERROR(MemoryError);
         }
         if constexpr (check_sizes) {
           // check consistency of sizes and nof_values
           int32_t sum_of_sizes = 0;
           for (int32_t i=0; i < sizes_lengths[1]; i++) {
             sum_of_sizes += sizes_buffers[1][i];
           }
           if (nof_values != sum_of_sizes) {
             RETURN_ERROR(InconsistentSizesError);
           }
         }
         if (memcpy(sizes_buffer + sizes3_offset,
                    sizes_buffers[1],
                    sizes_lengths[1] * sizeof(sizes_t)) == nullptr) {
           RETURN_ERROR(MemoryError);
         }
         sizes_offsets[storage_index * ndims + 1] = sizes2_offset;
         sizes_offsets[storage_index * ndims + 2] = sizes3_offset;
         sizes_offsets[storage_index * ndims + 3] = sizes3_offset + sizes_lengths[1];
       } break;
       default:
         FLATBUFFER_UNREACHABLE();
         break;
     }
     if (values != nullptr) {
       if (memcpy(values_buffer + values_offset * valuesize,
                  values,
                  nof_values * valuesize) == nullptr) {
         RETURN_ERROR(MemoryError);
       }
     }
     values_offsets[storage_index + 1] = values_offset + nof_values;
     return Success;
   }

Here is the call graph for this function:

HOST DEVICE Status FlatBufferManager::setNull ( int64_t index )

inline

Definition at line 2029 of file FlatBuffer.h.

References format(), GeoPointFormatId, get_storage_indices(), getNDims(), IndexError, isNestedArray(), ItemAlreadySpecifiedError, itemsCount(), RETURN_ERROR, setNullNoValidation(), Success, and UnknownFormatError.

Referenced by Column< GeoPoint >::setNull(), writeBackCellArrayScalar(), writeBackCellGeoNestedArray(), and writeBackCellTextEncodingNone().

                                             {
     if (index < 0 || index >= itemsCount()) {
       RETURN_ERROR(IndexError);
     }
     if (isNestedArray()) {
       auto* storage_indices = get_storage_indices();
       if (storage_indices[index] >= 0) {
         RETURN_ERROR(ItemAlreadySpecifiedError);
       }
       auto* worker = getNestedArrayWorker();
       const auto storage_index = worker->specified_items_count;
       worker->specified_items_count++;
       storage_indices[index] = storage_index;
       const size_t ndims = getNDims();
       auto* sizes_buffer = get_sizes_buffer();
       auto* values_offsets = get_values_offsets();
       auto* sizes_offsets = get_sizes_offsets();
       const auto values_offset = values_offsets[storage_index];
       const auto sizes_offset = sizes_offsets[storage_index * ndims];
       sizes_buffer[sizes_offset] = 0;
       for (size_t i = 0; i < ndims; i++) {
         sizes_offsets[storage_index * ndims + i + 1] = sizes_offset + 1;
       }
       values_offsets[storage_index] = -(values_offset + 1);
       values_offsets[storage_index + 1] = values_offset;
       return Success;
     }
     // To be deprecated in favor of NestedArray format:
     if (index < 0 || index >= itemsCount()) {
       RETURN_ERROR(IndexError);
     }
 
     switch (format()) {
       case GeoPointFormatId: {
         return setNullNoValidation(index);
       }
       default:
         break;
     }
     RETURN_ERROR(UnknownFormatError);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST DEVICE Status FlatBufferManager::setNullNoValidation ( int64_t index )

inline

Definition at line 2073 of file FlatBuffer.h.

References dtypeSize(), format(), GeoPointFormatId, get_values(), RETURN_ERROR, Success, and UnknownFormatError.

Referenced by setNull().

                                                         {
     switch (format()) {
       case GeoPointFormatId: {
         int8_t* values = get_values();
         int64_t itemsize = dtypeSize();
         const auto* metadata = getGeoPointMetadata();
         if (metadata->is_geoint) {
           // per Geospatial/CompressionRuntime.h:is_null_point_longitude_geoint32
           *reinterpret_cast<uint32_t*>(values + index * itemsize) = 0x80000000U;
           *reinterpret_cast<uint32_t*>(values + index * itemsize + sizeof(int32_t)) =
               0x80000000U;
         } else {
           // per Shared/InlineNullValues.h:NULL_ARRAY_DOUBLE
           *reinterpret_cast<double*>(values + index * itemsize) = 2 * DBL_MIN;
           *reinterpret_cast<double*>(values + index * itemsize + sizeof(double)) =
               2 * DBL_MIN;
         }
         break;
       }
       default:
         RETURN_ERROR(UnknownFormatError);
     }
     return Success;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

HOST DEVICE int64_t FlatBufferManager::valueByteSize ( ) const

inline

Definition at line 617 of file FlatBuffer.h.

References format(), and GeoPointFormatId.

                                                    {
     switch (format()) {
       case GeoPointFormatId:
         return 2 * (getGeoPointMetadata()->is_geoint ? sizeof(int32_t) : sizeof(double));
       default:
         break;
     }
     return -1;
   }

Here is the call graph for this function:

Member Data Documentation

int8_t* FlatBufferManager::buffer

Definition at line 519 of file FlatBuffer.h.

Referenced by format(), get_storage_indices(), get_values(), getBaseWorker(), getBufferSize(), getValuesBuffer(), initialize(), initializeNestedArray(), and isFlatBuffer().

The documentation for this struct was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/Utils/FlatBuffer.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Member Function Documentation

Member Data Documentation