pdk-contracts-lib 1.9.1-alpha.2

PDK Contracts Library
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

// Copyright (c) 2026, Salesforce, Inc.,
// All rights reserved.
// For full license text, see the LICENSE.txt file

use std::{cell::RefCell, collections::HashMap, time::SystemTime};

use pdk_core::classy::{proxy_wasm::types::Status, Clock, SharedData};

pub struct ManualClock {
    current: SystemTime,
}

impl ManualClock {
    fn new() -> Self {
        Self {
            current: SystemTime::now(),
        }
    }
}

impl Default for ManualClock {
    /// Returns the manual clock implementation that is useful for testing
    fn default() -> Self {
        Self::new()
    }
}

impl Clock for ManualClock {
    fn get_current_time(&self) -> SystemTime {
        self.current
    }
}

#[derive(Default)]
pub struct MapSharedData {
    map: RefCell<HashMap<String, MapSharedDataEntry>>,
}

struct MapSharedDataEntry {
    data: Option<Vec<u8>>,
    lock: u32,
}

impl MapSharedData {
    fn do_store(&self, key: &str, value: &[u8], version: u32) {
        self.map.borrow_mut().insert(
            key.to_string(),
            MapSharedDataEntry {
                data: Some(value.to_vec()),
                lock: version,
            },
        );
    }

    fn next_cas(cas: Option<u32>) -> u32 {
        match cas {
            Some(u32::MAX) | None => 1,
            Some(cas) => cas + 1,
        }
    }
}

impl SharedData for MapSharedData {
    fn shared_data_get(&self, key: &str) -> (Option<Vec<u8>>, Option<u32>) {
        let key = key.to_string();
        self.map
            .borrow()
            .get(&key)
            .map(|entry| (entry.data.clone(), Some(entry.lock)))
            .unwrap_or_else(|| (None, None))
    }

    fn shared_data_set(&self, key: &str, value: &[u8], version: Option<u32>) -> Result<(), Status> {
        let (_, lock) = self.shared_data_get(key);
        if version.is_none() || lock.is_none() || version.unwrap() == lock.unwrap() {
            self.do_store(key, value, Self::next_cas(version));
            Ok(())
        } else {
            Err(Status::CasMismatch)
        }
    }

    fn shared_data_remove(
        &self,
        key: &str,
        version: Option<u32>,
    ) -> Result<Option<Vec<u8>>, Status> {
        let (val, _) = self.shared_data_get(key);
        self.shared_data_set(key, &[], version)?;
        Ok(val)
    }

    fn shared_data_keys(&self) -> Vec<String> {
        self.map.borrow().keys().cloned().collect()
    }
}