proto-types 0.1.0

Rust types generated from the google.protobuf and buf.validate protobuf packages, plus extra helpers for implementing validation with the protocheck crate.
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
135
136
137
138
139

#![allow(clippy::len_without_is_empty)]
include!("./buf.validate.rs");

use crate::protovalidate::field_path_element::Subscript;

#[cfg(feature = "protocheck")]
mod length_rules;

#[cfg(feature = "protocheck")]
pub use length_rules::*;

#[cfg(feature = "protocheck")]
mod substring_rules;

#[cfg(feature = "protocheck")]
pub use substring_rules::*;

#[cfg(feature = "protocheck")]
mod comparable_rules;

#[cfg(feature = "protocheck")]
mod containing_rules;

#[cfg(feature = "protocheck")]
mod into_comparable;

#[cfg(feature = "protocheck")]
mod numeric_rules;

#[cfg(feature = "protocheck")]
mod rule_matching;

#[cfg(feature = "protocheck")]
mod const_rules;

#[cfg(feature = "protocheck")]
pub use const_rules::*;

mod violations;

use std::fmt::{self, Display};

#[cfg(feature = "protocheck")]
pub use comparable_rules::*;
#[cfg(feature = "protocheck")]
pub use containing_rules::{ContainingRules, ItemList};
#[cfg(feature = "protocheck")]
pub use numeric_rules::NumericRules;

impl Display for Subscript {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    match self {
      Subscript::Index(val) => write!(f, "{}", val),
      Subscript::BoolKey(val) => write!(f, "{}", val),
      Subscript::IntKey(val) => write!(f, "{}", val),
      Subscript::UintKey(val) => write!(f, "{}", val),
      Subscript::StringKey(val) => write!(f, "{}", val),
    }
  }
}

#[cfg(feature = "totokens")]
mod totokens {
  use proc_macro2::TokenStream;
  use quote::{quote, ToTokens};

  use crate::protovalidate::{field_path_element::Subscript, FieldPathElement, Ignore};

  impl ToTokens for Ignore {
    fn to_tokens(&self, tokens: &mut TokenStream) {
      let path = quote! { ::protocheck::types::protovalidate::Ignore };

      match self {
        Ignore::Unspecified => tokens.extend(quote! { #path::Unspecified }),
        Ignore::IfZeroValue => tokens.extend(quote! { #path::IfZeroValue }),
        Ignore::Always => tokens.extend(quote! { #path::Always }),
      }
    }
  }

  impl ToTokens for Subscript {
    fn to_tokens(&self, tokens: &mut TokenStream) {
      match self {
        Subscript::Index(value) => {
          tokens.extend(quote! {
              ::protocheck::types::protovalidate::Subscript::Index(#value)
          });
        }
        Subscript::BoolKey(value) => {
          tokens.extend(quote! {
              ::protocheck::types::protovalidate::Subscript::BoolKey(#value)
          });
        }
        Subscript::IntKey(value) => {
          tokens.extend(quote! {
              ::protocheck::types::protovalidate::Subscript::IntKey(#value)
          });
        }
        Subscript::UintKey(value) => {
          tokens.extend(quote! {
              ::protocheck::types::protovalidate::Subscript::UintKey(#value)
          });
        }
        Subscript::StringKey(value) => {
          tokens.extend(quote! {
              ::protocheck::types::protovalidate::Subscript::StringKey(#value)
          });
        }
      }
    }
  }

  impl ToTokens for FieldPathElement {
    fn to_tokens(&self, tokens: &mut TokenStream) {
      let field_number = &self.field_number;
      let field_name = &self.field_name;
      let field_type = &self.field_type;
      let key_type = &self.key_type;
      let value_type = &self.value_type;
      let subscript = &self.subscript;

      let field_name_expr = match field_name {
        Some(name_str) => quote! { Some(#name_str.clone()) },
        None => quote! { None },
      };

      tokens.extend(quote! {
        ::protocheck::types::protovalidate::FieldPathElement {
          field_number: #field_number,
          field_name: #field_name_expr,
          field_type: #field_type,
          key_type: #key_type,
          value_type: #value_type,
          subscript: #subscript,
        }
      });
    }
  }
}