wp_model_core/model/data/
record.rs

1use crate::model::Maker;
2use crate::model::format::LevelFormatAble;
3use crate::model::{DataType, FNameStr, FValueStr, Value};
4use crate::traits::AsValueRef;
5use serde_derive::{Deserialize, Serialize};
6use std::convert::TryFrom;
7use std::fmt::{Display, Formatter};
8use std::net::{IpAddr, Ipv4Addr};
9use std::sync::Arc;
10
11use super::field::Field;
12use super::storage::FieldStorage;
13pub const WP_EVENT_ID: &str = "wp_event_id";
14/// 记录中每一项需要暴露的行为
15pub trait RecordItem {
16    fn get_name(&self) -> &str;
17    fn get_meta(&self) -> &DataType;
18    fn get_value(&self) -> &Value;
19    fn get_value_mut(&mut self) -> &mut Value;
20}
21
22/// 为 Record 生成字段所需的工厂方法
23pub trait RecordItemFactory {
24    fn from_digit<S: Into<FNameStr>>(name: S, val: i64) -> Self;
25    fn from_ip<S: Into<FNameStr>>(name: S, ip: IpAddr) -> Self;
26    fn from_chars<N: Into<FNameStr>, Val: Into<FValueStr>>(name: N, val: Val) -> Self;
27}
28
29#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
30pub struct Record<T> {
31    pub id: u64,
32    pub items: Vec<T>,
33}
34
35impl<T> Default for Record<T> {
36    fn default() -> Self {
37        Self {
38            id: 0,
39            items: Vec::with_capacity(10),
40        }
41    }
42}
43
44impl<T> From<Vec<T>> for Record<T> {
45    fn from(value: Vec<T>) -> Self {
46        Self {
47            id: 0,
48            items: value,
49        }
50    }
51}
52
53impl<T> Display for Record<T>
54where
55    T: RecordItem + LevelFormatAble,
56{
57    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
58        writeln!(f)?;
59        for (i, o) in self.items.iter().enumerate() {
60            if *o.get_meta() != DataType::Ignore {
61                write!(f, "NO:{:<5}", i + 1)?;
62                o.level_fmt(f, 1)?;
63            }
64        }
65        Ok(())
66    }
67}
68
69impl<T> Record<T>
70where
71    T: RecordItem + RecordItemFactory,
72{
73    pub fn set_id(&mut self, id: u64) {
74        // 设置 id 字段
75        self.id = id;
76
77        // 如果已存在 wp_event_id 字段，避免重复追加
78        if self.items.iter().any(|f| f.get_name() == WP_EVENT_ID) {
79            return;
80        }
81        let Ok(id_i64) = i64::try_from(id) else {
82            // 事件 ID 超出 i64 无法表示，保持记录原状
83            return;
84        };
85        self.items.insert(0, T::from_digit(WP_EVENT_ID, id_i64));
86    }
87    pub fn test_value() -> Self {
88        let data = vec![
89            T::from_ip("ip", IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))),
90            T::from_chars("chars", "test"),
91        ];
92        Self { id: 0, items: data }
93    }
94}
95
96impl<T> Record<T>
97where
98    T: RecordItem,
99{
100    pub fn get_value(&self, key: &str) -> Option<&Value> {
101        self.items
102            .iter()
103            .find(|x| x.get_name() == key)
104            .map(|x| x.get_value())
105    }
106}
107
108impl<T> Record<T> {
109    pub fn append(&mut self, data: T) {
110        self.items.push(data);
111    }
112    pub fn merge(&mut self, mut other: Self) {
113        self.items.append(&mut other.items);
114    }
115}
116
117impl<T> Record<T>
118where
119    T: RecordItem,
120{
121    // 存在同名字段时取第一个字段返回值
122    pub fn field(&self, key: &str) -> Option<&T> {
123        self.items.iter().find(|item| item.get_name() == key)
124    }
125
126    pub fn get2(&self, name: &str) -> Option<&T> {
127        self.items.iter().find(|x| x.get_name() == name)
128    }
129    pub fn get_value_mut(&mut self, name: &str) -> Option<&mut T> {
130        self.items.iter_mut().find(|x| x.get_name() == name)
131    }
132    pub fn remove_field(&mut self, name: &str) -> bool {
133        let pos = self.items.iter().position(|x| x.get_name() == name);
134        if let Some(pos) = pos {
135            self.items.remove(pos);
136            true
137        } else {
138            false
139        }
140    }
141}
142
143impl<V> RecordItem for Field<V>
144where
145    V: AsValueRef<Value>,
146{
147    fn get_name(&self) -> &str {
148        Field::get_name(self)
149    }
150
151    fn get_meta(&self) -> &DataType {
152        Field::get_meta(self)
153    }
154
155    fn get_value(&self) -> &Value {
156        Field::get_value(self)
157    }
158
159    fn get_value_mut(&mut self) -> &mut Value {
160        Field::get_value_mut(self)
161    }
162}
163
164impl<V> RecordItemFactory for Field<V>
165where
166    V: Maker<i64> + Maker<FValueStr> + Maker<IpAddr>,
167{
168    fn from_digit<S: Into<FNameStr>>(name: S, val: i64) -> Self {
169        Field::from_digit(name, val)
170    }
171
172    fn from_ip<S: Into<FNameStr>>(name: S, ip: IpAddr) -> Self {
173        Field::from_ip(name, ip)
174    }
175
176    fn from_chars<N: Into<FNameStr>, Val: Into<FValueStr>>(name: N, val: Val) -> Self {
177        Field::from_chars(name, val)
178    }
179}
180
181// Convenience methods for Record<FieldStorage> (DataRecord with mixed storage)
182impl Record<FieldStorage> {
183    /// Push a shared field (Arc-wrapped) to the record
184    ///
185    /// # Examples
186    ///
187    /// ```
188    /// use std::sync::Arc;
189    /// use wp_model_core::model::{DataRecord, Field, Value, DataType, FieldStorage};
190    ///
191    /// let mut record = DataRecord::default();
192    /// let field = Arc::new(Field::new(DataType::Chars, "app_name", Value::from("myapp")));
193    /// record.push_shared(field);
194    /// ```
195    pub fn push_shared(&mut self, field: Arc<Field<Value>>) {
196        self.items.push(FieldStorage::Shared(field));
197    }
198
199    /// Push an owned field to the record
200    ///
201    /// # Examples
202    ///
203    /// ```
204    /// use wp_model_core::model::{DataRecord, Field, Value, DataType};
205    ///
206    /// let mut record = DataRecord::default();
207    /// let field = Field::new(DataType::Digit, "count", Value::from(42));
208    /// record.push_owned(field);
209    /// ```
210    pub fn push_owned(&mut self, field: Field<Value>) {
211        self.items.push(FieldStorage::Owned(field));
212    }
213
214    /// Get a reference to the underlying field by index
215    ///
216    /// # Examples
217    ///
218    /// ```
219    /// use wp_model_core::model::{DataRecord, Field, Value, DataType};
220    ///
221    /// let mut record = DataRecord::default();
222    /// let field = Field::new(DataType::Digit, "x", Value::from(10));
223    /// record.push_owned(field);
224    ///
225    /// let retrieved = record.get_field(0);
226    /// assert!(retrieved.is_some());
227    /// assert_eq!(retrieved.unwrap().get_name(), "x");
228    /// ```
229    pub fn get_field(&self, index: usize) -> Option<&Field<Value>> {
230        self.items.get(index).map(|s| s.as_field())
231    }
232
233    /// Get statistics about storage types (shared vs owned)
234    ///
235    /// Returns (shared_count, owned_count)
236    ///
237    /// # Examples
238    ///
239    /// ```
240    /// use std::sync::Arc;
241    /// use wp_model_core::model::{DataRecord, Field, Value, DataType};
242    ///
243    /// let mut record = DataRecord::default();
244    /// let static_field = Arc::new(Field::new(DataType::Chars, "static", Value::from("val")));
245    /// record.push_shared(static_field);
246    ///
247    /// let dynamic_field = Field::new(DataType::Digit, "dynamic", Value::from(10));
248    /// record.push_owned(dynamic_field);
249    ///
250    /// let (shared, owned) = record.storage_stats();
251    /// assert_eq!(shared, 1);
252    /// assert_eq!(owned, 1);
253    /// ```
254    pub fn storage_stats(&self) -> (usize, usize) {
255        let mut shared_count = 0;
256        let mut owned_count = 0;
257        for item in &self.items {
258            match item {
259                FieldStorage::Shared(_) => shared_count += 1,
260                FieldStorage::Owned(_) => owned_count += 1,
261            }
262        }
263        (shared_count, owned_count)
264    }
265
266    /// Convert to a fully owned record (Record<Field<Value>>)
267    ///
268    /// This is useful when you need to pass the record to code that expects
269    /// the old Record<Field<Value>> type.
270    ///
271    /// # Examples
272    ///
273    /// ```
274    /// use wp_model_core::model::{DataRecord, Field, Value, DataType};
275    ///
276    /// let mut record = DataRecord::default();
277    /// let field = Field::new(DataType::Digit, "x", Value::from(10));
278    /// record.push_owned(field);
279    ///
280    /// let owned_record = record.into_owned_record();
281    /// assert_eq!(owned_record.items.len(), 1);
282    /// ```
283    pub fn into_owned_record(self) -> Record<Field<Value>> {
284        Record {
285            id: self.id,
286            items: self.items
287                .into_iter()
288                .map(|storage| storage.into_owned())
289                .collect(),
290        }
291    }
292}
293
294// ValueGetter impl removed from core; use function-style adapters in extension crates.
295
296#[cfg(test)]
297mod tests {
298    use super::*;
299    use crate::model::{DataField, DataRecord, FieldStorage};
300    use std::net::Ipv4Addr;
301
302    fn make_test_record() -> DataRecord {
303        let fields = vec![
304            FieldStorage::from_chars("name", "Alice"),
305            FieldStorage::from_digit("age", 30),
306            FieldStorage::from_ip("ip", IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1))),
307        ];
308        Record::from(fields)
309    }
310
311    // ========== Record creation tests ==========
312
313    #[test]
314    fn test_record_default() {
315        let record: DataRecord = Record::default();
316        assert!(record.items.is_empty());
317    }
318
319    #[test]
320    fn test_record_from_vec() {
321        let fields: Vec<FieldStorage> = vec![FieldStorage::from_digit("x", 1), FieldStorage::from_digit("y", 2)];
322        let record: DataRecord = Record::from(fields);
323        assert_eq!(record.items.len(), 2);
324    }
325
326    #[test]
327    fn test_record_test_value() {
328        let record: DataRecord = Record::test_value();
329        assert_eq!(record.items.len(), 2);
330        assert!(record.field("ip").is_some());
331        assert!(record.field("chars").is_some());
332    }
333
334    // ========== Record field access tests ==========
335
336    #[test]
337    fn test_record_field() {
338        let record = make_test_record();
339
340        let name_field = record.field("name");
341        assert!(name_field.is_some());
342        assert_eq!(name_field.unwrap().get_name(), "name");
343
344        let missing = record.field("missing");
345        assert!(missing.is_none());
346    }
347
348    #[test]
349    fn test_record_get2() {
350        let record = make_test_record();
351
352        let age_field = record.get2("age");
353        assert!(age_field.is_some());
354        assert_eq!(age_field.unwrap().get_meta(), &DataType::Digit);
355    }
356
357    #[test]
358    fn test_record_get_value() {
359        let record = make_test_record();
360
361        let age_value = record.get_value("age");
362        assert!(age_value.is_some());
363        assert_eq!(age_value.unwrap(), &Value::Digit(30));
364
365        let missing = record.get_value("missing");
366        assert!(missing.is_none());
367    }
368
369    #[test]
370    fn test_record_get_value_mut() {
371        let mut record = make_test_record();
372
373        let field = record.get_value_mut("age");
374        assert!(field.is_some());
375
376        // Modify the value through mutable reference
377        if let Some(f) = field {
378            *f.get_value_mut() = Value::Digit(31);
379        }
380
381        assert_eq!(record.get_value("age"), Some(&Value::Digit(31)));
382    }
383
384    // ========== Record mutation tests ==========
385
386    #[test]
387    fn test_record_append() {
388        let mut record: DataRecord = Record::default();
389        assert_eq!(record.items.len(), 0);
390
391        record.append(FieldStorage::from_digit("count", 100));
392        assert_eq!(record.items.len(), 1);
393
394        record.append(FieldStorage::from_chars("msg", "hello"));
395        assert_eq!(record.items.len(), 2);
396    }
397
398    #[test]
399    fn test_record_merge() {
400        let mut record1: DataRecord = Record::from(vec![FieldStorage::from_digit("a", 1)]);
401        let record2: DataRecord =
402            Record::from(vec![FieldStorage::from_digit("b", 2), FieldStorage::from_digit("c", 3)]);
403
404        record1.merge(record2);
405        assert_eq!(record1.items.len(), 3);
406        assert!(record1.field("a").is_some());
407        assert!(record1.field("b").is_some());
408        assert!(record1.field("c").is_some());
409    }
410
411    #[test]
412    fn test_record_remove_field() {
413        let mut record = make_test_record();
414        assert_eq!(record.items.len(), 3);
415
416        let removed = record.remove_field("age");
417        assert!(removed);
418        assert_eq!(record.items.len(), 2);
419        assert!(record.field("age").is_none());
420
421        let not_found = record.remove_field("nonexistent");
422        assert!(!not_found);
423        assert_eq!(record.items.len(), 2);
424    }
425
426    // ========== set_id tests ==========
427
428    #[test]
429    fn test_record_set_id() {
430        let mut record = make_test_record();
431        let original_len = record.items.len();
432
433        record.set_id(12345);
434
435        // ID should be set in both the id field and added to items
436        assert_eq!(record.id, 12345);
437        assert_eq!(record.items.len(), original_len + 1);
438        // ID should be inserted at position 0
439        assert_eq!(record.items[0].get_name(), WP_EVENT_ID);
440        assert_eq!(record.items[0].get_value(), &Value::Digit(12345));
441    }
442
443    #[test]
444    fn test_record_set_id_no_duplicate() {
445        let mut record = make_test_record();
446
447        record.set_id(100);
448        assert_eq!(record.id, 100);
449        let len_after_first = record.items.len();
450
451        // Try to set ID again - should update id field but not add duplicate to items
452        record.set_id(200);
453        assert_eq!(record.id, 200);
454        assert_eq!(record.items.len(), len_after_first);
455        // Original ID in items should remain
456        assert_eq!(record.get_value(WP_EVENT_ID), Some(&Value::Digit(100)));
457    }
458
459    // ========== RecordItem trait tests ==========
460
461    #[test]
462    fn test_field_as_record_item() {
463        let field: DataField = Field::from_chars("key", "value");
464
465        // Test RecordItem trait methods
466        assert_eq!(field.get_name(), "key");
467        assert_eq!(field.get_meta(), &DataType::Chars);
468        assert_eq!(field.get_value(), &Value::Chars("value".into()));
469    }
470
471    #[test]
472    fn test_field_record_item_get_value_mut() {
473        let mut field: DataField = Field::from_digit("num", 10);
474
475        *field.get_value_mut() = Value::Digit(20);
476        assert_eq!(field.get_value(), &Value::Digit(20));
477    }
478
479    // ========== FieldStorage RecordItem tests ==========
480
481    #[test]
482    fn test_field_storage_as_record_item() {
483        let storage: FieldStorage = FieldStorage::from_chars("key", "value");
484
485        // Test RecordItem trait methods
486        assert_eq!(storage.get_name(), "key");
487        assert_eq!(storage.get_meta(), &DataType::Chars);
488        assert_eq!(storage.get_value(), &Value::Chars("value".into()));
489    }
490
491    #[test]
492    fn test_field_storage_record_item_get_value_mut() {
493        let mut storage: FieldStorage = FieldStorage::from_digit("num", 10);
494
495        *storage.get_value_mut() = Value::Digit(20);
496        assert_eq!(storage.get_value(), &Value::Digit(20));
497    }
498
499    // ========== RecordItemFactory trait tests ==========
500
501    #[test]
502    fn test_record_item_factory() {
503        let digit: FieldStorage = <FieldStorage as RecordItemFactory>::from_digit("n", 42);
504        assert_eq!(digit.get_meta(), &DataType::Digit);
505
506        let ip: FieldStorage = <FieldStorage as RecordItemFactory>::from_ip(
507            "addr",
508            IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1)),
509        );
510        assert_eq!(ip.get_meta(), &DataType::IP);
511
512        let chars: FieldStorage = <FieldStorage as RecordItemFactory>::from_chars("s", "hello");
513        assert_eq!(chars.get_meta(), &DataType::Chars);
514    }
515
516    // ========== Display test ==========
517
518    #[test]
519    fn test_record_display() {
520        let record = make_test_record();
521        let display = format!("{}", record);
522
523        assert!(display.contains("name"));
524        assert!(display.contains("age"));
525        assert!(display.contains("ip"));
526    }
527
528    // ========== Record<FieldStorage> convenience methods tests ==========
529
530    #[test]
531    fn test_push_shared() {
532        let mut record = DataRecord::default();
533        let field = Arc::new(Field::new(DataType::Chars, "static", Value::from("value")));
534
535        record.push_shared(field.clone());
536        assert_eq!(record.items.len(), 1);
537        assert!(record.items[0].is_shared());
538        assert_eq!(record.items[0].as_field().get_name(), "static");
539    }
540
541    #[test]
542    fn test_push_owned() {
543        let mut record = DataRecord::default();
544        let field = Field::new(DataType::Digit, "dynamic", Value::from(42));
545
546        record.push_owned(field);
547        assert_eq!(record.items.len(), 1);
548        assert!(!record.items[0].is_shared());
549        assert_eq!(record.items[0].as_field().get_name(), "dynamic");
550    }
551
552    #[test]
553    fn test_get_field() {
554        let mut record = DataRecord::default();
555        record.push_owned(Field::new(DataType::Chars, "test", Value::from("value")));
556
557        let field = record.get_field(0);
558        assert!(field.is_some());
559        assert_eq!(field.unwrap().get_name(), "test");
560
561        let missing = record.get_field(10);
562        assert!(missing.is_none());
563    }
564
565    #[test]
566    fn test_storage_stats() {
567        let mut record = DataRecord::default();
568
569        // Add shared fields
570        record.push_shared(Arc::new(Field::new(DataType::Chars, "s1", Value::from("a"))));
571        record.push_shared(Arc::new(Field::new(DataType::Chars, "s2", Value::from("b"))));
572
573        // Add owned fields
574        record.push_owned(Field::new(DataType::Digit, "o1", Value::from(1)));
575        record.push_owned(Field::new(DataType::Digit, "o2", Value::from(2)));
576        record.push_owned(Field::new(DataType::Digit, "o3", Value::from(3)));
577
578        let (shared, owned) = record.storage_stats();
579        assert_eq!(shared, 2);
580        assert_eq!(owned, 3);
581    }
582
583    #[test]
584    fn test_into_owned_record() {
585        let mut record = DataRecord::default();
586        record.push_shared(Arc::new(Field::new(DataType::Chars, "s", Value::from("shared"))));
587        record.push_owned(Field::new(DataType::Digit, "o", Value::from(10)));
588
589        let owned_record = record.into_owned_record();
590        assert_eq!(owned_record.items.len(), 2);
591        assert_eq!(owned_record.items[0].get_name(), "s");
592        assert_eq!(owned_record.items[1].get_name(), "o");
593    }
594}
wp_model_core/model/data/record.rs

wp_model_core/model/data/
record.rs
