Row accessor

The row_accessor class provides a read-only access to the rows of the table as contiguous homogeneous array.

Usage example

#include <CL/sycl.hpp>
#include <iostream>

#include "oneapi/dal/table/homogen.hpp"
#include "oneapi/dal/table/row_accessor.hpp"

using namespace oneapi;

int main() {
   sycl::queue queue { sycl::default_selector() };

   constexpr float host_data[] = {
      1.0f, 1.5f, 2.0f,
      2.1f, 3.2f, 3.7f,
      4.0f, 4.9f, 5.0f,
      5.2f, 6.1f, 6.2f

   constexpr std::int64_t row_count = 4;
   constexpr std::int64_t column_count = 3;

   auto shared_data = sycl::malloc_shared<float>(row_count * column_count, queue);
   auto event = queue.memcpy(shared_data, host_data, sizeof(float) * row_count * column_count);
   auto t = dal::homogen_table::wrap(queue, data, row_count, column_count, { event });

   // Accessing second and third rows of the table
   dal::row_accessor<const float> acc { t };

   auto block = acc.pull(queue, {1, 3});
   for(std::int64_t i = 0; i < block.get_count(); i++) {
      std::cout << block[i] << ", ";
   std::cout << std::endl;

   sycl::free(shared_data, queue);
   return 0;

Programming interface

All types and functions in this section are declared in the oneapi::dal namespace and be available via inclusion of the oneapi/dal/table/row_accessor.hpp header file.

template<typename T>
class row_accessor
Template Parameters

T – The type of data values in blocks returned by the accessor. Should be const-qualified for read-only access. An accessor supports at least float, double, and std::int32_t types of T.


template <typename K, typename None = std::enable_if_t<is_readonly && (std::is_base_of_v<table, K> || std::is_base_of_v<detail::table_builder, K>> row_accessor(const K &obj)

Creates a new read-only accessor object from the table. The check that the accessor supports the table kind of obj is performed. The reference to the obj table is stored within the accessor to obtain data from the table.

row_accessor(const detail::table_builder &b)

Public Methods

array<data_t> pull(const range &rows = {0, -1}) const
T *pull(array<data_t> &block, const range &rows = {0, -1}) const
template<typename Q = T>
std::enable_if_t<sizeof(Q) && !is_readonly> push(const array<data_t> &block, const range &rows = {0, -1})