Centralized enum and mode string conversion - single source of truth. More...

Data Structures
struct	mode_descriptor_t
	Mode descriptor for string conversion. More...

Functions
const char *	asciichat_mode_to_string (asciichat_mode_t mode)

asciichat_mode_t	asciichat_string_to_mode (const char *str)

bool	asciichat_is_valid_mode_string (const char *str)

size_t	asciichat_get_all_mode_strings (const char ***out_names)

const char *	asciichat_suggest_mode (const char *input)

const char *	color_mode_to_string (terminal_color_mode_t mode)

const char *	render_mode_to_string (render_mode_t mode)

const char *	palette_type_to_string (palette_type_t type)

const char *	asciichat_suggest_enum_value (const char option_name, const char input)

Detailed Description

Centralized enum and mode string conversion - single source of truth.

This module provides bidirectional conversion between enums and strings:

Mode enum ↔ mode string ("server", "client", "mirror", etc.)
Option enum values ↔ string values ("auto", "none", "16", etc.)
Fuzzy matching suggestions via levenshtein distance

All mode and enum string conversions should use this module.

Definition in file options/strings.c.

Function Documentation

◆ asciichat_get_all_mode_strings()

size_t asciichat_get_all_mode_strings ( const char *** out_names )

Definition at line 85 of file options/strings.c.

                                                               {
  static const char *names[32]; // Max 32 modes
  size_t count = 0;
 
  for (size_t i = 0; mode_registry[i].name != NULL && count < 32; i++) {
    // Skip duplicates (like "acds" alias)
    bool duplicate = false;
    for (size_t j = 0; j < count; j++) {
      if (strcmp(names[j], mode_registry[i].name) == 0) {
        duplicate = true;
        break;
      }
    }
    if (!duplicate) {
      names[count++] = mode_registry[i].name;
    }
  }
 
  if (out_names) {
    *out_names = names;
  }
  return count;
}

References mode_descriptor_t::name.

Referenced by asciichat_suggest_mode().

◆ asciichat_is_valid_mode_string()

bool asciichat_is_valid_mode_string ( const char * str )

Definition at line 81 of file options/strings.c.

                                                     {
  return asciichat_string_to_mode(str) != MODE_INVALID;
}

References asciichat_string_to_mode().

◆ asciichat_mode_to_string()

const char * asciichat_mode_to_string ( asciichat_mode_t mode )

Definition at line 53 of file options/strings.c.

                                                            {
  // Special case: MODE_DISCOVERY is the default mode, show as "default" to users
  if (mode == MODE_DISCOVERY) {
    return "default";
  }
 
  for (size_t i = 0; mode_registry[i].name != NULL; i++) {
    if (mode_registry[i].mode == mode) {
      return mode_registry[i].name;
    }
  }
  return "unknown";
}

References mode_descriptor_t::name.

◆ asciichat_string_to_mode()

asciichat_mode_t asciichat_string_to_mode ( const char * str )

Definition at line 67 of file options/strings.c.

                                                           {
  if (!str) {
    return MODE_INVALID;
  }
 
  for (size_t i = 0; mode_registry[i].name != NULL; i++) {
    if (strcmp(mode_registry[i].name, str) == 0) {
      return mode_registry[i].mode;
    }
  }
 
  return MODE_INVALID;
}

References mode_descriptor_t::mode, and mode_descriptor_t::name.

Referenced by asciichat_is_valid_mode_string().

◆ asciichat_suggest_enum_value()

const char * asciichat_suggest_enum_value	(	const char *	option_name,
		const char *	input
	)

Definition at line 192 of file options/strings.c.

                                                                                     {
  if (!option_name || !input) {
    return NULL;
  }
 
  size_t value_count = 0;
  const char **values = options_get_enum_values(option_name, &value_count);
 
  if (!values || value_count == 0) {
    return NULL;
  }
 
  // Create NULL-terminated array for levenshtein_find_similar
  static const char *null_terminated[64]; // Max 64 enum values
  for (size_t i = 0; i < value_count && i < 63; i++) {
    null_terminated[i] = values[i];
  }
  null_terminated[value_count] = NULL;
 
  return levenshtein_find_similar(input, null_terminated);
}

References levenshtein_find_similar(), and options_get_enum_values().

Referenced by parse_color_mode(), parse_palette_type(), and parse_render_mode().

◆ asciichat_suggest_mode()

const char * asciichat_suggest_mode ( const char * input )

Definition at line 109 of file options/strings.c.

                                                      {
  if (!input) {
    return NULL;
  }
 
  const char **names = NULL;
  size_t count = asciichat_get_all_mode_strings(&names);
 
  // Create NULL-terminated array for levenshtein_find_similar
  static const char *null_terminated[33]; // Max 32 modes + NULL
  for (size_t i = 0; i < count && i < 32; i++) {
    null_terminated[i] = names[i];
  }
  null_terminated[count] = NULL;
 
  return levenshtein_find_similar(input, null_terminated);
}

References asciichat_get_all_mode_strings(), and levenshtein_find_similar().

◆ color_mode_to_string()

const char * color_mode_to_string ( terminal_color_mode_t mode )

Definition at line 131 of file options/strings.c.

                                                             {
  switch (mode) {
  case TERM_COLOR_AUTO:
    return "auto";
  case TERM_COLOR_NONE:
    return "none";
  case TERM_COLOR_16:
    return "16";
  case TERM_COLOR_256:
    return "256";
  case TERM_COLOR_TRUECOLOR:
    return "truecolor";
  default:
    return "unknown";
  }
}

Referenced by session_display_render_help().

◆ palette_type_to_string()

const char * palette_type_to_string ( palette_type_t type )

Definition at line 169 of file options/strings.c.

                                                        {
  switch (type) {
  case PALETTE_STANDARD:
    return "standard";
  case PALETTE_BLOCKS:
    return "blocks";
  case PALETTE_DIGITAL:
    return "digital";
  case PALETTE_MINIMAL:
    return "minimal";
  case PALETTE_COOL:
    return "cool";
  case PALETTE_CUSTOM:
    return "custom";
  default:
    return "unknown";
  }
}

◆ render_mode_to_string()

const char * render_mode_to_string ( render_mode_t mode )

Definition at line 152 of file options/strings.c.

                                                      {
  switch (mode) {
  case RENDER_MODE_FOREGROUND:
    return "foreground";
  case RENDER_MODE_BACKGROUND:
    return "background";
  case RENDER_MODE_HALF_BLOCK:
    return "half-block";
  default:
    return "unknown";
  }
}