efm32gg11b840_pac/wtimer3/
routeloc0.rs1#[doc = "Register `ROUTELOC0` reader"]
2pub struct R(crate::R<ROUTELOC0_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<ROUTELOC0_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<ROUTELOC0_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<ROUTELOC0_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `ROUTELOC0` writer"]
17pub struct W(crate::W<ROUTELOC0_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<ROUTELOC0_SPEC>;
20 #[inline(always)]
21 fn deref(&self) -> &Self::Target {
22 &self.0
23 }
24}
25impl core::ops::DerefMut for W {
26 #[inline(always)]
27 fn deref_mut(&mut self) -> &mut Self::Target {
28 &mut self.0
29 }
30}
31impl From<crate::W<ROUTELOC0_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<ROUTELOC0_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "I/O Location\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39#[repr(u8)]
40pub enum CC0LOC_A {
41 #[doc = "0: Location 0"]
42 LOC0 = 0,
43 #[doc = "1: Location 1"]
44 LOC1 = 1,
45 #[doc = "2: Location 2"]
46 LOC2 = 2,
47 #[doc = "3: Location 3"]
48 LOC3 = 3,
49 #[doc = "4: Location 4"]
50 LOC4 = 4,
51 #[doc = "5: Location 5"]
52 LOC5 = 5,
53 #[doc = "6: Location 6"]
54 LOC6 = 6,
55 #[doc = "7: Location 7"]
56 LOC7 = 7,
57}
58impl From<CC0LOC_A> for u8 {
59 #[inline(always)]
60 fn from(variant: CC0LOC_A) -> Self {
61 variant as _
62 }
63}
64#[doc = "Field `CC0LOC` reader - I/O Location"]
65pub type CC0LOC_R = crate::FieldReader<u8, CC0LOC_A>;
66impl CC0LOC_R {
67 #[doc = "Get enumerated values variant"]
68 #[inline(always)]
69 pub fn variant(&self) -> Option<CC0LOC_A> {
70 match self.bits {
71 0 => Some(CC0LOC_A::LOC0),
72 1 => Some(CC0LOC_A::LOC1),
73 2 => Some(CC0LOC_A::LOC2),
74 3 => Some(CC0LOC_A::LOC3),
75 4 => Some(CC0LOC_A::LOC4),
76 5 => Some(CC0LOC_A::LOC5),
77 6 => Some(CC0LOC_A::LOC6),
78 7 => Some(CC0LOC_A::LOC7),
79 _ => None,
80 }
81 }
82 #[doc = "Checks if the value of the field is `LOC0`"]
83 #[inline(always)]
84 pub fn is_loc0(&self) -> bool {
85 *self == CC0LOC_A::LOC0
86 }
87 #[doc = "Checks if the value of the field is `LOC1`"]
88 #[inline(always)]
89 pub fn is_loc1(&self) -> bool {
90 *self == CC0LOC_A::LOC1
91 }
92 #[doc = "Checks if the value of the field is `LOC2`"]
93 #[inline(always)]
94 pub fn is_loc2(&self) -> bool {
95 *self == CC0LOC_A::LOC2
96 }
97 #[doc = "Checks if the value of the field is `LOC3`"]
98 #[inline(always)]
99 pub fn is_loc3(&self) -> bool {
100 *self == CC0LOC_A::LOC3
101 }
102 #[doc = "Checks if the value of the field is `LOC4`"]
103 #[inline(always)]
104 pub fn is_loc4(&self) -> bool {
105 *self == CC0LOC_A::LOC4
106 }
107 #[doc = "Checks if the value of the field is `LOC5`"]
108 #[inline(always)]
109 pub fn is_loc5(&self) -> bool {
110 *self == CC0LOC_A::LOC5
111 }
112 #[doc = "Checks if the value of the field is `LOC6`"]
113 #[inline(always)]
114 pub fn is_loc6(&self) -> bool {
115 *self == CC0LOC_A::LOC6
116 }
117 #[doc = "Checks if the value of the field is `LOC7`"]
118 #[inline(always)]
119 pub fn is_loc7(&self) -> bool {
120 *self == CC0LOC_A::LOC7
121 }
122}
123#[doc = "Field `CC0LOC` writer - I/O Location"]
124pub type CC0LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC0LOC_A, 6, 0>;
125impl<'a> CC0LOC_W<'a> {
126 #[doc = "Location 0"]
127 #[inline(always)]
128 pub fn loc0(self) -> &'a mut W {
129 self.variant(CC0LOC_A::LOC0)
130 }
131 #[doc = "Location 1"]
132 #[inline(always)]
133 pub fn loc1(self) -> &'a mut W {
134 self.variant(CC0LOC_A::LOC1)
135 }
136 #[doc = "Location 2"]
137 #[inline(always)]
138 pub fn loc2(self) -> &'a mut W {
139 self.variant(CC0LOC_A::LOC2)
140 }
141 #[doc = "Location 3"]
142 #[inline(always)]
143 pub fn loc3(self) -> &'a mut W {
144 self.variant(CC0LOC_A::LOC3)
145 }
146 #[doc = "Location 4"]
147 #[inline(always)]
148 pub fn loc4(self) -> &'a mut W {
149 self.variant(CC0LOC_A::LOC4)
150 }
151 #[doc = "Location 5"]
152 #[inline(always)]
153 pub fn loc5(self) -> &'a mut W {
154 self.variant(CC0LOC_A::LOC5)
155 }
156 #[doc = "Location 6"]
157 #[inline(always)]
158 pub fn loc6(self) -> &'a mut W {
159 self.variant(CC0LOC_A::LOC6)
160 }
161 #[doc = "Location 7"]
162 #[inline(always)]
163 pub fn loc7(self) -> &'a mut W {
164 self.variant(CC0LOC_A::LOC7)
165 }
166}
167#[doc = "I/O Location\n\nValue on reset: 0"]
168#[derive(Clone, Copy, Debug, PartialEq)]
169#[repr(u8)]
170pub enum CC1LOC_A {
171 #[doc = "0: Location 0"]
172 LOC0 = 0,
173 #[doc = "1: Location 1"]
174 LOC1 = 1,
175 #[doc = "2: Location 2"]
176 LOC2 = 2,
177 #[doc = "3: Location 3"]
178 LOC3 = 3,
179 #[doc = "4: Location 4"]
180 LOC4 = 4,
181 #[doc = "5: Location 5"]
182 LOC5 = 5,
183 #[doc = "6: Location 6"]
184 LOC6 = 6,
185 #[doc = "7: Location 7"]
186 LOC7 = 7,
187}
188impl From<CC1LOC_A> for u8 {
189 #[inline(always)]
190 fn from(variant: CC1LOC_A) -> Self {
191 variant as _
192 }
193}
194#[doc = "Field `CC1LOC` reader - I/O Location"]
195pub type CC1LOC_R = crate::FieldReader<u8, CC1LOC_A>;
196impl CC1LOC_R {
197 #[doc = "Get enumerated values variant"]
198 #[inline(always)]
199 pub fn variant(&self) -> Option<CC1LOC_A> {
200 match self.bits {
201 0 => Some(CC1LOC_A::LOC0),
202 1 => Some(CC1LOC_A::LOC1),
203 2 => Some(CC1LOC_A::LOC2),
204 3 => Some(CC1LOC_A::LOC3),
205 4 => Some(CC1LOC_A::LOC4),
206 5 => Some(CC1LOC_A::LOC5),
207 6 => Some(CC1LOC_A::LOC6),
208 7 => Some(CC1LOC_A::LOC7),
209 _ => None,
210 }
211 }
212 #[doc = "Checks if the value of the field is `LOC0`"]
213 #[inline(always)]
214 pub fn is_loc0(&self) -> bool {
215 *self == CC1LOC_A::LOC0
216 }
217 #[doc = "Checks if the value of the field is `LOC1`"]
218 #[inline(always)]
219 pub fn is_loc1(&self) -> bool {
220 *self == CC1LOC_A::LOC1
221 }
222 #[doc = "Checks if the value of the field is `LOC2`"]
223 #[inline(always)]
224 pub fn is_loc2(&self) -> bool {
225 *self == CC1LOC_A::LOC2
226 }
227 #[doc = "Checks if the value of the field is `LOC3`"]
228 #[inline(always)]
229 pub fn is_loc3(&self) -> bool {
230 *self == CC1LOC_A::LOC3
231 }
232 #[doc = "Checks if the value of the field is `LOC4`"]
233 #[inline(always)]
234 pub fn is_loc4(&self) -> bool {
235 *self == CC1LOC_A::LOC4
236 }
237 #[doc = "Checks if the value of the field is `LOC5`"]
238 #[inline(always)]
239 pub fn is_loc5(&self) -> bool {
240 *self == CC1LOC_A::LOC5
241 }
242 #[doc = "Checks if the value of the field is `LOC6`"]
243 #[inline(always)]
244 pub fn is_loc6(&self) -> bool {
245 *self == CC1LOC_A::LOC6
246 }
247 #[doc = "Checks if the value of the field is `LOC7`"]
248 #[inline(always)]
249 pub fn is_loc7(&self) -> bool {
250 *self == CC1LOC_A::LOC7
251 }
252}
253#[doc = "Field `CC1LOC` writer - I/O Location"]
254pub type CC1LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC1LOC_A, 6, 8>;
255impl<'a> CC1LOC_W<'a> {
256 #[doc = "Location 0"]
257 #[inline(always)]
258 pub fn loc0(self) -> &'a mut W {
259 self.variant(CC1LOC_A::LOC0)
260 }
261 #[doc = "Location 1"]
262 #[inline(always)]
263 pub fn loc1(self) -> &'a mut W {
264 self.variant(CC1LOC_A::LOC1)
265 }
266 #[doc = "Location 2"]
267 #[inline(always)]
268 pub fn loc2(self) -> &'a mut W {
269 self.variant(CC1LOC_A::LOC2)
270 }
271 #[doc = "Location 3"]
272 #[inline(always)]
273 pub fn loc3(self) -> &'a mut W {
274 self.variant(CC1LOC_A::LOC3)
275 }
276 #[doc = "Location 4"]
277 #[inline(always)]
278 pub fn loc4(self) -> &'a mut W {
279 self.variant(CC1LOC_A::LOC4)
280 }
281 #[doc = "Location 5"]
282 #[inline(always)]
283 pub fn loc5(self) -> &'a mut W {
284 self.variant(CC1LOC_A::LOC5)
285 }
286 #[doc = "Location 6"]
287 #[inline(always)]
288 pub fn loc6(self) -> &'a mut W {
289 self.variant(CC1LOC_A::LOC6)
290 }
291 #[doc = "Location 7"]
292 #[inline(always)]
293 pub fn loc7(self) -> &'a mut W {
294 self.variant(CC1LOC_A::LOC7)
295 }
296}
297#[doc = "I/O Location\n\nValue on reset: 0"]
298#[derive(Clone, Copy, Debug, PartialEq)]
299#[repr(u8)]
300pub enum CC2LOC_A {
301 #[doc = "0: Location 0"]
302 LOC0 = 0,
303 #[doc = "1: Location 1"]
304 LOC1 = 1,
305 #[doc = "2: Location 2"]
306 LOC2 = 2,
307 #[doc = "3: Location 3"]
308 LOC3 = 3,
309 #[doc = "4: Location 4"]
310 LOC4 = 4,
311 #[doc = "5: Location 5"]
312 LOC5 = 5,
313 #[doc = "6: Location 6"]
314 LOC6 = 6,
315 #[doc = "7: Location 7"]
316 LOC7 = 7,
317}
318impl From<CC2LOC_A> for u8 {
319 #[inline(always)]
320 fn from(variant: CC2LOC_A) -> Self {
321 variant as _
322 }
323}
324#[doc = "Field `CC2LOC` reader - I/O Location"]
325pub type CC2LOC_R = crate::FieldReader<u8, CC2LOC_A>;
326impl CC2LOC_R {
327 #[doc = "Get enumerated values variant"]
328 #[inline(always)]
329 pub fn variant(&self) -> Option<CC2LOC_A> {
330 match self.bits {
331 0 => Some(CC2LOC_A::LOC0),
332 1 => Some(CC2LOC_A::LOC1),
333 2 => Some(CC2LOC_A::LOC2),
334 3 => Some(CC2LOC_A::LOC3),
335 4 => Some(CC2LOC_A::LOC4),
336 5 => Some(CC2LOC_A::LOC5),
337 6 => Some(CC2LOC_A::LOC6),
338 7 => Some(CC2LOC_A::LOC7),
339 _ => None,
340 }
341 }
342 #[doc = "Checks if the value of the field is `LOC0`"]
343 #[inline(always)]
344 pub fn is_loc0(&self) -> bool {
345 *self == CC2LOC_A::LOC0
346 }
347 #[doc = "Checks if the value of the field is `LOC1`"]
348 #[inline(always)]
349 pub fn is_loc1(&self) -> bool {
350 *self == CC2LOC_A::LOC1
351 }
352 #[doc = "Checks if the value of the field is `LOC2`"]
353 #[inline(always)]
354 pub fn is_loc2(&self) -> bool {
355 *self == CC2LOC_A::LOC2
356 }
357 #[doc = "Checks if the value of the field is `LOC3`"]
358 #[inline(always)]
359 pub fn is_loc3(&self) -> bool {
360 *self == CC2LOC_A::LOC3
361 }
362 #[doc = "Checks if the value of the field is `LOC4`"]
363 #[inline(always)]
364 pub fn is_loc4(&self) -> bool {
365 *self == CC2LOC_A::LOC4
366 }
367 #[doc = "Checks if the value of the field is `LOC5`"]
368 #[inline(always)]
369 pub fn is_loc5(&self) -> bool {
370 *self == CC2LOC_A::LOC5
371 }
372 #[doc = "Checks if the value of the field is `LOC6`"]
373 #[inline(always)]
374 pub fn is_loc6(&self) -> bool {
375 *self == CC2LOC_A::LOC6
376 }
377 #[doc = "Checks if the value of the field is `LOC7`"]
378 #[inline(always)]
379 pub fn is_loc7(&self) -> bool {
380 *self == CC2LOC_A::LOC7
381 }
382}
383#[doc = "Field `CC2LOC` writer - I/O Location"]
384pub type CC2LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC2LOC_A, 6, 16>;
385impl<'a> CC2LOC_W<'a> {
386 #[doc = "Location 0"]
387 #[inline(always)]
388 pub fn loc0(self) -> &'a mut W {
389 self.variant(CC2LOC_A::LOC0)
390 }
391 #[doc = "Location 1"]
392 #[inline(always)]
393 pub fn loc1(self) -> &'a mut W {
394 self.variant(CC2LOC_A::LOC1)
395 }
396 #[doc = "Location 2"]
397 #[inline(always)]
398 pub fn loc2(self) -> &'a mut W {
399 self.variant(CC2LOC_A::LOC2)
400 }
401 #[doc = "Location 3"]
402 #[inline(always)]
403 pub fn loc3(self) -> &'a mut W {
404 self.variant(CC2LOC_A::LOC3)
405 }
406 #[doc = "Location 4"]
407 #[inline(always)]
408 pub fn loc4(self) -> &'a mut W {
409 self.variant(CC2LOC_A::LOC4)
410 }
411 #[doc = "Location 5"]
412 #[inline(always)]
413 pub fn loc5(self) -> &'a mut W {
414 self.variant(CC2LOC_A::LOC5)
415 }
416 #[doc = "Location 6"]
417 #[inline(always)]
418 pub fn loc6(self) -> &'a mut W {
419 self.variant(CC2LOC_A::LOC6)
420 }
421 #[doc = "Location 7"]
422 #[inline(always)]
423 pub fn loc7(self) -> &'a mut W {
424 self.variant(CC2LOC_A::LOC7)
425 }
426}
427#[doc = "I/O Location\n\nValue on reset: 0"]
428#[derive(Clone, Copy, Debug, PartialEq)]
429#[repr(u8)]
430pub enum CC3LOC_A {
431 #[doc = "0: Location 0"]
432 LOC0 = 0,
433 #[doc = "1: Location 1"]
434 LOC1 = 1,
435 #[doc = "2: Location 2"]
436 LOC2 = 2,
437 #[doc = "3: Location 3"]
438 LOC3 = 3,
439 #[doc = "4: Location 4"]
440 LOC4 = 4,
441 #[doc = "5: Location 5"]
442 LOC5 = 5,
443 #[doc = "6: Location 6"]
444 LOC6 = 6,
445 #[doc = "7: Location 7"]
446 LOC7 = 7,
447}
448impl From<CC3LOC_A> for u8 {
449 #[inline(always)]
450 fn from(variant: CC3LOC_A) -> Self {
451 variant as _
452 }
453}
454#[doc = "Field `CC3LOC` reader - I/O Location"]
455pub type CC3LOC_R = crate::FieldReader<u8, CC3LOC_A>;
456impl CC3LOC_R {
457 #[doc = "Get enumerated values variant"]
458 #[inline(always)]
459 pub fn variant(&self) -> Option<CC3LOC_A> {
460 match self.bits {
461 0 => Some(CC3LOC_A::LOC0),
462 1 => Some(CC3LOC_A::LOC1),
463 2 => Some(CC3LOC_A::LOC2),
464 3 => Some(CC3LOC_A::LOC3),
465 4 => Some(CC3LOC_A::LOC4),
466 5 => Some(CC3LOC_A::LOC5),
467 6 => Some(CC3LOC_A::LOC6),
468 7 => Some(CC3LOC_A::LOC7),
469 _ => None,
470 }
471 }
472 #[doc = "Checks if the value of the field is `LOC0`"]
473 #[inline(always)]
474 pub fn is_loc0(&self) -> bool {
475 *self == CC3LOC_A::LOC0
476 }
477 #[doc = "Checks if the value of the field is `LOC1`"]
478 #[inline(always)]
479 pub fn is_loc1(&self) -> bool {
480 *self == CC3LOC_A::LOC1
481 }
482 #[doc = "Checks if the value of the field is `LOC2`"]
483 #[inline(always)]
484 pub fn is_loc2(&self) -> bool {
485 *self == CC3LOC_A::LOC2
486 }
487 #[doc = "Checks if the value of the field is `LOC3`"]
488 #[inline(always)]
489 pub fn is_loc3(&self) -> bool {
490 *self == CC3LOC_A::LOC3
491 }
492 #[doc = "Checks if the value of the field is `LOC4`"]
493 #[inline(always)]
494 pub fn is_loc4(&self) -> bool {
495 *self == CC3LOC_A::LOC4
496 }
497 #[doc = "Checks if the value of the field is `LOC5`"]
498 #[inline(always)]
499 pub fn is_loc5(&self) -> bool {
500 *self == CC3LOC_A::LOC5
501 }
502 #[doc = "Checks if the value of the field is `LOC6`"]
503 #[inline(always)]
504 pub fn is_loc6(&self) -> bool {
505 *self == CC3LOC_A::LOC6
506 }
507 #[doc = "Checks if the value of the field is `LOC7`"]
508 #[inline(always)]
509 pub fn is_loc7(&self) -> bool {
510 *self == CC3LOC_A::LOC7
511 }
512}
513#[doc = "Field `CC3LOC` writer - I/O Location"]
514pub type CC3LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC3LOC_A, 6, 24>;
515impl<'a> CC3LOC_W<'a> {
516 #[doc = "Location 0"]
517 #[inline(always)]
518 pub fn loc0(self) -> &'a mut W {
519 self.variant(CC3LOC_A::LOC0)
520 }
521 #[doc = "Location 1"]
522 #[inline(always)]
523 pub fn loc1(self) -> &'a mut W {
524 self.variant(CC3LOC_A::LOC1)
525 }
526 #[doc = "Location 2"]
527 #[inline(always)]
528 pub fn loc2(self) -> &'a mut W {
529 self.variant(CC3LOC_A::LOC2)
530 }
531 #[doc = "Location 3"]
532 #[inline(always)]
533 pub fn loc3(self) -> &'a mut W {
534 self.variant(CC3LOC_A::LOC3)
535 }
536 #[doc = "Location 4"]
537 #[inline(always)]
538 pub fn loc4(self) -> &'a mut W {
539 self.variant(CC3LOC_A::LOC4)
540 }
541 #[doc = "Location 5"]
542 #[inline(always)]
543 pub fn loc5(self) -> &'a mut W {
544 self.variant(CC3LOC_A::LOC5)
545 }
546 #[doc = "Location 6"]
547 #[inline(always)]
548 pub fn loc6(self) -> &'a mut W {
549 self.variant(CC3LOC_A::LOC6)
550 }
551 #[doc = "Location 7"]
552 #[inline(always)]
553 pub fn loc7(self) -> &'a mut W {
554 self.variant(CC3LOC_A::LOC7)
555 }
556}
557impl R {
558 #[doc = "Bits 0:5 - I/O Location"]
559 #[inline(always)]
560 pub fn cc0loc(&self) -> CC0LOC_R {
561 CC0LOC_R::new((self.bits & 0x3f) as u8)
562 }
563 #[doc = "Bits 8:13 - I/O Location"]
564 #[inline(always)]
565 pub fn cc1loc(&self) -> CC1LOC_R {
566 CC1LOC_R::new(((self.bits >> 8) & 0x3f) as u8)
567 }
568 #[doc = "Bits 16:21 - I/O Location"]
569 #[inline(always)]
570 pub fn cc2loc(&self) -> CC2LOC_R {
571 CC2LOC_R::new(((self.bits >> 16) & 0x3f) as u8)
572 }
573 #[doc = "Bits 24:29 - I/O Location"]
574 #[inline(always)]
575 pub fn cc3loc(&self) -> CC3LOC_R {
576 CC3LOC_R::new(((self.bits >> 24) & 0x3f) as u8)
577 }
578}
579impl W {
580 #[doc = "Bits 0:5 - I/O Location"]
581 #[inline(always)]
582 pub fn cc0loc(&mut self) -> CC0LOC_W {
583 CC0LOC_W::new(self)
584 }
585 #[doc = "Bits 8:13 - I/O Location"]
586 #[inline(always)]
587 pub fn cc1loc(&mut self) -> CC1LOC_W {
588 CC1LOC_W::new(self)
589 }
590 #[doc = "Bits 16:21 - I/O Location"]
591 #[inline(always)]
592 pub fn cc2loc(&mut self) -> CC2LOC_W {
593 CC2LOC_W::new(self)
594 }
595 #[doc = "Bits 24:29 - I/O Location"]
596 #[inline(always)]
597 pub fn cc3loc(&mut self) -> CC3LOC_W {
598 CC3LOC_W::new(self)
599 }
600 #[doc = "Writes raw bits to the register."]
601 #[inline(always)]
602 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
603 self.0.bits(bits);
604 self
605 }
606}
607#[doc = "I/O Routing Location Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [routeloc0](index.html) module"]
608pub struct ROUTELOC0_SPEC;
609impl crate::RegisterSpec for ROUTELOC0_SPEC {
610 type Ux = u32;
611}
612#[doc = "`read()` method returns [routeloc0::R](R) reader structure"]
613impl crate::Readable for ROUTELOC0_SPEC {
614 type Reader = R;
615}
616#[doc = "`write(|w| ..)` method takes [routeloc0::W](W) writer structure"]
617impl crate::Writable for ROUTELOC0_SPEC {
618 type Writer = W;
619}
620#[doc = "`reset()` method sets ROUTELOC0 to value 0"]
621impl crate::Resettable for ROUTELOC0_SPEC {
622 #[inline(always)]
623 fn reset_value() -> Self::Ux {
624 0
625 }
626}