utils.h

Go to the documentation of this file.

// BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
 
#ifndef AWKWARD_CPP_HEADERS_UTILS_H_
#define AWKWARD_CPP_HEADERS_UTILS_H_
 
#include <iterator>
#include <iostream>
#include <complex>
#include <type_traits>
#include <cassert>
#include <utility>
#include <stdexcept>
#include <stdint.h>
 
namespace awkward {
 
  template <typename T>
  const std::string
  type_to_name() {
    std::cout << "Type " << typeid(T).name() << " is not recognized." << std::endl;
    return typeid(T).name();
  }
 
  template <>
  const std::string
  type_to_name<bool>() {
    return "bool";
  }
 
  template <>
  const std::string
  type_to_name<int8_t>() {
    return "int8";
  }
 
  template <>
  const std::string
  type_to_name<int16_t>() {
    return "int16";
  }
 
  template <>
  const std::string
  type_to_name<int32_t>() {
    return "int32";
  }
 
  template <>
  const std::string
  type_to_name<int64_t>() {
    return "int64";
  }
 
  template <>
  const std::string
  type_to_name<Long64_t>() {
    return "int64";
  }
 
  template <>
  const std::string
  type_to_name<uint8_t>() {
    return "uint8";
  }
 
  template <>
  const std::string
  type_to_name<uint16_t>() {
    return "uint16";
  }
 
  template <>
  const std::string
  type_to_name<uint32_t>() {
    return "uint32";
  }
 
  template <>
  const std::string
  type_to_name<uint64_t>() {
    return "uint64";
  }
 
  template <>
  const std::string
  type_to_name<float>() {
    return "float32";
  }
 
  template <>
  const std::string
  type_to_name<double>() {
    return "float64";
  }
 
  template <>
  const std::string
  type_to_name<char>() {
    return "char";
  }
 
  template <>
  const std::string
  type_to_name<std::complex<float>>() {
    return "complex64";
  }
 
  template <>
  const std::string
  type_to_name<std::complex<double>>() {
    return "complex128";
  }
 
  template <typename T>
  const std::string
  type_to_numpy_like() {
    return type_to_name<T>();
  }
 
  template <>
  const std::string
  type_to_numpy_like<uint8_t>() {
    return "u8";
  }
 
  template <>
  const std::string
  type_to_numpy_like<int8_t>() {
    return "i8";
  }
 
  template <>
  const std::string
  type_to_numpy_like<uint32_t>() {
    return "u32";
  }
 
  template <>
  const std::string
  type_to_numpy_like<int32_t>() {
    return "i32";
  }
 
  template <>
  const std::string
  type_to_numpy_like<int64_t>() {
    return "i64";
  }
 
  template <typename, typename = void>
  constexpr bool is_iterable{};
 
  // FIXME:
  // std::void_t is part of C++17, define it ourselves until we switch to it
  template <typename...>
  struct voider {
    using type = void;
  };
 
  template <typename... T>
  using void_t = typename voider<T...>::type;
 
  template <typename T>
  constexpr bool is_iterable<T,
                             void_t<decltype(std::declval<T>().begin()),
                                    decltype(std::declval<T>().end())>> = true;
 
  template <typename Test, template <typename...> class Ref>
  struct is_specialization : std::false_type {};
 
  template <template <typename...> class Ref, typename... Args>
  struct is_specialization<Ref<Args...>, Ref> : std::true_type {};
 
  template <typename T>
  std::string
  type_to_form(int64_t form_key_id) {
    if (std::string(typeid(T).name()).find("awkward") != std::string::npos) {
      return std::string("awkward type");
    }
 
    std::stringstream form_key;
    form_key << "node" << (form_key_id++);
 
    if (std::is_arithmetic<T>::value) {
      std::string parameters(type_to_name<T>() + "\", ");
      if (std::is_same<T, char>::value) {
        parameters = std::string(
            "uint8\", \"parameters\": { \"__array__\": \"char\" }, ");
      }
      return "{\"class\": \"NumpyArray\", \"primitive\": \"" + parameters +
             "\"form_key\": \"" + form_key.str() + "\"}";
    } else if (is_specialization<T, std::complex>::value) {
      return "{\"class\": \"NumpyArray\", \"primitive\": \"" +
             type_to_name<T>() + "\", \"form_key\": \"" + form_key.str() +
             "\"}";
    }
 
    typedef typename T::value_type value_type;
 
    if (is_iterable<T>) {
      std::string parameters("");
      if (std::is_same<value_type, char>::value) {
        parameters =
            std::string(" \"parameters\": { \"__array__\": \"string\" }, ");
      }
      return "{\"class\": \"ListOffsetArray\", \"offsets\": \"i64\", "
             "\"content\":" +
             type_to_form<value_type>(form_key_id) + ", " + parameters +
             "\"form_key\": \"" + form_key.str() + "\"}";
    }
    return "unsupported type";
  }
 
  template <typename T>
  bool
  is_awkward_type() {
    return (std::string(typeid(T).name()).find("awkward") != std::string::npos);
  }
 
  template <size_t INDEX>
  struct visit_impl {
    template <typename CONTENT, typename FUNCTION>
    static void
    visit(CONTENT& contents, size_t index, FUNCTION fun) {
      if (index == INDEX - 1) {
        fun(std::get<INDEX - 1>(contents));
      } else {
        visit_impl<INDEX - 1>::visit(contents, index, fun);
      }
    }
  };
 
  template <>
  struct visit_impl<0> {
    template <typename CONTENT, typename FUNCTION>
    static void
    visit(CONTENT& /* contents */, size_t /* index */, FUNCTION /* fun */) {
      assert(false);
    }
  };
 
  template <typename FUNCTION, typename... CONTENTs>
  void
  visit_at(std::tuple<CONTENTs...> const& contents, size_t index, FUNCTION fun) {
    visit_impl<sizeof...(CONTENTs)>::visit(contents, index, fun);
  }
 
  template <typename FUNCTION, typename... CONTENTs>
  void
  visit_at(std::tuple<CONTENTs...>& contents, size_t index, FUNCTION fun) {
    visit_impl<sizeof...(CONTENTs)>::visit(contents, index, fun);
  }
 
}  // namespace awkward
 
#endif  // AWKWARD_CPP_HEADERS_UTILS_H_