containers.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/compact_device_vector.hpp"
#include "detray/definitions/detail/qualifiers.hpp"
#include "detray/utils/tuple.hpp"
 
// Vecmem include(s)
#include <vecmem/containers/jagged_vector.hpp>
#include <vecmem/containers/vector.hpp>
 
// System include(s)
#include <array>
#include <map>
#include <type_traits>
#include <vector>
 
namespace detray {
 
template <typename value_t, std::size_t kDIM>
using darray = std::array<value_t, kDIM>;
 
template <typename value_t>
using dvector = vecmem::vector<value_t>;
 
template <typename value_t>
using djagged_vector = vecmem::jagged_vector<value_t>;
 
template <typename key_t, typename value_t>
using dmap = std::map<key_t, value_t>;
 
template <class... types>
using dtuple = detray::tuple<types...>;

template <template <typename...> class vector_t = dvector>
struct container_types {
  template <typename T>
  using vector_type = vector_t<T>;
 
  template <class... T>
  using tuple_type = dtuple<T...>;
 
  template <typename T, std::size_t kDIM>
  using array_type = darray<T, kDIM>;
};

template <template <typename...> class vector_t = dvector>
struct const_container_types {
  template <typename T>
  using vector_type = vector_t<std::add_const_t<T>>;
 
  template <class... T>
  using tuple_type = dtuple<std::add_const_t<T>...>;
 
  template <typename T, std::size_t kDIM>
  using array_type = darray<std::add_const_t<T>, kDIM>;
};

using host_container_types = container_types<>;
using const_host_container_types = const_container_types<>;
 
namespace detail {
 
// make std::get available in detray detail namespace, where also the thrust and
// index specific overloads live.
using std::get;

template <typename T>
struct has_reserve {
 private:
  template <typename C>
  static constexpr auto check(C*) ->
      typename std::is_void<decltype(std::declval<C>().reserve(
          std::declval<typename C::size_type>()))>::type;

  template <typename>
  static constexpr std::false_type check(...);

  using type = decltype(check<T>(nullptr));
 
 public:
  static constexpr bool value = type::value;
};

template <typename T>
  requires has_reserve<T>::value
DETRAY_HOST_DEVICE void call_reserve(T& obj, std::size_t newsize) {
  obj.reserve(newsize);
}
 
template <typename T>
  requires(!has_reserve<T>::value)
DETRAY_HOST_DEVICE void call_reserve(T& /*obj*/, std::size_t /*newsize*/) {
  /*Not defined*/
}
 
}  // namespace detail
 
}  // namespace detray