object-introspection/types/std_variant.toml

[info]
type_name = "std::variant"
ctype = "STD_VARIANT_TYPE"
header = "variant"

# Old:
typeName = "std::variant"
ns = ["namespace std"]

[codegen]
decl = """
template<class... Types>
void getSizeType(const %1%<Types...> &container, size_t& returnArg);
"""

func = """
template<class... Types>
void getSizeType(const %1%<Types...> &container, size_t& returnArg)
{
  SAVE_SIZE(sizeof(%1%<Types...>));
  SAVE_DATA(container.index());

  // This check should be `container.valueless_by_exception()` but it doesn't
  // work with the variable sized integers used in `std::variant`. For fewer
  // than 256 options it uses a `uint8_t` index but checks against -1 of
  // `uintptr_t`. Manually check for any out of bounds indices as a workaround.
  if (container.index() >= sizeof...(Types)) {
    return;
  }

  std::visit([&returnArg](auto &&arg) {
    // Account for inline contents
    SAVE_SIZE(-sizeof(arg));
    getSizeType(arg, returnArg);
  }, container);
}
"""

scoped_extra = """
template <size_t I = 0>
static types::st::Unit<DB>
getSizeTypeRecursive(
    Ctx& ctx,
    const container_type& container,
    typename TypeHandler<Ctx, container_type>::type returnArg
) {
  if constexpr (I < sizeof...(Types)) {
    if (I == container.index()) {
      return returnArg.template delegate<I>([&ctx, &container](auto ret) {
        return OIInternal::getSizeType<Ctx>(ctx, std::get<I>(container), ret);
      });
    } else {
      return getSizeTypeRecursive<I+1>(ctx, container, returnArg);
    }
  } else {
    return returnArg.template delegate<sizeof...(Types)>(std::identity());
  }
}
"""

handler_header = """
template <typename Ctx, typename... Types>
struct TypeHandler<Ctx, std::variant<Types...>>
"""

traversal_func = """
return getSizeTypeRecursive(ctx, container, returnArg);
"""

[[codegen.processor]]
type = "types::st::Sum<DB, typename TypeHandler<Ctx, Types>::type..., types::st::Unit<DB>>"
func = """
static constexpr std::array<inst::Field, sizeof...(Types)> children{
  make_field<Ctx, Types>("*")...,
};

auto sum = std::get<ParsedData::Sum>(d.val);

el.container_stats = result::Element::ContainerStats {
  .capacity = 1,
  .length = sum.index == sizeof...(Types) ? 0u : 1u,
};

if (el.container_stats->length == 0)
  return;

el.exclusive_size -= children[sum.index].static_size;
stack_ins(children[sum.index]);
"""