FlatBufferManager Struct Reference

#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