grid_bins.hpp

// This file is part of the ACTS project.
//
// Copyright (C) 2016 CERN for the benefit of the ACTS project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
#pragma once
 
// Project include(s).
#include "detray/core/detail/container_views.hpp"
#include "detray/definitions/detail/qualifiers.hpp"
#include "detray/definitions/indexing.hpp"
#include "detray/utils/invalid_values.hpp"
#include "detray/utils/ranges.hpp"
 
// System include(s)
#include <algorithm>
 
namespace detray::bins {

template <typename entry_t>
class single : public detray::ranges::single_view<entry_t> {
  using base_type = detray::ranges::single_view<entry_t>;
 
 public:
  using entry_type = entry_t;
  using base_type::base_type;
  using base_type::operator=;

  DETRAY_HOST_DEVICE constexpr single()
      : base_type{detail::invalid_value<entry_t>()} {}

  DETRAY_HOST_DEVICE
  constexpr dindex capacity() noexcept { return 1u; }

  template <typename E = entry_t>
  DETRAY_HOST_DEVICE constexpr void push_back(E&& entry) noexcept {
    (*this).ref() = std::forward<E>(entry);
  }

  DETRAY_HOST_DEVICE
  constexpr auto init(entry_t entry = detail::invalid_value<entry_t>())
      -> single& {
    (*this).ref() = entry;
    return *this;
  }

