meta_functions.h

Go to the documentation of this file.

//  NIST-developed software is provided by NIST as a public service. You may use, copy and distribute copies of the
//  software in any medium, provided that you keep intact this entire notice. You may improve, modify and create
//  derivative works of the software or any portion of the software, and you may copy and distribute such modifications
//  or works. Modified works should carry a notice stating that you changed the software and should note the date and
//  nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the
//  source of the software. NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND,
//  EXPRESS, IMPLIED, IN FACT OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR
//  WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE
//  CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS
//  THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE. You
//  are solely responsible for determining the appropriateness of using and distributing the software and you assume
//  all risks associated with its use, including but not limited to the risks and costs of program errors, compliance
//  with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of
//  operation. This software is not intended to be used in any situation where a failure could cause risk of injury or
//  damage to property. The software developed by NIST employees is not subject to copyright protection within the
//  United States.
 
 
 
#ifndef HEDGEHOG_META_FUNCTIONS_H
#define HEDGEHOG_META_FUNCTIONS_H
 
#pragma once
#include <iostream>
#include <tuple>
 
//todo clean code
 
namespace hh {
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace core {
namespace abstraction {
 
template<class Input>
class ReceiverAbstraction;
 
template<class Output>
class SenderAbstraction;
}
}
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
namespace tool {
 
namespace internals {
 
template<typename Ts, typename T>
struct PushFront;
 
template<typename... Vs, typename T>
struct PushFront<std::tuple<Vs...>, T> {
  using Type = std::tuple<T, Vs...>;
};
 
template<typename Ts, typename T>
using PushFront_t = typename PushFront<Ts, T>::Type;
 
template<typename Types, typename Indices>
struct SplitInput;
 
template<typename Types, size_t... Indices>
struct SplitInput<Types, std::index_sequence<Indices...>> {
  using Type = std::tuple<std::tuple_element_t<Indices, Types>...>;
};
 
template<typename Types, typename Indices>
using SplitInput_t = typename SplitInput<Types, Indices>::Type;
 
template<typename Types, size_t delta, typename Indices>
struct SplitOutput;
 
template<typename Types, size_t delta, size_t... Indices>
struct SplitOutput<Types, delta, std::index_sequence<Indices...>> {
  using Type = std::tuple<std::tuple_element_t<delta + Indices, Types>...>;
};
 
template<typename Types, size_t delta, typename Indices>
using SplitOutput_t = typename SplitOutput<Types, delta, Indices>::Type;
 
template<size_t delimiter, typename ... Types>
struct Splitter {
  static_assert(delimiter != 0, "The delimiter should not be 0.");
  static_assert(delimiter < sizeof...(Types), "The delimiter should be inferior to the number of types.");
 
  using Inputs = internals::SplitInput_t<std::tuple<Types...>, std::make_integer_sequence<size_t, delimiter>>;
 
  using Outputs = internals::SplitOutput_t<std::tuple<Types...>,
                                           delimiter,
                                           std::make_integer_sequence<size_t, sizeof...(Types) - delimiter>>;
};
 
template<typename T, typename Tuple>
struct HasType;
 
template<typename T>
struct HasType<T, std::tuple<>> : std::false_type {};
 
template<typename T, typename Front, typename... Ts>
struct HasType<T, std::tuple<Front, Ts...>> : HasType<T, std::tuple<Ts...>> {};
 
template<typename T, typename... Ts>
struct HasType<T, std::tuple<T, Ts...>> : std::true_type {};
 
template<typename T1, typename T2, size_t Index, size_t Size>
struct IntersectImpl;
 
template<typename T1, typename T2, size_t Size>
struct IntersectImpl<T1, T2, Size, Size> {
  using type = std::tuple<>;
};
 
template<typename T1, typename T2, size_t Index, size_t Size>
struct IntersectImpl {
  using type = std::conditional_t<
      internals::HasType<std::tuple_element_t<Index, T1>, T2>::value,
      internals::PushFront_t<typename IntersectImpl<T1, T2, Index + 1, Size>::type, std::tuple_element_t<Index, T1>>,
      typename IntersectImpl<T1, T2, Index + 1, Size>::type>;
};
 
template<typename T1, typename T2>
struct Intersect {
  using type = typename IntersectImpl<T1, T2, 0, std::tuple_size_v<T1>>::type;
};
}
 
template<size_t delta, typename ... Types>
using Inputs = typename internals::Splitter<delta, Types...>::Inputs;
 
template<size_t delta, typename ... Types>
using Outputs = typename internals::Splitter<delta, Types...>::Outputs;
 
template<class Tuple1, class Tuple2>
using Intersect_t = typename internals::Intersect<Tuple1, Tuple2>::type;
 
template<class T, class ...Ts>
constexpr bool isContainedIn_v = std::disjunction_v<std::is_same<T, Ts>...>;
 
template<class T, class Tuple>
constexpr bool isContainedInTuple_v = std::tuple_size_v<Intersect_t<std::tuple<T>, Tuple>> == 1;
 
template<typename T>
constexpr auto typeToStrView() {
  std::string_view name, prefix, suffix;
#ifdef __clang__
  name = __PRETTY_FUNCTION__;
  prefix = "auto hh::tool::typeToStr() [T = ";
  suffix = "]";
#elif defined(__GNUC__)
  name = __PRETTY_FUNCTION__;
  prefix = "constexpr auto hh::tool::typeToStrView() [with T = ";
  suffix = "]";
#elif defined(_MSC_VER)
  name = __FUNCSIG__;
    prefix = "auto __cdecl typeToStr<";
    suffix = ">(void)";
#endif
  name.remove_prefix(prefix.size());
  name.remove_suffix(suffix.size());
 
  return name;
}
 
template<typename T>
constexpr auto typeToStr() { return std::string(typeToStrView<T>()); }
 
}
}
 
#endif //HEDGEHOG_META_FUNCTIONS_H