Struct CodexOkRaw 

pub struct CodexOkRaw<T, C = HashMap<String, String>> {
    pub value: T,
    pub location: &'static Location<'static>,
    pub execution_meta: C,
}

Detailed diagnostic information for a successful execution.

CodexOkRaw wraps the underlying success value and automatically captures the precise file and line number where the success was instantiated. It also provides a metadata envelope for injecting contextual data (e.g., execution time, row counts, or process IDs) into the success path.

Type Parameters

• T - The type of the successful value being wrapped.
• C - The type of the execution metadata. Defaults to HashMap<String, String> for dynamic key-value pairs, but can be replaced with a strongly-typed struct for better observability.

Fields

• value - The underlying success outcome.
• location - The source code location (file and line) of the CodexOkRaw instantiation. This field is ignored during serialization.
• execution_meta - A container for diagnostic information associated with the successful execution.

Examples

use cirious_codex_result::CodexOkRaw;
use std::collections::HashMap;

// Explicitly provide the type to guide the compiler's inference
let result: CodexOkRaw<&str, HashMap<String, String>> = CodexOkRaw::new("Operation complete")
    .with_meta("duration_ms", "42")
    .with_meta("affected_rows", "5");

assert_eq!(result.value, "Operation complete");
assert_eq!(result.execution_meta.get("duration_ms").unwrap(), "42");

Fields

value: T

The underlying successful value.

location: &'static Location<'static>

The precise location in the source code where this success was created.

execution_meta: C

Arbitrary key-value metadata associated with this successful execution.

Implementations

impl<T, C> CodexOkRaw<T, C>

pub fn new(value: T) -> Self

where C: Default,

Wraps the result in a success scenario, natively capturing the location.

This method uses the #[track_caller] attribute to ensure that the location captured is the site where CodexOkRaw::new was called, rather than the location inside the new function itself.

Arguments

• value - The successful outcome value to be wrapped.

Examples found in repository

examples/basic_usage.rs (line 16)

pub fn example_dynamic_metadata() {
  println!("--- Dynamic Metadata Example ---");

  // Explicitly annotate type to satisfy inference for HashMap
  let result = CodexOk::new("Operation completed").with_meta("service", "auth");

  println!("{result}");

  #[cfg(feature = "serde")]
  log_codex_ok(&result);
}

impl<T, S: BuildHasher> CodexOkRaw<T, HashMap<String, String, S>>

pub fn with_meta<K: Into<String>, V: Into<String>>( self, key: K, value: V, ) -> Self

Injects arbitrary execution metadata into the success envelope.

This method uses a builder-like pattern to allow chainable insertions of diagnostic metadata key-value pairs.

Arguments

• key - The metadata key (e.g., "duration_ms").
• value - The string representation of the metadata value.

Examples found in repository

examples/basic_usage.rs (line 16)

pub fn example_dynamic_metadata() {
  println!("--- Dynamic Metadata Example ---");

  // Explicitly annotate type to satisfy inference for HashMap
  let result = CodexOk::new("Operation completed").with_meta("service", "auth");

  println!("{result}");

  #[cfg(feature = "serde")]
  log_codex_ok(&result);
}

Trait Implementations

impl<T: Debug, C: Debug> Debug for CodexOkRaw<T, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T, C> Deserialize<'de> for CodexOkRaw<T, C>

where CodexOkRaw<T, C>: Default, T: Deserialize<'de>, C: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Display, C> Display for CodexOkRaw<T, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, C> Serialize for CodexOkRaw<T, C>

where T: Serialize, C: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.