Enum ChildResultDto 

pub enum ChildResultDto {
    Ok(Value),
    Err {
        kind: String,
        message: String,
    },
    Aborted,
}

Serializable representation of ChildResult.

Use this type for IPC, persistence, or JSON serialization.

Example

use orcs_component::{ChildResult, ChildResultDto, ChildError};
use serde_json::json;

let result = ChildResult::Err(ChildError::Timeout { elapsed_ms: 5000 });
let dto: ChildResultDto = result.into();

let json = serde_json::to_string(&dto).expect("ChildResultDto should serialize");
assert!(json.contains("timeout"));

Variants

Ok(Value)

Work completed successfully.

Err

Work failed with error details.

Fields

kind: String

Error kind identifier (e.g., “timeout”, “invalid_input”).

message: String

Human-readable error message.

Aborted

Work was aborted by a Signal.

Implementations

impl ChildResultDto

pub fn is_ok(&self) -> bool

Returns true if the result is Ok.

pub fn is_err(&self) -> bool

Returns true if the result is Err.

pub fn is_aborted(&self) -> bool

Returns true if the result is Aborted.

Trait Implementations

impl Clone for ChildResultDto

fn clone(&self) -> ChildResultDto

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ChildResultDto

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

Formats the value using the given formatter.

impl Default for ChildResultDto

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ChildResultDto

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ChildResult> for ChildResultDto

fn from(result: ChildResult) -> Self

Converts to this type from the input type.

impl PartialEq for ChildResultDto

fn eq(&self, other: &ChildResultDto) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ChildResultDto

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ChildResultDto