Proposal: Implement getval/setval types system while retaining backwards compatibility

[LimpingNinja]

Implementing Typed sys_getval/sys_setval Functions

Overview

This document outlines the implementation of enhanced sys_getval and sys_setval functions that support type-safe access to mudsettings while maintaining backward compatibility.

Current Limitations

• Only string access via mudsys.sys_getval(key) and mudsys.sys_setval(key, val)
• No type safety - can overwrite integer settings with strings
• No access to mudsettingGetInt(), mudsettingGetBool(), etc.

Proposed Enhancement

Add optional type parameter with string default:

• mudsys.sys_getval(key, type="string")
• mudsys.sys_setval(key, value, type="auto")

Implementation

1. Replace mudsys_get_sys_val in /src/scripts/pymudsys.c

PyObject *mudsys_get_sys_val(PyObject *self, PyObject *args) {
  char *key, *type = "string";  // default to string for backward compatibility
  
  if(!PyArg_ParseTuple(args, "s|s", &key, &type)) {
    PyErr_Format(PyExc_TypeError, "Provide a string key and optional type");
    return NULL;
  }

  if(strcmp(type, "int") == 0) {
    return Py_BuildValue("i", mudsettingGetInt(key));
  }
  else if(strcmp(type, "bool") == 0) {
    return Py_BuildValue("i", mudsettingGetBool(key) ? 1 : 0);
  }
  else if(strcmp(type, "double") == 0 || strcmp(type, "float") == 0) {
    return Py_BuildValue("d", mudsettingGetDouble(key));
  }
  else if(strcmp(type, "long") == 0) {
    return Py_BuildValue("l", mudsettingGetLong(key));
  }
  else if(strcmp(type, "string") == 0) {
    return Py_BuildValue("s", mudsettingGetString(key));
  }
  else {
    PyErr_Format(PyExc_ValueError, "Invalid type '%s'. Use: string, int, bool, double, long", type);
    return NULL;
  }
}

2. Replace mudsys_set_sys_val in /src/scripts/pymudsys.c

PyObject *mudsys_set_sys_val(PyObject *self, PyObject *args) {
  char *key, *type = "auto";
  PyObject *value;
  
  if(!PyArg_ParseTuple(args, "sO|s", &key, &value, &type)) {
    PyErr_Format(PyExc_TypeError, "Provide key, value, and optional type");
    return NULL;
  }

  // Auto-detect type if not specified
  if(strcmp(type, "auto") == 0) {
    if(PyLong_Check(value)) {
      type = "int";
    }
    else if(PyBool_Check(value)) {
      type = "bool";  
    }
    else if(PyFloat_Check(value)) {
      type = "double";
    }
    else if(PyUnicode_Check(value)) {
      type = "string";
    }
    else {
      PyErr_Format(PyExc_TypeError, "Cannot auto-detect type for value");
      return NULL;
    }
  }

  if(strcmp(type, "int") == 0) {
    if(!PyLong_Check(value)) {
      PyErr_Format(PyExc_TypeError, "Expected int value");
      return NULL;
    }
    mudsettingSetInt(key, (int)PyLong_AsLong(value));
  }
  else if(strcmp(type, "bool") == 0) {
    mudsettingSetBool(key, PyObject_IsTrue(value));
  }
  else if(strcmp(type, "double") == 0 || strcmp(type, "float") == 0) {
    if(!PyFloat_Check(value) && !PyLong_Check(value)) {
      PyErr_Format(PyExc_TypeError, "Expected float/double value");
      return NULL;
    }
    mudsettingSetDouble(key, PyFloat_AsDouble(value));
  }
  else if(strcmp(type, "long") == 0) {
    if(!PyLong_Check(value)) {
      PyErr_Format(PyExc_TypeError, "Expected long value");
      return NULL;
    }
    mudsettingSetLong(key, PyLong_AsLong(value));
  }
  else if(strcmp(type, "string") == 0) {
    if(!PyUnicode_Check(value)) {
      PyErr_Format(PyExc_TypeError, "Expected string value");
      return NULL;
    }
    const char *str_val = PyUnicode_AsUTF8(value);
    if(str_val == NULL) return NULL;
    mudsettingSetString(key, str_val);
  }
  else {
    PyErr_Format(PyExc_ValueError, "Invalid type '%s'. Use: string, int, bool, double, long", type);
    return NULL;
  }

  return Py_BuildValue("i", 1);
}

3. Update Method Documentation in PyInit_PyMudSys()

PyMudSys_addMethod("sys_getval", mudsys_get_sys_val, METH_VARARGS,
                   "sys_getval(name, type='string')\n"
                   "\n"
                   "Returns a value from system settings with optional type.\n"
                   "Types: 'string', 'int', 'bool', 'double', 'long'");

PyMudSys_addMethod("sys_setval", mudsys_set_sys_val, METH_VARARGS,
                   "sys_setval(name, value, type='auto')\n"
                   "\n"
                   "Sets a system setting value with optional type.\n"
                   "Types: 'string', 'int', 'bool', 'double', 'long', 'auto'");

Python Usage Examples

Backward Compatibility (unchanged)

import mudsys

# Still works exactly as before
port = mudsys.sys_getval("listening_port")  # Returns string "4000"
mudsys.sys_setval("mud_name", "My MUD")

New Typed Access

import mudsys

# Get values with proper types
port = mudsys.sys_getval("listening_port", "int")        # Returns int 4000
width = mudsys.sys_getval("screen_width", "int")         # Returns int 80
pulses = mudsys.sys_getval("pulses_per_second", "int")   # Returns int 4

# Set values with type safety
mudsys.sys_setval("listening_port", 4001, "int")         # Sets as integer
mudsys.sys_setval("screen_width", 120, "int")            # Sets as integer
mudsys.sys_setval("mud_name", "Enhanced MUD")            # Auto-detects string

# Boolean settings
mudsys.sys_setval("some_flag", True, "bool")             # Sets as boolean
flag = mudsys.sys_getval("some_flag", "bool")            # Returns boolean

# Auto-detection (recommended for setting)
mudsys.sys_setval("listening_port", 4002)                # Auto-detects int
mudsys.sys_setval("mud_name", "Auto MUD")                # Auto-detects string
mudsys.sys_setval("enable_feature", False)               # Auto-detects bool

Error Handling

try:
    # This will raise TypeError if value is wrong type
    mudsys.sys_setval("listening_port", "not_a_number", "int")
except TypeError as e:
    print(f"Type error: {e}")

try:
    # This will raise ValueError if type is invalid
    value = mudsys.sys_getval("some_key", "invalid_type")
except ValueError as e:
    print(f"Invalid type: {e}")

Features

• Allows multiple types instead of strings and prevents corruption changes of overwriting bool or int (type safety)
• Auto detection of common cases, string by default
• Better error-handling for type mismatches