CbmYamlBaseTypes.h

Go to the documentation of this file.

/* Copyright (C) 2023-2025 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Felix Weiglhofer [committer] */
#ifndef CBM_YAML_BASETYPES_H
#define CBM_YAML_BASETYPES_H
#pragma once
 
#include <array>
#include <cstdint>
#include <map>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
// FIXME: move some of the variables to CbmTypeTraits.h
 
namespace cbm::util::yaml
{
  // typealias for Rust-like fixed size integer types
  using i8  = int8_t;
  using u8  = uint8_t;
  using i16 = int16_t;
  using u16 = uint16_t;
  using i32 = int32_t;
  using u32 = uint32_t;
  using i64 = int64_t;
  using u64 = uint64_t;
  using f32 = float;
  using f64 = double;
 
  // clang-format off
  using FundamentalTypes = std::tuple< bool
                                     , u8, i8
                                     , u16, i16
                                     , u32, i32
                                     , u64, i64
                                     , f32, f64
                                     , std::string
// Clang on macOS somehow treats unsigned long as a different type than uint64_t
#ifdef __APPLE__
                                      , unsigned long, long
#endif
                                      >;
  // clang-format on
 
  template<typename T, typename Tuple>
  struct has_type;
 
  template<typename T, typename... Us>
  struct has_type<T, std::tuple<Us...>> : std::disjunction<std::is_same<T, Us>...> {
  };
 
  template<typename T>
  constexpr bool IsFundamental = has_type<T, FundamentalTypes>::value;
 
  template<typename T>
  constexpr bool IsEnum = std::is_enum_v<T>;
 
  template<typename T>
  constexpr bool IsScalar = IsFundamental<T> || IsEnum<T>;
 
  template<typename T, typename = std::enable_if_t<IsFundamental<T>>>
  constexpr std::string_view Typename()
  {
    if constexpr (std::is_same_v<bool, T>) {
      return "bool";
    }
    else if constexpr (std::is_same_v<u8, T>) {
      return "u8";
    }
    else if constexpr (std::is_same_v<i8, T>) {
      return "i8";
    }
    else if constexpr (std::is_same_v<u16, T>) {
      return "u16";
    }
    else if constexpr (std::is_same_v<i16, T>) {
      return "i16";
    }
    else if constexpr (std::is_same_v<u32, T>) {
      return "u32";
    }
    else if constexpr (std::is_same_v<i32, T>) {
      return "i32";
    }
    else if constexpr (std::is_same_v<f32, T>) {
      return "f32";
    }
    else if constexpr (std::is_same_v<f64, T>) {
      return "f64";
    }
    else if constexpr (std::is_same_v<std::string, T>) {
      return "string";
    }
    else {
      return "unknown";
    }
  }
 
  template<typename>
  struct is_std_vector : std::false_type {
  };
 
  template<typename T, typename A>
  struct is_std_vector<std::vector<T, A>> : std::true_type {
  };
 
  template<typename T>
  constexpr bool IsVector = is_std_vector<T>::value;
 
  template<typename>
  struct is_std_array : std::false_type {
  };
 
  template<typename T, std::size_t N>
  struct is_std_array<std::array<T, N>> : std::true_type {
  };
 
  template<typename T>
  constexpr bool IsArray = is_std_array<T>::value;
 
  template<typename>
  struct is_std_map : std::false_type {
  };
 
  template<typename K, typename V, typename C, typename A>
  struct is_std_map<std::map<K, V, C, A>> : std::true_type {
  };
 
  template<typename>
  struct is_std_unordered_map : std::false_type {
  };
 
  template<typename K, typename V, typename H, typename E, typename A>
  struct is_std_unordered_map<std::unordered_map<K, V, H, E, A>> : std::true_type {
  };
 
  template<typename T>
  constexpr bool IsMap = is_std_map<T>::value || is_std_unordered_map<T>::value;
 
  template<typename>
  struct is_std_set : std::false_type {
  };
 
  template<typename K, typename C, typename A>
  struct is_std_set<std::set<K, C, A>> : std::true_type {
  };
 
  template<typename>
  struct is_std_unordered_set : std::false_type {
  };
 
  template<typename K, typename H, typename E, typename A>
  struct is_std_unordered_set<std::unordered_set<K, H, E, A>> : std::true_type {
  };
 
  template<typename T>
  constexpr bool IsSet = is_std_set<T>::value || is_std_unordered_set<T>::value;
 
  template<typename>
  struct is_optional : std::false_type {
  };
 
  template<typename T>
  struct is_optional<std::optional<T>> : std::true_type {
  };
 
  template<typename T>
  constexpr bool IsOptional = is_optional<T>::value;
 
}  // namespace cbm::util::yaml
#endif  // CBM_YAML_BASETYPES_H