param_oneof.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include "param_oneof.h"
#include "param_internal.h"
#include "utils_common.h"
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdint.h>
 
struct yac_param_oneof {
  const struct yac_param_vtable *vtable;
  char *name;
  void **obj; // user object for the subparameter
  struct yac_param *subparam;
  int is_default;
  int is_defined; // 0 if not set, 1 if set
  yac_param_oneof_factory_ptr default_factory;
};
 
static enum yac_param_type
yac_param_oneof_get_type(
  const struct yac_param *param) {
 
  UNUSED(param);
  return YAC_PARAM_TYPE_STRUCT;
}
 
static int yac_param_oneof_is_default(
  const struct yac_param *param) {
 
  const struct yac_param_oneof *self =
    (const struct yac_param_oneof *)param;
  return (!self->is_defined) ||
         (self->is_default &&
          yac_param_is_default(self->subparam));
}
 
static const char *yac_param_oneof_get_name(
  const struct yac_param *param) {
  const struct yac_param_oneof *self =
    (const struct yac_param_oneof *)param;
  return self->name;
}
 
static int yac_param_oneof_get_sub_count(
  const struct yac_param *param, size_t *count) {
  UNUSED(param);
  YAC_ASSERT(count, "count is NULL");
  *count = 1;
  return 0;
}
 
static int yac_param_oneof_get_sub_by_index(
  struct yac_param *param, size_t idx,
  struct yac_param **sub_param) {
 
  struct yac_param_oneof *self =
    (struct yac_param_oneof *)param;
  YAC_ASSERT(sub_param, "sub_param is NULL");
 
  *sub_param = NULL;
 
  YAC_PARAM_ASSERT(
    idx == 0,
    "idx out of bounds for oneof parameter");
 
  if (!self->is_defined) {
    int err = self->default_factory(
      NULL, self->obj, &self->subparam, &self->is_default);
    YAC_PARAM_ASSERT(
      err == 0, "failed to create default oneof subparameter");
    self->is_defined = 1;
  }
 
  *sub_param = self->subparam;
  return 0;
}
 
static int yac_param_oneof_get_sub_by_name(
  const struct yac_param *param, const char *name,
  struct yac_param **sub_param)
{
  struct yac_param_oneof *self =
    (struct yac_param_oneof *)param;
  YAC_ASSERT(name, "name is NULL");
  YAC_ASSERT(sub_param, "sub_param is NULL");
  // Only allow setting once
  if (self->is_defined) {
 
    YAC_PARAM_ASSERT(
      strcmp(name, yac_param_get_name(self->subparam)) == 0,
      "oneof parameter '%s' already set to '%s', cannot set to '%s'",
      self->name, yac_param_get_name(self->subparam),
      name);
  } else {
 
    // Not set yet, use factory to create subparam for the given name
    int err =
      self->default_factory(
        name, self->obj, &self->subparam, &self->is_default);
 
    YAC_PARAM_ASSERT(
      err == 0,
      "dynamic subparam with  name '%s' creation failed for "
      "paramter name '%s'", name, self->name);
    self->is_defined = 1;
  }
  *sub_param = self->subparam;
  return 0;
}
 
static void yac_param_oneof_delete(
  struct yac_param *param) {
 
  struct yac_param_oneof *self =
    (struct yac_param_oneof *)param;
  if (self->subparam)
    yac_param_delete(self->subparam);
  free(self->name);
  free(param);
}
 
static const struct yac_param_vtable
  yac_param_oneof_vtable = {
  .get_type = yac_param_oneof_get_type,
  .is_default = yac_param_oneof_is_default,
  .get_name = yac_param_oneof_get_name,
  .delete = yac_param_oneof_delete,
  .get_sub_count = yac_param_oneof_get_sub_count,
  .get_sub_by_name = yac_param_oneof_get_sub_by_name,
  .get_sub_by_index = yac_param_oneof_get_sub_by_index,
  .append = NULL,
  .set_scalar = NULL,
  .get_scalar = NULL,
  .get_scalar_kind = NULL,
  .set_scalar_int = NULL,
  .set_scalar_dble = NULL,
  .get_scalar_int = NULL,
  .get_scalar_dble = NULL
};
 
struct yac_param * yac_param_oneof_new(
  const char *name,
  yac_param_oneof_factory_ptr default_factory,
  void **value_ptr, struct yac_param *subparam,
  int subparam_is_default) {
 
  YAC_PARAM_CHECK_BASIC();
  YAC_ASSERT(default_factory, "default_factory is NULL");
  YAC_ASSERT(
    ((*value_ptr == NULL) && (subparam == NULL)) ||
      ((*value_ptr != NULL) && (subparam != NULL)),
    "subparam must be NULL if and only if *out_obj is NULL");
 
  struct yac_param_oneof *self =
    xmalloc(1 * sizeof(*self));
  self->vtable = &yac_param_oneof_vtable;
  self->name = xstrdup(name);
  self->obj = value_ptr;
  self->subparam = subparam;
  self->is_default = (*value_ptr != NULL) ? subparam_is_default : 0;
  self->is_defined = (*value_ptr != NULL);
  self->default_factory = default_factory;
  return (struct yac_param *)self;
}