pub fn regex_predicate(
        self,
        tag_key_name: impl Into<String>,
        pattern: impl Into<String>,
        comparison: Comparison,
    ) -> Self {
        let predicate = Predicate {
            root: Some(Node {
                node_type: NodeType::ComparisonExpression as i32,
                children: vec![
                    Node {
                        node_type: NodeType::TagRef as i32,
                        children: vec![],
                        value: Some(Value::TagRefValue(tag_key_name.into().into())),
                    },
                    Node {
                        node_type: NodeType::Literal as i32,
                        children: vec![],
                        value: Some(Value::RegexValue(pattern.into())),
                    },
                ],
                value: Some(Value::Comparison(comparison as _)),
            }),
        };
        self.predicate(predicate)
    }
/// Set predicate to tag_name <op> /pattern/
///
/// where op is `Regex` or `NotRegEx`
/// The constitution of this request was formed by looking at a real request
/// made to storage, which looked like this:
///
/// root:<
///         node_type:COMPARISON_EXPRESSION
///         children:<node_type:TAG_REF tag_ref_value:"tag_key_name" >
///         children:<node_type:LITERAL regex_value:"pattern" >
///         comparison:REGEX
/// >
Set predicate to tag_name  /pattern
where op is `Regex` or `NotRegEx`
The constitution of this request was formed by looking at a real request
made to storage, which looked like this.


Set predicate to tag_name / pattern where op is ` Regex ` or ` NotRegEx ` The constitution of this request was formed by looking at a real request made to storage which looked like this .
pub fn regex_predicate(
        self,
        tag_key_name: impl Into<String>,
        pattern: impl Into<String>,
        comparison: Comparison,
    ) -> Self {
        let predicate = Predicate {
            root: Some(Node {
                node_type: NodeType::ComparisonExpression as i32,
                children: vec![
                    Node {
                        node_type: NodeType::TagRef as i32,
                        children: vec![],
                        value: Some(Value::TagRefValue(tag_key_name.into().into())),
                    },
                    Node {
                        node_type: NodeType::Literal as i32,
                        children: vec![],
                        value: Some(Value::RegexValue(pattern.into())),
                    },
                ],
                value: Some(Value::Comparison(comparison as _)),
            }),
        };
        self.predicate(predicate)
    }
pub fn regex_predicate ( self , tag_key_name : impl Into < String > , pattern : impl Into < String > , comparison : Comparison , ) -> Self { let predicate = Predicate { root : Some ( Node { node_type : NodeType :: ComparisonExpression as i32 , children : vec ! [ Node { node_type NodeType TagRef as i32 children vec [ ] value Some ( Value TagRefValue ( tag_key_name into ( ) into ( ) ) ) } Node { node_type NodeType Literal as i32 children vec [ ] value Some ( Value RegexValue ( pattern into ( ) ) ) } ] , value : Some ( Value :: Comparison ( comparison as _ ) ) , } ) , } ; self . predicate ( predicate ) }
Set predicate to tag_name <op> /pattern
where op is `Regex` or `NotRegEx`
The constitution of this request was formed by looking at a real request
made to storage, which looked like this:
Set predicate to tag_name <op > / pattern where op is ` Regex ` or ` NotRegEx ` The constitution of this request was formed by looking at a real request made to storage which looked like this :
self
tag_key_name
impl Into<String>
pattern
impl Into<String>
comparison
Comparison
self
tag_key_name
impl Into<String>
pattern
impl Into<String>
comparison
Comparison