param_enum.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include "param_enum.h"
#include "param_internal.h"
#include "utils_common.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <limits.h>
 
struct yac_param_enum {
  const struct yac_param_vtable *vtable;
  char *name;
  int *value_ptr;
  int default_value;
  struct yac_name_type_pair const *enum_table;
  size_t enum_table_size;
  int has_default;
  int is_defined;
};
 
static enum yac_param_type
yac_param_enum_get_type(
  const struct yac_param *param) {
  UNUSED(param);
  return YAC_PARAM_TYPE_SCALAR;
}
 
static int yac_param_enum_is_default(
  const struct yac_param *param) {
  const struct yac_param_enum *self =
    (const struct yac_param_enum *)param;
  if (!self->has_default) return 0;
  return *(self->value_ptr) == self->default_value;
}
 
static const char *yac_param_enum_get_name(
  const struct yac_param *param) {
  const struct yac_param_enum *self =
    (const struct yac_param_enum *)param;
  return self->name;
}
 
static int yac_param_enum_set_scalar_int(
  struct yac_param *param, int value) {
  struct yac_param_enum *self =
    (struct yac_param_enum *)param;
  // Check if value is valid in enum_table
  YAC_PARAM_ASSERT(
    yac_name_type_pair_get_name(
      self->enum_table, self->enum_table_size, value) != NULL,
    "value %d is not a valid enum for parameter '%s'", value, self->name);
  *(self->value_ptr) = value;
  self->is_defined = 1;
  return 0;
}
 
static int yac_param_enum_set_scalar(
  struct yac_param *param, const char *value_str) {
  struct yac_param_enum *self =
    (struct yac_param_enum *)param;
  YAC_PARAM_ASSERT(
    value_str,
    "No value provided for enum parameter '%s'", self->name);
  int value =
    yac_name_type_pair_get_type(
      self->enum_table, self->enum_table_size, value_str);
  YAC_PARAM_ASSERT(
    value != INT_MAX,
    "'%s' is not a valid enum name for parameter '%s'",
    value_str, self->name);
  *(self->value_ptr) = value;
  self->is_defined = 1;
  return 0;
}
 
static int yac_param_enum_get_scalar_int(
  const struct yac_param *param, int *value) {
  const struct yac_param_enum *self =
    (const struct yac_param_enum *)param;
  YAC_ASSERT(value, "value is NULL");
  YAC_PARAM_ASSERT(
    self->has_default || self->is_defined,
    "value for parameter '%s' is undefined, user must set it first",
    self->name);
  *value = *(self->value_ptr);
  return 0;
}
 
static int yac_param_enum_get_scalar(
  const struct yac_param *param, char *buf, size_t buflen) {
  const struct yac_param_enum *self =
    (const struct yac_param_enum *)param;
  YAC_PARAM_ASSERT(
    self->has_default || self->is_defined,
    "value for parameter '%s' is undefined, user must set it first",
    self->name);
  int value = *(self->value_ptr);
  const char *name =
    yac_name_type_pair_get_name(self->enum_table, self->enum_table_size, value);
  YAC_ASSERT_F(
    name, "value %d is not a valid enum for parameter '%s'", value, self->name);
  YAC_ASSERT(buf, "buf is NULL");
  int n = snprintf(buf, buflen, "%s", name);
  YAC_PARAM_ASSERT(
    (n >= 0) && ((size_t)n < buflen),
    "buffer too small for value '%s' of parameter '%s'", name, self->name);
  return 0;
}
 
static int yac_param_enum_get_scalar_kind(
  const struct yac_param *param,
  enum yac_param_scalar_kind *scalar_kind) {
  UNUSED(param);
  *scalar_kind = YAC_PARAM_SCALAR_KIND_INT;
  return 0;
}
 
static void yac_param_enum_delete(
  struct yac_param *param) {
  struct yac_param_enum *self =
    (struct yac_param_enum *)param;
  free(self->name);
  free(param);
}
 
static const struct yac_param_vtable
  yac_param_enum_vtable = {
  .get_type = yac_param_enum_get_type,
  .is_default = yac_param_enum_is_default,
  .get_name = yac_param_enum_get_name,
  .delete = yac_param_enum_delete,
  .get_sub_count = NULL,
  .get_sub_by_name = NULL,
  .get_sub_by_index = NULL,
  .append = NULL,
  .set_scalar = yac_param_enum_set_scalar,
  .get_scalar = yac_param_enum_get_scalar,
  .get_scalar_kind = yac_param_enum_get_scalar_kind,
  .set_scalar_int = yac_param_enum_set_scalar_int,
  .set_scalar_dble = NULL,
  .get_scalar_int = yac_param_enum_get_scalar_int,
  .get_scalar_dble = NULL
};
 
struct yac_param *yac_param_enum_new(
  const char *name, int *value_ptr, int default_value,
  struct yac_name_type_pair const *enum_table, size_t enum_table_size,
  int has_default, int is_defined) {
 
  YAC_PARAM_CHECK_BASIC();
  YAC_ASSERT(enum_table, "enum_table is NULL");
  YAC_ASSERT(enum_table_size > 0, "enum_table_size is 0");
  YAC_ASSERT_F(
    !has_default ||
    yac_name_type_pair_get_name(
      enum_table, enum_table_size, default_value),
    "default_value %d is not valid enum of parameter '%s'",
    default_value, name);
  YAC_ASSERT_F(
    !is_defined ||
    yac_name_type_pair_get_name(enum_table, enum_table_size, *value_ptr),
    "initial value %d is not valid enum of parameter '%s'",
    *value_ptr, name);
  struct yac_param_enum *self = xmalloc(1 * sizeof(*self));
  self->vtable = &yac_param_enum_vtable;
  self->name = xstrdup(name);
  self->value_ptr = value_ptr;
  self->default_value = default_value;
  self->enum_table = enum_table;
  self->enum_table_size = enum_table_size;
  self->has_default = has_default;
  self->is_defined = is_defined;
  return (struct yac_param *)self;
}