protify 0.1.4

A Rust-first protobuf framework to generate packages from rust code, with validation included
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

#[doc(hidden)]
pub mod state;
use crate::validators::*;
pub(crate) use state::*;

/// Builder for [`MessageValidator`].
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MessageValidatorBuilder<S: State = Empty> {
	_state: PhantomData<S>,

	data: MessageValidator,
}

impl<S: State> Default for MessageValidatorBuilder<S> {
	#[inline]
	fn default() -> Self {
		Self {
			_state: PhantomData,
			data: MessageValidator::default(),
		}
	}
}

impl MessageValidator {
	#[must_use]
	#[inline]
	pub fn builder() -> MessageValidatorBuilder {
		MessageValidatorBuilder::default()
	}
}

impl<S: State> From<MessageValidatorBuilder<S>> for ProtoOption {
	#[inline(never)]
	#[cold]
	fn from(value: MessageValidatorBuilder<S>) -> Self {
		value.build().into()
	}
}

#[allow(
	clippy::must_use_candidate,
	clippy::use_self,
	clippy::return_self_not_must_use
)]
impl<S: State> MessageValidatorBuilder<S> {
	/// Adds a [`CelProgram`] to this validator.
	#[inline]
	pub fn cel(mut self, program: CelProgram) -> MessageValidatorBuilder<S> {
		self.data.cel.push(program);

		MessageValidatorBuilder {
			_state: PhantomData,
			data: self.data,
		}
	}

	/// Specifies that this validator should always be ignored.
	#[inline]
	pub fn ignore_always(mut self) -> MessageValidatorBuilder<SetIgnore<S>>
	where
		S::Ignore: IsUnset,
	{
		self.data.ignore = Ignore::Always;

		MessageValidatorBuilder {
			_state: PhantomData,
			data: self.data,
		}
	}

	/// Specifies that the field must be set in order to be valid.
	#[inline]
	pub fn required(mut self) -> MessageValidatorBuilder<SetRequired<S>>
	where
		S::Required: IsUnset,
	{
		self.data.required = true;

		MessageValidatorBuilder {
			_state: PhantomData,
			data: self.data,
		}
	}

	/// Specifies a custom error message to display for the `required` violation.
	#[inline]
	pub fn required_error_message(
		mut self,
		msg: impl Into<FixedStr>,
	) -> MessageValidatorBuilder<SetRequiredErrorMessage<S>>
	where
		S::RequiredErrorMessage: IsUnset,
		S::Required: IsSet,
	{
		self.data.required_error_message = Some(msg.into());

		MessageValidatorBuilder {
			_state: PhantomData,
			data: self.data,
		}
	}

	/// Builds the validator.
	#[inline]
	pub fn build(self) -> MessageValidator {
		self.data
	}
}