Extendable.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Extendable.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2016-2018 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 http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Utilities/detail/MPL/all_of.hpp"

#include <tuple>
#include <type_traits>

namespace Acts {

namespace detail {

template <typename... extensions_t>
struct Extendable {
  // clang-format off
    static_assert(detail::all_of_v<std::is_default_constructible<extensions_t>::value...>,
                  "all extensions must be default constructible");
    static_assert(detail::all_of_v<std::is_copy_constructible<extensions_t>::value...>,
                  "all extensions must be copy constructible");
    static_assert(detail::all_of_v<std::is_move_constructible<extensions_t>::value...>,
                  "all extensions must be move constructible");
  // clang-format on

  Extendable() = default;

  Extendable(const Extendable<extensions_t...>& extendable) = default;

  // Default move constructor
  Extendable(Extendable<extensions_t...>&& extendable) = default;

  Extendable(const std::tuple<extensions_t...>& extensions)
      : m_extensions(extensions) {}

  Extendable(std::tuple<extensions_t...>&& extensions)
      : m_extensions(std::move(extensions)) {}

  Extendable<extensions_t...>& operator=(
      const Extendable<extensions_t...>& extendable) = default;

  Extendable<extensions_t...>& operator=(
      Extendable<extensions_t...>&& extendable) = default;

  template <typename... appendices_t>
  Extendable<extensions_t..., appendices_t...> append(
      appendices_t... aps) const {
    auto catTuple =
        std::tuple_cat(m_extensions, std::tuple<appendices_t...>(aps...));
    return Extendable<extensions_t..., appendices_t...>(std::move(catTuple));
  }

  template <typename extension_t>
  const extension_t& get() const {
    return std::get<extension_t>(m_extensions);
  }

  template <typename extension_t>
  extension_t& get() {
    return std::get<extension_t>(m_extensions);
  }

  const std::tuple<extensions_t...>& tuple() const { return m_extensions; }

  std::tuple<extensions_t...>& tuple() { return m_extensions; }

 private:
  std::tuple<extensions_t...> m_extensions;
};

}  // namespace detail
}  // namespace Acts