nominal-api 0.1239.0

API bindings for the Nominal platform
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

#[derive(
    Debug,
    Clone,
    conjure_object::serde::Serialize,
    conjure_object::serde::Deserialize,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Hash
)]
#[serde(crate = "conjure_object::serde")]
#[conjure_object::private::staged_builder::staged_builder]
#[builder(crate = conjure_object::private::staged_builder, update, inline)]
pub struct RunChannel {
    #[builder(custom(type = super::StringConstant, convert = Box::new))]
    #[serde(rename = "runRid")]
    run_rid: Box<super::StringConstant>,
    #[builder(
        default,
        custom(
            type = impl
            Into<Option<super::StringConstant>>,
            convert = |v|v.into().map(Box::new)
        )
    )]
    #[serde(rename = "assetRid", skip_serializing_if = "Option::is_none", default)]
    asset_rid: Option<Box<super::StringConstant>>,
    #[builder(custom(type = super::StringConstant, convert = Box::new))]
    #[serde(rename = "dataScopeName")]
    data_scope_name: Box<super::StringConstant>,
    #[builder(custom(type = super::StringConstant, convert = Box::new))]
    #[serde(rename = "channel")]
    channel: Box<super::StringConstant>,
    #[builder(
        default,
        map(key(type = String, into), value(type = super::StringConstant))
    )]
    #[serde(
        rename = "additionalTags",
        skip_serializing_if = "std::collections::BTreeMap::is_empty",
        default
    )]
    additional_tags: std::collections::BTreeMap<String, super::StringConstant>,
    #[builder(
        default,
        custom(
            type = impl
            Into<Option<super::TagFilters>>,
            convert = |v|v.into().map(Box::new)
        )
    )]
    #[serde(
        rename = "additionalTagFilters",
        skip_serializing_if = "Option::is_none",
        default
    )]
    additional_tag_filters: Option<Box<super::TagFilters>>,
    #[builder(default, set(item(type = String, into)))]
    #[serde(
        rename = "tagsToGroupBy",
        skip_serializing_if = "std::collections::BTreeSet::is_empty",
        default
    )]
    tags_to_group_by: std::collections::BTreeSet<String>,
    #[builder(default, set(item(type = super::StringConstant)))]
    #[serde(
        rename = "groupByTags",
        skip_serializing_if = "std::collections::BTreeSet::is_empty",
        default
    )]
    group_by_tags: std::collections::BTreeSet<super::StringConstant>,
}
impl RunChannel {
    /// Constructs a new instance of the type.
    #[inline]
    pub fn new(
        run_rid: super::StringConstant,
        data_scope_name: super::StringConstant,
        channel: super::StringConstant,
    ) -> Self {
        Self::builder()
            .run_rid(run_rid)
            .data_scope_name(data_scope_name)
            .channel(channel)
            .build()
    }
    #[inline]
    pub fn run_rid(&self) -> &super::StringConstant {
        &*self.run_rid
    }
    /// Used to disambiguate when multiple assets within this run contain data scopes with the same name.
    /// If not specified for a run with multiple assets, an error will be thrown.
    #[inline]
    pub fn asset_rid(&self) -> Option<&super::StringConstant> {
        self.asset_rid.as_ref().map(|o| &**o)
    }
    /// Used to disambiguate when multiple data scopes within this run contain channels with the same name.
    #[inline]
    pub fn data_scope_name(&self) -> &super::StringConstant {
        &*self.data_scope_name
    }
    #[inline]
    pub fn channel(&self) -> &super::StringConstant {
        &*self.channel
    }
    #[deprecated(note = "Use additionalTagFilters")]
    #[inline]
    pub fn additional_tags(
        &self,
    ) -> &std::collections::BTreeMap<String, super::StringConstant> {
        &self.additional_tags
    }
    /// Tags to filter the channel by, in addition to tag filters defined for a given Run data scope. Throws on
    /// collisions with tag keys already defined for the given Run data scope. Only returns points that match
    /// both sets of tag filters. For log series, include arg filters here in addition to tag filters.
    #[inline]
    pub fn additional_tag_filters(&self) -> Option<&super::TagFilters> {
        self.additional_tag_filters.as_ref().map(|o| &**o)
    }
    #[deprecated(
        note = "Use groupByTags instead. Throws if both tagsToGroupBy and groupByTags are specified.\n"
    )]
    #[inline]
    pub fn tags_to_group_by(&self) -> &std::collections::BTreeSet<String> {
        &self.tags_to_group_by
    }
    /// Tags that the channel should be grouped by. If this is non-empty a grouped result will be returned
    /// with an entry for each grouping. Only one of tagsToGroupBy and groupByTags should be specified.
    #[inline]
    pub fn group_by_tags(&self) -> &std::collections::BTreeSet<super::StringConstant> {
        &self.group_by_tags
    }
}