schema.c File Reference

Schema metadata registry for config file options. More...

Go to the source code of this file.

Functions
asciichat_error_t	config_schema_build_from_configs (const options_config_t **configs, size_t num_configs)
const config_option_metadata_t *	config_schema_get_by_toml_key (const char *toml_key)
const config_option_metadata_t **	config_schema_get_by_category (const char *category, size_t *count)
const config_option_metadata_t *	config_schema_get_all (size_t *count)
void	config_schema_destroy (void)

Detailed Description

Schema metadata registry for config file options.

Definition in file schema.c.

Function Documentation

config_schema_build_from_configs()

asciichat_error_t config_schema_build_from_configs	(	const options_config_t **	configs,
		size_t	num_configs
	)

Definition at line 242 of file schema.c.

                                                                                                         {
  // Free existing dynamic schema if any
  if (g_dynamic_schema) {
    SAFE_FREE(g_dynamic_schema);
    g_dynamic_schema = NULL;
    g_dynamic_schema_count = 0;
  }
 
  // Free existing string storage
  if (g_dynamic_strings) {
    for (size_t i = 0; i < g_dynamic_strings_count; i++) {
      SAFE_FREE(g_dynamic_strings[i]);
    }
    SAFE_FREE(g_dynamic_strings);
    g_dynamic_strings = NULL;
    g_dynamic_strings_count = 0;
    g_dynamic_strings_capacity = 0;
  }
 
  // Count total unique descriptors (by offset) across all configs
  // Use a simple approach: collect all descriptors, then deduplicate by offset
  const option_descriptor_t *all_descriptors[256] = {0}; // Max expected options
  size_t descriptor_count = 0;
 
  // Collect descriptors from all configs
  for (size_t cfg_idx = 0; cfg_idx < num_configs; cfg_idx++) {
    const options_config_t *config = configs[cfg_idx];
    if (!config) {
      continue;
    }
 
    for (size_t i = 0; i < config->num_descriptors && descriptor_count < 256; i++) {
      const option_descriptor_t *desc = &config->descriptors[i];
      if (should_add_descriptor(desc, all_descriptors, descriptor_count)) {
        all_descriptors[descriptor_count++] = desc;
      }
    }
  }
 
  // Allocate schema array
  g_dynamic_schema = SAFE_MALLOC(descriptor_count * sizeof(config_option_metadata_t), config_option_metadata_t *);
  if (!g_dynamic_schema) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate dynamic schema");
  }
 
  // Build schema entries
  g_dynamic_schema_count = 0;
  char toml_key_buffer[BUFFER_SIZE_SMALL];
  char cli_flag_buffer[256];
  char category_buffer[64];
 
  for (size_t i = 0; i < descriptor_count; i++) {
    const option_descriptor_t *desc = all_descriptors[i];
    if (!desc || !desc->long_name || !desc->group) {
      continue;
    }
 
    config_option_metadata_t *meta = &g_dynamic_schema[g_dynamic_schema_count++];
    // Zero-initialize the metadata struct to ensure all fields are initialized
    memset(meta, 0, sizeof(*meta));
 
    // Use builder's type directly
    meta->type = desc->type;
 
    // Generate category: lowercase the group name from builder
    SAFE_STRNCPY(category_buffer, desc->group, sizeof(category_buffer) - 1);
    category_buffer[sizeof(category_buffer) - 1] = '\0';
    str_tolower(category_buffer);
 
    // Generate TOML key: "category.field_name" (category is lowercase group, field_name is long_name with
    // dashes->underscores)
    if (!generate_toml_key(category_buffer, desc->long_name, toml_key_buffer, sizeof(toml_key_buffer))) {
      g_dynamic_schema_count--; // Skip this entry
      continue;
    }
 
    // Store generated strings (allocate and store)
    meta->toml_key = store_dynamic_string(toml_key_buffer);
    meta->category = store_dynamic_string(category_buffer);
    if (!meta->toml_key || !meta->category) {
      // Failed to allocate strings, skip this entry
      g_dynamic_schema_count--;
      continue;
    }
 
    // Generate CLI flag: "--long-name"
    if (generate_cli_flag(desc->long_name, cli_flag_buffer, sizeof(cli_flag_buffer))) {
      meta->cli_flag = store_dynamic_string(cli_flag_buffer);
      if (!meta->cli_flag) {
        // Failed to allocate, but continue (cli_flag can be NULL)
      }
    } else {
      meta->cli_flag = NULL;
    }
 
    // Set other fields
    meta->context = OPTION_CONTEXT_BOTH; // Most options can appear in both CLI and config
    meta->field_offset = desc->offset;
    meta->field_size = get_field_size(meta->type, desc->offset);
    // Use builder's validate function directly - it receives the full options struct
    meta->validate_fn = desc->validate;
    // Use builder's parse function for CALLBACK types
    meta->parse_fn = desc->parse_fn;
    meta->description = desc->help_text;
 
    // Set mode_bitmask from option descriptor
    // The descriptor should have mode_bitmask set from the registry
    meta->mode_bitmask = desc->mode_bitmask;
 
    // Copy mode_default_getter function pointer
    meta->mode_default_getter = desc->mode_default_getter;
 
    // Copy constraints from descriptor's metadata
    // For integer types, copy numeric_range to int_range (always copy, even if min is 0)
    memset(&meta->constraints, 0, sizeof(meta->constraints));
    // Always copy numeric_range if descriptor has it (check max or min)
    if (desc && desc->metadata.numeric_range.max > 0) {
      meta->constraints.int_range.min = desc->metadata.numeric_range.min;
      meta->constraints.int_range.max = desc->metadata.numeric_range.max;
    }
  }
 
  g_schema_built = true;
  return ASCIICHAT_OK;
}

