lnmp 0.5.16

LNMP (LLM Native Minimal Protocol) - Meta crate providing unified access to all LNMP modules
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

//! Distributed Cache - Showcase Example
//!
//! Distributed caching system with efficient data synchronization.
//! Demonstrates binary format, nested structures, and streaming.
//!
//! Run: `cargo run --example distributed_cache`

use lnmp::prelude::*;

/// Cache entry
#[derive(Clone)]
struct CacheEntry {
    key: String,
    value: Vec<u8>,
    ttl: u64,
    version: u32,
}

impl CacheEntry {
    fn to_lnmp_record(&self) -> LnmpRecord {
        let mut record = LnmpRecord::new();

        record.add_field(LnmpField {
            fid: 1,
            value: LnmpValue::String(self.key.clone()),
        });

        record.add_field(LnmpField {
            fid: 2,
            value: LnmpValue::String(String::from_utf8_lossy(&self.value).to_string()),
        });

        record.add_field(LnmpField {
            fid: 3,
            value: LnmpValue::Int(self.ttl as i64),
        });

        record.add_field(LnmpField {
            fid: 4,
            value: LnmpValue::Int(self.version as i64),
        });

        record
    }
}

fn main() {
    println!("💾 Distributed Cache - LNMP Showcase\n");

    // Create cache entries
    let entries = vec![
        CacheEntry {
            key: "user:1001".to_string(),
            value: b"Alice Johnson|alice@example.com|Premium".to_vec(),
            ttl: 3600,
            version: 1,
        },
        CacheEntry {
            key: "session:abc123".to_string(),
            value: b"SessionData{authenticated:true}".to_vec(),
            ttl: 1800,
            version: 1,
        },
        CacheEntry {
            key: "config:app".to_string(),
            value: b"max_connections=100;timeout=30".to_vec(),
            ttl: 7200,
            version: 2,
        },
    ];

    println!("📦 Cache initialized with {} entries\n", entries.len());

    // Create encoder
    let encoder = lnmp::codec::Encoder::new();

    println!("🔄 Encoding cache entries:\n");

    for entry in &entries {
        let record = entry.to_lnmp_record();
        let encoded = encoder.encode(&record);

        println!("  Key: {}", entry.key);
        println!("    Version: {}", entry.version);
        println!("    TTL: {}s", entry.ttl);
        println!("    Encoded size: {} bytes", encoded.len());
        println!();
    }

    // Simulate cache update
    println!("🔄 Simulating cache update...");
    let mut updated_entry = entries[0].clone();
    updated_entry.value = b"Alice Johnson|alice@example.com|Enterprise".to_vec();
    updated_entry.version = 2;

    let old_record = entries[0].to_lnmp_record();
    let new_record = updated_entry.to_lnmp_record();

    let old_encoded = encoder.encode(&old_record);
    let new_encoded = encoder.encode(&new_record);

    println!("  Old version: {} bytes", old_encoded.len());
    println!("  New version: {} bytes", new_encoded.len());
    println!(
        "  Change: {} → {} (version bumped)\n",
        entries[0].version, updated_entry.version
    );

    println!("✅ Cache synchronization demo complete!");
    println!("\n💡 Key Features Demonstrated:");
    println!("   • Structured cache entries with metadata");
    println!("   • Cache versioning for conflict resolution");
    println!("   • TTL-based expiration");
    println!("   • Efficient LNMP encoding");
    println!("   • Meta crate integration (lnmp::*)");
}