  DETRAY_HOST_DEVICE
  constexpr bool operator==(const single& rhs) const {
    return (*this).value() == rhs.value();
  }
};

template <typename entry_t, std::size_t N>
class static_array
    : public detray::ranges::view_interface<static_array<entry_t, N>> {
  using bin_view_t = detray::ranges::subrange<darray<entry_t, N>>;
  using const_bin_view_t = detray::ranges::subrange<const darray<entry_t, N>>;
  using bin_iterator_t = typename detray::ranges::iterator_t<bin_view_t>;
  using const_bin_iterator_t =
      typename detray::ranges::const_iterator_t<const_bin_view_t>;
 
 public:
  using entry_type = entry_t;

  DETRAY_HOST_DEVICE constexpr static_array() { init(); };
  constexpr static_array(const static_array& other) = default;
  constexpr static_array(static_array&& other) noexcept = default;
  static_array& operator=(const static_array& other) noexcept = default;

  DETRAY_HOST_DEVICE bin_iterator_t begin() {
    return detray::ranges::begin(m_content);
  }

  DETRAY_HOST_DEVICE bin_iterator_t end() {
    return detray::ranges::begin(m_content) + m_size;
  }

  DETRAY_HOST_DEVICE
  const_bin_iterator_t begin() const {
    return detray::ranges::cbegin(m_content);
  }

  DETRAY_HOST_DEVICE
  const_bin_iterator_t end() const {
    return detray::ranges::cbegin(m_content) + m_size;
  }


  DETRAY_HOST_DEVICE
  constexpr dindex size() const { return m_size; }

  DETRAY_HOST_DEVICE
  constexpr dindex capacity() const noexcept {
    return static_cast<dindex>(m_content.size());
  }

  template <typename E = entry_t>
  DETRAY_HOST_DEVICE constexpr void push_back(E&& entry) noexcept {
    m_content[m_size] = std::forward<E>(entry);
    ++m_size;
  }

  DETRAY_HOST_DEVICE
  constexpr auto init(entry_t entry = detail::invalid_value<entry_t>())
      -> static_array& {
    // Initialize the storage element
    for (auto& e : m_content) {
      e = detail::invalid_value<entry_t>();
    }
 
    if (entry == detail::invalid_value<entry_t>()) {
      m_size = 0u;
      return *this;
    }
 
    // The bin has at least a capacity of 1
    m_content[0] = entry;
    m_size = 1u;
 
    return *this;
  }

  DETRAY_HOST_DEVICE
  constexpr auto init(darray<entry_t, N> content) -> static_array& {
    m_content = content;
    m_size = 0u;
    for (const auto& entry : m_content) {
      if (entry != detail::invalid_value<entry_t>()) {
        ++m_size;
      }
    }
 
    return *this;
  }

  DETRAY_HOST_DEVICE
  constexpr bool operator==(const static_array& rhs) const {
    return m_content == rhs.m_content;
  }
 
 private:
  dindex m_size{0u};
  darray<entry_t, N> m_content{};
};

template <typename entry_t>
class dynamic_array
    : public detray::ranges::view_interface<dynamic_array<entry_t>> {
  using container_t = device_container_types::template vector_type<entry_t>;
 
 public:
  struct data {
    dindex offset{0u};
    dindex size{0u};
    dindex capacity{0u};

    constexpr bool operator==(const data& rhs) const = default;

    DETRAY_HOST_DEVICE
    constexpr void update_offset(std::size_t shift) {
      offset += static_cast<dindex>(shift);
    }
  };

  using entry_type = entry_t;
  using entry_ptr_t = const entry_type*;
  using data_ptr_t = const data*;

  DETRAY_HOST_DEVICE constexpr dynamic_array() { init(); };

  DETRAY_HOST_DEVICE
  dynamic_array(entry_type* bin_storage, data& bin_data)
      : m_data{&bin_data}, m_capacity{bin_data.capacity} {
    // Prevent null-dereference warning
    if (bin_storage) {
      m_global_storage = bin_storage + bin_data.offset;
    }
  }

  DETRAY_HOST_DEVICE
  dynamic_array(const entry_type* bin_storage, const data& bin_data)
      : m_data{&bin_data}, m_capacity{bin_data.capacity} {
    // Prevent null-dereference warning
    if (bin_storage) {
      m_global_storage = bin_storage + bin_data.offset;
    }
  }

  DETRAY_HOST_DEVICE auto begin() {
    return const_cast<entry_type*>(m_global_storage);
  }

  DETRAY_HOST_DEVICE auto end() {
    return const_cast<entry_type*>(m_global_storage) + m_data->size;
  }

  DETRAY_HOST_DEVICE auto begin() const { return m_global_storage; }

  DETRAY_HOST_DEVICE auto end() const {
    return m_global_storage + m_data->size;
  }


  DETRAY_HOST_DEVICE
  constexpr dindex size() const { return m_data->size; }

  DETRAY_HOST_DEVICE
  constexpr dindex capacity() const noexcept { return m_capacity; }

  template <typename E = entry_type>
  DETRAY_HOST_DEVICE constexpr void push_back(E&& entry) {
    assert(m_capacity > 0);
    assert(m_data->size <= m_capacity);
    assert(m_global_storage);
 
    if (m_data->size < m_capacity) {
      *(const_cast<entry_type*>(m_global_storage) + m_data->size) =
          std::forward<E>(entry);
      ++(const_cast<data*>(m_data)->size);
    }
  }

  DETRAY_HOST_DEVICE
  constexpr auto init(entry_type entry = detail::invalid_value<entry_type>())
      -> dynamic_array& {
    if (capacity() == 0u) {
      return *this;
    }
 
    // Initialize the storage element
    std::ranges::fill(this, detail::invalid_value<entry_type>());
 
    if (entry == detail::invalid_value<entry_type>()) {
      const_cast<data*>(m_data)->size = 0u;
      return *this;
    }
 
    // The bin has at least a capacity of 1
    this->front() = entry;
    const_cast<data*>(m_data)->size = 1u;
 
    return *this;
  }

  template <typename storage_t>
  DETRAY_HOST_DEVICE constexpr auto init(const storage_t& content)
      -> dynamic_array& {
    const_cast<data*>(m_data)->size = 0u;
    for (dindex i{0u}; i < m_capacity; ++i) {
      if (content[i] != detail::invalid_value<entry_type>()) {
        const_cast<entry_type*>(m_global_storage)[i] = content[i];
        ++(const_cast<data*>(m_data)->size);
      }
    }
    return *this;
  }

  DETRAY_HOST_DEVICE
  constexpr bool operator==(const dynamic_array& rhs) const {
    // Check if the bin points to the same data
    if (m_data == rhs.m_data || *m_data == *rhs.m_data) {
      return true;
    }
    if (m_data->size != rhs.m_data->size) {
      return false;
    }
    // It could still point to different data, but the
    // content is the same
    // Loop over the size of the bin and compare
    for (dindex i{0u}; i < m_data->size; ++i) {
      if (m_global_storage[i] != rhs.m_global_storage[i]) {
        return false;
      }
    }
    return true;
  }
 
 private:
  entry_ptr_t m_global_storage{nullptr};
  data_ptr_t m_data{nullptr};
  dindex m_capacity{0u};
};
 
template <typename entry_t, typename data_t>
dynamic_array(entry_t* bin_storage, data_t& bin_data) -> dynamic_array<entry_t>;
 
template <typename entry_t, typename data_t>
dynamic_array(const entry_t* bin_storage, const data_t& bin_data)
    -> dynamic_array<entry_t>;
}  // namespace detray::bins