Concepts.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef O2_FRAMEWORK_CONCEPTS_H
#define O2_FRAMEWORK_CONCEPTS_H
 
#include <Framework/Traits.h>
#include <cstdint>
#include <concepts>
 
namespace o2::aod
{
template <uint32_t>
struct Hash;
template <typename T>
concept is_aod_hash = requires(T t) { t.isHash(); };
template <typename T>
concept is_origin_hash = requires(T t) { t.isOriginHash(); };
 
template <typename H>
struct MetadataTrait;
} // namespace o2::aod
 
namespace o2::soa
{
template <typename T>
concept not_void = requires { requires !std::same_as<T, void>; };
 
template <typename C>
concept is_persistent_column = requires(C c) { c.isIteratableColumn(); };
 
template <typename C>
concept is_self_index_column = requires(C c) {
  typename C::compatible_signature;
  // requires aod::is_aod_hash<typename C::compatible_signature>;
  typename C::self_index_t;
  requires std::same_as<typename C::self_index_t, std::true_type>;
};
 
template <typename C>
concept is_index_column = requires(C c) {
  typename C::binding_t;
  requires not_void<typename C::binding_t>;
};
 
template <typename T>
concept is_spawnable_column = std::same_as<typename std::decay_t<T>::spawnable_t, std::true_type>;
 
template <typename C>
concept is_indexing_column = requires(C c) { c.isEnumeratingColumn(); };
 
template <typename C>
concept is_dynamic_column = requires(C c) { c.isDynamicColumn(); };
 
template <typename C>
concept is_marker_column = requires(C c) { c.isMarkingColumn(); };
 
template <typename T>
concept is_column = is_persistent_column<T> || is_dynamic_column<T> || is_indexing_column<T> || is_marker_column<T>;
 
template <typename T, typename B>
concept can_bind = requires(T&& t) {
  { t.B::mColumnIterator };
};
 
template <typename... C>
concept has_index = (is_indexing_column<C> || ...);
 
template <typename T>
using is_dynamic_t = std::conditional_t<is_dynamic_column<T>, std::true_type, std::false_type>;
 
template <typename T>
using is_indexing_t = std::conditional_t<is_indexing_column<T>, std::true_type, std::false_type>;
 
template <typename T>
concept has_parent_t = not_void<typename T::parent_t>;
 
template <typename T>
concept is_metadata_trait = requires(T t) { t.isMetadataTrait(); };
 
template <typename T>
concept is_metadata = requires(T t) { t.isTableMetadata(); };
 
template <typename T>
concept has_metadata = is_metadata<typename std::decay_t<T>::metadata>;
 
template <typename T>
concept has_extension = is_metadata<T> && not_void<typename std::decay_t<T>::extension_table_t>;
 
template <typename T>
concept has_configurable_extension = has_extension<T> && requires(T t) { typename std::decay_t<T>::configurable_t; requires std::same_as<std::true_type, typename std::decay_t<T>::configurable_t>; };
 
template <typename T>
concept is_table = requires(T t) { t.isSOATable(); };
 
template <typename T>
concept is_iterator = requires(T t) { t.isTableIterator(); };
 
template <typename T>
concept is_table_or_iterator = is_table<T> || is_iterator<T>;
 
template <typename T>
concept is_index_table = requires(T t) {
  t.isIndexTable();
};
 
template <typename T>
concept has_filtered_policy = not_void<typename std::decay_t<T>::policy_t> && requires { std::decay_t<T>::policy_t::isFilteredIndexPolicy(); };
 
template <typename T>
concept is_filtered_iterator = is_iterator<T> && has_filtered_policy<T>;
 
template <typename T>
concept is_not_filtered_iterator = is_iterator<T> && !has_filtered_policy<T>;
 
template <typename T>
concept is_filtered_table = requires(T t) { t.isFilteredBase(); };
 
template <typename T>
concept is_filtered = is_filtered_table<T> || is_filtered_iterator<T>;
 
template <typename T>
concept is_not_filtered_table = is_table<T> && !is_filtered_table<T>;
 
template <typename T>
concept is_join = requires(T t) { t.isJoin(); };
 
template <typename T>
concept is_enumerated_iterator = requires(T t) { t.globalIndex(); };
 
template <typename T>
concept with_originals = requires {
  T::originals.size();
};
 
template <typename T>
concept with_sources = requires {
  T::sources.size();
};
 
template <typename T>
concept with_sources_generator = requires(T t) {
  t.generateSources();
};
 
template <typename T>
concept with_ccdb_urls = requires(T t) {
  t.ccdb_urls.size();
};
 
template <typename T>
concept with_base_table = with_originals<T> && has_metadata<aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>> && requires {
  typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata::base_table_t;
};
 
template <typename T>
concept with_base_table_ng = not_void<typename T::base_table_t>; // redicrection should be done at the check site
 
template <typename T>
concept with_expression_pack = requires {
  typename T::expression_pack_t{};
};
 
template <typename T>
concept with_index_pack = requires {
  typename T::index_pack_t{};
};
 
template <typename T>
concept is_smallgroups = requires(T t) { t.isSmallGroups(); };
} // namespace o2::soa
 
namespace o2::framework
{
template <typename T>
concept is_preslice_policy = requires(T t) { t.isPreslicePolicy(); };
 
template <typename T>
concept is_preslice = requires(T t) { t.isPresliceContainer(); };
 
template <typename T>
concept is_preslice_group = requires(T t) { t.isPresliceGroup(); };
 
template <typename T>
concept is_producable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>> || soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::parent_t::ref.desc_hash>>>;
 
template <typename T>
concept is_produces = requires(T t) { typename T::cursor_t; typename T::persistent_table_t; &T::cursor; };
 
template <typename T>
concept is_produces_group = requires(T t) { t.isProducesGroup(); };
 
template <typename T>
concept is_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>> && soa::has_extension<typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata>;
 
template <typename T>
concept is_dynamically_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>> && soa::has_configurable_extension<typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata>;
 
template <typename T>
concept is_spawns = requires(T t) {
  typename T::metadata;
  typename T::expression_pack_t;
  t.projector.get();
};
 
template <typename T>
concept is_defines = requires(T t) {
  typename T::metadata;
  typename T::placeholders_pack_t;
  t.projector.get();
  requires std::same_as<decltype(t.needRecompilation), bool>;
  t.recompile();
};
 
template <typename T>
concept is_builds = requires(T t) {
  typename T::metadata;
  typename T::Key;
  t.map.size();
};
 
template <typename T>
concept is_outputobj = requires(T t) {
  &T::setHash;
  &T::spec;
  &T::ref;
  requires std::same_as<decltype(t.operator->()), typename T::obj_t*>;
  requires std::same_as<decltype(t.object.get()), typename T::obj_t*>;
};
 
template <typename T>
concept is_service = requires(T t) {
  requires std::same_as<decltype(t.service), typename T::service_t*>;
  &T::operator->;
};
 
template <typename T>
concept is_partition = requires(T t) {
  &T::updatePlaceholders;
  t.mFiltered.get();
  &T::operator->;
  requires std::same_as<decltype(t.dataframeChanged), bool>;
  t.begin();
  t.end();
  t.size();
};
} // namespace o2::framework
 
#endif // O2_FRAMEWORK_CONCEPTS_H