quilkin_proto/generated/xds/kind/matcher/
v3.rs

1#[allow(clippy::derive_partial_eq_without_eq)]
2#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct RegexMatcher {
4    #[prost(string, tag = "2")]
5    pub regex: ::prost::alloc::string::String,
6    #[prost(oneof = "regex_matcher::EngineType", tags = "1")]
7    pub engine_type: ::core::option::Option<regex_matcher::EngineType>,
8}
9/// Nested message and enum types in `RegexMatcher`.
10pub mod regex_matcher {
11    #[allow(clippy::derive_partial_eq_without_eq)]
12    #[derive(Clone, PartialEq, ::prost::Message)]
13    pub struct GoogleRe2 {}
14    #[allow(clippy::derive_partial_eq_without_eq)]
15    #[derive(Clone, PartialEq, ::prost::Oneof)]
16    pub enum EngineType {
17        #[prost(message, tag = "1")]
18        GoogleRe2(GoogleRe2),
19    }
20}
21#[allow(clippy::derive_partial_eq_without_eq)]
22#[derive(Clone, PartialEq, ::prost::Message)]
23pub struct StringMatcher {
24    #[prost(bool, tag = "6")]
25    pub ignore_case: bool,
26    #[prost(oneof = "string_matcher::MatchPattern", tags = "1, 2, 3, 5, 7")]
27    pub match_pattern: ::core::option::Option<string_matcher::MatchPattern>,
28}
29/// Nested message and enum types in `StringMatcher`.
30pub mod string_matcher {
31    #[allow(clippy::derive_partial_eq_without_eq)]
32    #[derive(Clone, PartialEq, ::prost::Oneof)]
33    pub enum MatchPattern {
34        #[prost(string, tag = "1")]
35        Exact(::prost::alloc::string::String),
36        #[prost(string, tag = "2")]
37        Prefix(::prost::alloc::string::String),
38        #[prost(string, tag = "3")]
39        Suffix(::prost::alloc::string::String),
40        #[prost(message, tag = "5")]
41        SafeRegex(super::RegexMatcher),
42        #[prost(string, tag = "7")]
43        Contains(::prost::alloc::string::String),
44    }
45}
46#[allow(clippy::derive_partial_eq_without_eq)]
47#[derive(Clone, PartialEq, ::prost::Message)]
48pub struct ListStringMatcher {
49    #[prost(message, repeated, tag = "1")]
50    pub patterns: ::prost::alloc::vec::Vec<StringMatcher>,
51}
52#[allow(clippy::derive_partial_eq_without_eq)]
53#[derive(Clone, PartialEq, ::prost::Message)]
54pub struct Matcher {
55    #[prost(message, optional, boxed, tag = "3")]
56    pub on_no_match: ::core::option::Option<::prost::alloc::boxed::Box<matcher::OnMatch>>,
57    #[prost(oneof = "matcher::MatcherType", tags = "1, 2")]
58    pub matcher_type: ::core::option::Option<matcher::MatcherType>,
59}
60/// Nested message and enum types in `Matcher`.
61pub mod matcher {
62    #[allow(clippy::derive_partial_eq_without_eq)]
63    #[derive(Clone, PartialEq, ::prost::Message)]
64    pub struct OnMatch {
65        #[prost(oneof = "on_match::OnMatch", tags = "1, 2")]
66        pub on_match: ::core::option::Option<on_match::OnMatch>,
67    }
68    /// Nested message and enum types in `OnMatch`.
69    pub mod on_match {
70        #[allow(clippy::derive_partial_eq_without_eq)]
71        #[derive(Clone, PartialEq, ::prost::Oneof)]
72        pub enum OnMatch {
73            #[prost(message, tag = "1")]
74            Matcher(::prost::alloc::boxed::Box<super::super::Matcher>),
75            #[prost(message, tag = "2")]
76            Action(super::super::super::super::super::core::v3::TypedExtensionConfig),
77        }
78    }
79    #[allow(clippy::derive_partial_eq_without_eq)]
80    #[derive(Clone, PartialEq, ::prost::Message)]
81    pub struct MatcherList {
82        #[prost(message, repeated, tag = "1")]
83        pub matchers: ::prost::alloc::vec::Vec<matcher_list::FieldMatcher>,
84    }
85    /// Nested message and enum types in `MatcherList`.
86    pub mod matcher_list {
87        #[allow(clippy::derive_partial_eq_without_eq)]
88        #[derive(Clone, PartialEq, ::prost::Message)]
89        pub struct Predicate {
90            #[prost(oneof = "predicate::MatchType", tags = "1, 2, 3, 4")]
91            pub match_type: ::core::option::Option<predicate::MatchType>,
92        }
93        /// Nested message and enum types in `Predicate`.
94        pub mod predicate {
95            #[allow(clippy::derive_partial_eq_without_eq)]
96            #[derive(Clone, PartialEq, ::prost::Message)]
97            pub struct SinglePredicate {
98                #[prost(message, optional, tag = "1")]
99                pub input: ::core::option::Option<
100                    super::super::super::super::super::super::core::v3::TypedExtensionConfig,
101                >,
102                #[prost(oneof = "single_predicate::Matcher", tags = "2, 3")]
103                pub matcher: ::core::option::Option<single_predicate::Matcher>,
104            }
105            /// Nested message and enum types in `SinglePredicate`.
106            pub mod single_predicate {
107                #[allow(clippy::derive_partial_eq_without_eq)]
108                #[derive(Clone, PartialEq, ::prost::Oneof)]
109                pub enum Matcher {
110                    #[prost(message, tag = "2")]
111                    ValueMatch(super::super::super::super::StringMatcher),
112                    #[prost(message, tag = "3")]
113                    CustomMatch(
114                        super::super::super::super::super::super::super::core::v3::TypedExtensionConfig,
115                    ),
116                }
117            }
118            #[allow(clippy::derive_partial_eq_without_eq)]
119            #[derive(Clone, PartialEq, ::prost::Message)]
120            pub struct PredicateList {
121                #[prost(message, repeated, tag = "1")]
122                pub predicate: ::prost::alloc::vec::Vec<super::Predicate>,
123            }
124            #[allow(clippy::derive_partial_eq_without_eq)]
125            #[derive(Clone, PartialEq, ::prost::Oneof)]
126            pub enum MatchType {
127                #[prost(message, tag = "1")]
128                SinglePredicate(SinglePredicate),
129                #[prost(message, tag = "2")]
130                OrMatcher(PredicateList),
131                #[prost(message, tag = "3")]
132                AndMatcher(PredicateList),
133                #[prost(message, tag = "4")]
134                NotMatcher(::prost::alloc::boxed::Box<super::Predicate>),
135            }
136        }
137        #[allow(clippy::derive_partial_eq_without_eq)]
138        #[derive(Clone, PartialEq, ::prost::Message)]
139        pub struct FieldMatcher {
140            #[prost(message, optional, tag = "1")]
141            pub predicate: ::core::option::Option<Predicate>,
142            #[prost(message, optional, tag = "2")]
143            pub on_match: ::core::option::Option<super::OnMatch>,
144        }
145    }
146    #[allow(clippy::derive_partial_eq_without_eq)]
147    #[derive(Clone, PartialEq, ::prost::Message)]
148    pub struct MatcherTree {
149        #[prost(message, optional, tag = "1")]
150        pub input:
151            ::core::option::Option<super::super::super::super::core::v3::TypedExtensionConfig>,
152        #[prost(oneof = "matcher_tree::TreeType", tags = "2, 3, 4")]
153        pub tree_type: ::core::option::Option<matcher_tree::TreeType>,
154    }
155    /// Nested message and enum types in `MatcherTree`.
156    pub mod matcher_tree {
157        #[allow(clippy::derive_partial_eq_without_eq)]
158        #[derive(Clone, PartialEq, ::prost::Message)]
159        pub struct MatchMap {
160            #[prost(map = "string, message", tag = "1")]
161            pub map: ::std::collections::HashMap<::prost::alloc::string::String, super::OnMatch>,
162        }
163        #[allow(clippy::derive_partial_eq_without_eq)]
164        #[derive(Clone, PartialEq, ::prost::Oneof)]
165        pub enum TreeType {
166            #[prost(message, tag = "2")]
167            ExactMatchMap(MatchMap),
168            #[prost(message, tag = "3")]
169            PrefixMatchMap(MatchMap),
170            #[prost(message, tag = "4")]
171            CustomMatch(super::super::super::super::super::core::v3::TypedExtensionConfig),
172        }
173    }
174    #[allow(clippy::derive_partial_eq_without_eq)]
175    #[derive(Clone, PartialEq, ::prost::Oneof)]
176    pub enum MatcherType {
177        #[prost(message, tag = "1")]
178        MatcherList(MatcherList),
179        #[prost(message, tag = "2")]
180        MatcherTree(MatcherTree),
181    }
182}