dixscript 1.0.0

Config, code, and encryption in one file — a data interchange format with compile-time functions, AES-256/ChaCha20 built-in, and cross-platform FFI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Result types for binary serialization/deserialization operations

use std::time::Duration;
use super::binary_serialization_context::{
    BinarySerializationStatistics,
    BinaryDeserializationStatistics,
};
use crate::Compiler::AST::DixScript;

/// Result of binary serialization operation
#[derive(Debug, Clone)]
pub struct BinarySerializationResult {
    pub is_success: bool,
    pub binary_data: Vec<u8>,
    pub original_size: usize,
    pub compressed_size: usize,
    pub compression_ratio: f64,
    pub duration: Duration,
    pub errors: Vec<String>,
    pub warnings: Vec<String>,
    pub statistics: BinarySerializationStatistics,
}

impl BinarySerializationResult {
    /// Create new successful result
    pub fn success(
        binary_data: Vec<u8>,
        original_size: usize,
        duration: Duration,
        statistics: BinarySerializationStatistics,
    ) -> Self {
        let compressed_size = binary_data.len();
        let compression_ratio = if original_size > 0 {
            1.0 - (compressed_size as f64 / original_size as f64)
        } else {
            0.0
        };

        BinarySerializationResult {
            is_success: true,
            binary_data,
            original_size,
            compressed_size,
            compression_ratio,
            duration,
            errors: Vec::new(),
            warnings: Vec::new(),
            statistics,
        }
    }

    /// Create new failed result
    pub fn failure(
        errors: Vec<String>,
        warnings: Vec<String>,
        duration: Duration,
    ) -> Self {
        BinarySerializationResult {
            is_success: false,
            binary_data: Vec::new(),
            original_size: 0,
            compressed_size: 0,
            compression_ratio: 0.0,
            duration,
            errors,
            warnings,
            statistics: BinarySerializationStatistics::new(),
        }
    }
}

impl std::fmt::Display for BinarySerializationResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let status = if self.is_success { "SUCCESS" } else { "FAILED" };
        write!(
            f,
            "Binary Serialization {}: Size={} bytes ({:.1}% reduction), Duration={:.2}ms, Errors={}",
            status,
            self.compressed_size,
            self.compression_ratio * 100.0,
            self.duration.as_secs_f64() * 1000.0,
            self.errors.len()
        )
    }
}

/// Result of binary deserialization operation
#[derive(Debug)]
pub struct BinaryDeserializationResult {
    pub is_success: bool,
    pub ast: Option<DixScript>,
    pub binary_size: usize,
    pub duration: Duration,
    pub errors: Vec<String>,
    pub warnings: Vec<String>,
    pub statistics: BinaryDeserializationStatistics,
}

impl BinaryDeserializationResult {
    /// Create new successful result
    pub fn success(
        ast: DixScript,
        binary_size: usize,
        duration: Duration,
        statistics: BinaryDeserializationStatistics,
    ) -> Self {
        BinaryDeserializationResult {
            is_success: true,
            ast: Some(ast),
            binary_size,
            duration,
            errors: Vec::new(),
            warnings: Vec::new(),
            statistics,
        }
    }

    /// Create new failed result
    pub fn failure(
        errors: Vec<String>,
        warnings: Vec<String>,
        duration: Duration,
    ) -> Self {
        BinaryDeserializationResult {
            is_success: false,
            ast: None,
            binary_size: 0,
            duration,
            errors,
            warnings,
            statistics: BinaryDeserializationStatistics::new(),
        }
    }
}

impl std::fmt::Display for BinaryDeserializationResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let status = if self.is_success { "SUCCESS" } else { "FAILED" };
        write!(
            f,
            "Binary Deserialization {}: Size={} bytes, Duration={:.2}ms, Errors={}",
            status,
            self.binary_size,
            self.duration.as_secs_f64() * 1000.0,
            self.errors.len()
        )
    }
          }