alec 1.3.9

Adaptive Lazy Evolving Compression - Smart codec for IoT sensor data with 90% compression ratio
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

//! # ALEC - Adaptive Lazy Evolving Compression
//!
//! A smart compression codec designed for constrained environments where every bit counts.
//!
//! ## Key Features
//!
//! - **Lazy Compression**: Transmit decisions before data
//! - **Evolving Context**: Shared dictionary that improves over time
//! - **Asymmetric Design**: Light encoder, heavy decoder (or vice versa)
//! - **Priority Classification**: P1 (critical) to P5 (disposable)
//!
//! ## Quick Start
//!
//! ```rust
//! use alec::{Encoder, Decoder, Context, Classifier, RawData};
//!
//! // Create components
//! let mut encoder = Encoder::new();
//! let mut decoder = Decoder::new();
//! let classifier = Classifier::default();
//! let mut context = Context::new();
//!
//! // Encode a value
//! let data = RawData::new(22.5, 0);
//! let classification = classifier.classify(&data, &context);
//! let message = encoder.encode(&data, &classification, &context);
//!
//! // Decode
//! let decoded = decoder.decode(&message, &context).unwrap();
//! assert!((decoded.value - data.value).abs() < 0.01);
//!
//! // Update context
//! context.observe(&data);
//! ```
//!
//! ## Modules
//!
//! - [`protocol`]: Message types, priorities, and wire format
//! - [`encoder`]: Data encoding
//! - [`decoder`]: Message decoding
//! - [`classifier`]: Priority classification
//! - [`context`]: Shared context (dictionary + prediction model)
//! - [`channel`]: Communication channel abstraction (std only)
//! - [`metrics`]: Compression statistics and analysis

#![cfg_attr(not(feature = "std"), no_std)]

#[cfg(not(feature = "std"))]
extern crate alloc;

// Core modules (always available)
pub mod classifier;
pub mod context;
pub mod decoder;
pub mod encoder;
pub mod error;
pub mod metrics;
pub mod protocol;
pub mod sync;
pub mod tls;

// Std-only modules
#[cfg(feature = "std")]
pub mod channel;
#[cfg(feature = "std")]
pub mod fleet;
#[cfg(feature = "std")]
pub mod health;
#[cfg(feature = "std")]
pub mod recovery;
#[cfg(feature = "std")]
pub mod security;

// Re-exports for convenient access (always available)
pub use classifier::{Classification, ClassificationReason, Classifier};
pub use context::Context;
pub use decoder::Decoder;
pub use encoder::Encoder;
pub use error::{AlecError, Result};
pub use metrics::{CompressionMetrics, ContextMetrics};
pub use protocol::{
    ChannelInput, EncodedMessage, EncodingType, MessageHeader, MessageType, Priority, RawData,
};
pub use sync::{
    SyncAnnounce, SyncConfig, SyncDiff, SyncMessage, SyncRequest, SyncState, Synchronizer,
};
pub use tls::{DtlsConfig, TlsConfig, TlsState};

// Std-only re-exports
#[cfg(feature = "std")]
pub use channel::Channel;
#[cfg(feature = "std")]
pub use fleet::{EmitterId, EmitterState, FleetConfig, FleetManager, FleetStats, ProcessedMessage};
#[cfg(feature = "std")]
pub use health::{HealthCheck, HealthCheckable, HealthConfig, HealthMonitor, HealthStatus};
#[cfg(feature = "std")]
pub use recovery::{
    with_retry, with_retry_metrics, CircuitBreaker, CircuitConfig, CircuitState, DegradationLevel,
    RetryResult, RetryStrategy,
};
#[cfg(feature = "std")]
pub use security::{
    AuditEvent, AuditEventType, AuditFilter, AuditLogger, CertValidation, MemoryAuditLogger,
    RateLimiter, SecurityConfig, SecurityContext, Severity,
};

/// Library version
pub const VERSION: &str = env!("CARGO_PKG_VERSION");

/// Protocol version
pub const PROTOCOL_VERSION: u8 = 1;

/// Maximum payload size in bytes
pub const MAX_PAYLOAD_SIZE: usize = 65535;

/// Default scale factor for delta encoding (100 = 2 decimal places)
pub const DEFAULT_SCALE_FACTOR: u32 = 100;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_version() {
        assert!(!VERSION.is_empty());
    }

    #[test]
    fn test_basic_roundtrip() {
        let mut encoder = Encoder::new();
        let mut decoder = Decoder::new();
        let classifier = Classifier::default();
        let mut context = Context::new();

        let data = RawData::new(42.0, 0);
        let classification = classifier.classify(&data, &context);
        let message = encoder.encode(&data, &classification, &context);
        let decoded = decoder.decode(&message, &context).unwrap();

        assert!((decoded.value - data.value).abs() < 0.001);

        context.observe(&data);
    }
}