activityrust 0.1.0

ActivityRust is an implementation of the ActivityStream specifications
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

use crate::content::*;
use crate::entities::collection::ActivityStreamCollection;
use crate::entities::entity::{
    ActivityStreamEntity, ActivityStreamEntityType, BoxedActivityStreamEntity,
};
use crate::entities::object::ActivityStreamObject;
use crate::traits::properties::*;
use crate::MaybeOptional;
use ambassador::Delegate;
use chrono::{DateTime, FixedOffset};
use serde::{Deserialize, Serialize};
use url::Url;

impl ActivityStreamCollectionProperties for ActivityStreamOrderedCollection {
    fn get_total_items(&self) -> &Option<usize> {
        &self.totalItems
    }

    fn get_current(&self) -> &Option<BoxedActivityStreamEntity> {
        &self.current
    }

    fn set_current<S, T: MaybeOptional<S>>(&mut self, current: T)
    where
        ActivityStreamEntity: From<S>,
    {
        if let Some(current) = current.get_optional() {
            self.current = Some(Box::new(ActivityStreamEntity::from(current)));
        }
    }

    fn get_first(&self) -> &Option<BoxedActivityStreamEntity> {
        &self.first
    }

    fn set_first<S, T: MaybeOptional<S>>(&mut self, first: T)
    where
        ActivityStreamEntity: From<S>,
    {
        if let Some(first) = first.get_optional() {
            self.first = Some(Box::new(ActivityStreamEntity::from(first)));
        }
    }

    fn get_last(&self) -> &Option<BoxedActivityStreamEntity> {
        &self.last
    }

    fn set_last<S, T: MaybeOptional<S>>(&mut self, last: T)
    where
        ActivityStreamEntity: From<S>,
    {
        if let Some(last) = last.get_optional() {
            self.last = Some(Box::new(ActivityStreamEntity::from(last)));
        }
    }

    fn get_items(&self) -> &Option<Vec<ActivityStreamEntity>> {
        &self.orderedItems
    }

    fn set_items<S, T: MaybeOptional<Vec<S>>>(&mut self, items: T)
    where
        ActivityStreamEntity: From<S>,
    {
        if let Some(items) = items.get_optional() {
            let items: Vec<ActivityStreamEntity> =
                items.into_iter().map(ActivityStreamEntity::from).collect();
            self.totalItems = Some(items.len());
            self.orderedItems = Some(items);
        }
    }

    fn add_item<S, T: MaybeOptional<S>>(&mut self, item: T)
    where
        ActivityStreamEntity: From<S>,
    {
        if let Some(item) = item.get_optional() {
            if self.orderedItems.is_none() {
                self.orderedItems = Some(Vec::new());
            }

            if let Some(ref mut items_internal) = self.orderedItems {
                self.totalItems = Some(self.totalItems.unwrap_or(0) + 1);
                items_internal.push(ActivityStreamEntity::from(item));
            }
        }
    }
}

generate_basics!(
    ActivityStreamOrderedCollection,
    ActivityStreamEntityType::OrderedCollection
);

#[allow(non_snake_case)]
#[derive(Debug, Default, Delegate, Serialize, Deserialize, PartialEq)]
#[delegate(ActivityStreamObjectProperties, target = "_base")]
pub struct ActivityStreamOrderedCollection {
    #[serde(skip_serializing_if = "Option::is_none", default)]
    #[serde(deserialize_with = "ActivityStreamOrderedCollection::deserialize_type")]
    r#type: Option<ActivityStreamEntityType>,
    #[serde(flatten)]
    _base: ActivityStreamObject,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    totalItems: Option<usize>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    current: Option<BoxedActivityStreamEntity>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    first: Option<BoxedActivityStreamEntity>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    last: Option<BoxedActivityStreamEntity>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    origin: Option<BoxedActivityStreamEntity>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    orderedItems: Option<Vec<ActivityStreamEntity>>,
}