Referenced by action_create_config(), and options_init().

config_schema_destroy()

void config_schema_destroy

(

void

)

Definition at line 446 of file schema.c.

                                 {
  if (!g_schema_built) {
    return; // Nothing to clean up
  }
 
  // Free all dynamically allocated strings (toml_key, cli_flag, category)
  if (g_dynamic_strings) {
    for (size_t i = 0; i < g_dynamic_strings_count; i++) {
      SAFE_FREE(g_dynamic_strings[i]);
    }
    SAFE_FREE(g_dynamic_strings);
    g_dynamic_strings = NULL;
    g_dynamic_strings_count = 0;
    g_dynamic_strings_capacity = 0;
  }
 
  // Free the schema array itself
  if (g_dynamic_schema) {
    SAFE_FREE(g_dynamic_schema);
    g_dynamic_schema = NULL;
    g_dynamic_schema_count = 0;
  }
 
  g_schema_built = false;
}

Referenced by options_cleanup_schema(), and options_state_destroy().

config_schema_get_all()

const config_option_metadata_t * config_schema_get_all

(

size_t *

count

)

Definition at line 426 of file schema.c.

                                                                     {
  // Schema must be built before use
  if (!g_schema_built || !g_dynamic_schema) {
    if (count) {
      *count = 0;
    }
    SET_ERRNO(ERROR_INVALID_STATE, "Schema not built");
    return NULL;
  }
 
  if (count) {
    *count = g_dynamic_schema_count;
  }
  return g_dynamic_schema;
}

Referenced by config_create_default().

config_schema_get_by_category()

const config_option_metadata_t ** config_schema_get_by_category	(	const char *	category,
		size_t *	count
	)

Definition at line 393 of file schema.c.

                                                                                                    {
  static const config_option_metadata_t *results[64]; // Max options per category
  size_t result_count = 0;
 
  if (!category) {
    if (count) {
      *count = 0;
    }
    return NULL;
  }
 
  // Schema must be built before use
  if (!g_schema_built || !g_dynamic_schema) {
    if (count) {
      *count = 0;
    }
    SET_ERRNO(ERROR_INVALID_STATE, "Schema not built");
    return NULL;
  }
 
  for (size_t i = 0; i < g_dynamic_schema_count && result_count < 64; i++) {
    if (g_dynamic_schema[i].category && strcmp(g_dynamic_schema[i].category, category) == 0) {
      results[result_count++] = &g_dynamic_schema[i];
    }
  }
 
  if (count) {
    *count = result_count;
  }
 
  return (result_count > 0) ? results : NULL;
}

Referenced by config_create_default().

config_schema_get_by_toml_key()

const config_option_metadata_t * config_schema_get_by_toml_key

(

const char *

toml_key

)

Definition at line 372 of file schema.c.

                                                                                    {
  if (!toml_key) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid arguments for config_schema_get_by_toml_key");
    return NULL;
  }
 
  // Schema must be built before use
  if (!g_schema_built || !g_dynamic_schema) {
    SET_ERRNO(ERROR_INVALID_STATE, "Schema not built");
    return NULL;
  }
 
  for (size_t i = 0; i < g_dynamic_schema_count; i++) {
    if (g_dynamic_schema[i].toml_key && strcmp(g_dynamic_schema[i].toml_key, toml_key) == 0) {
      return &g_dynamic_schema[i];
    }
  }
 
  return NULL;
}