History

Renamed folders and separated GSF.Media and GSF.Net into separate projects.

StephenCWills committed 14 years ago

Commit ac1ef661 parent 45bce55628 files · +733 −461Browse files

Showing the changes to Source/Libraries/GSF.Core/BitExtensions.cs (1 of 628 files). Show all

Unified · Split

Source/Libraries/GSF.Core/BitExtensions.cs+2894−0
@@ -0,0 +1,2894 @@
1//******************************************************************************************************
2// BitExtensions.cs - Gbtc
3//
4// Copyright © 2010, Grid Protection Alliance. All Rights Reserved.
5//
6// Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
7// the NOTICE file distributed with this work for additional information regarding copyright ownership.
8// The GPA licenses this file to you under the Eclipse Public License -v 1.0 (the "License"); you may
9// not use this file except in compliance with the License. You may obtain a copy of the License at:
10//
11// http://www.opensource.org/licenses/eclipse-1.0.php
12//
13// Unless agreed to in writing, the subject software distributed under the License is distributed on an
14// "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
15// License for the specific language governing permissions and limitations.
16//
17// Code Modification History:
18// ----------------------------------------------------------------------------------------------------
19// 01/25/2008 - J. Ritchie Carroll
20// Initial version of source generated.
21// 09/14/2009 - Stephen C. Wills
22// Added new header and license agreement.
23// 10/8/2012 - Danyelle Gilliam
24// Modified Header
25//
26//******************************************************************************************************
27
28
29
30
31#region [ Contributor License Agreements ]
32
33/**************************************************************************\
34 Copyright © 2009 - J. Ritchie Carroll, Pinal C. Patel
35 All rights reserved.
36
37 Redistribution and use in source and binary forms, with or without
38 modification, are permitted provided that the following conditions
39 are met:
40
41 * Redistributions of source code must retain the above copyright
42 notice, this list of conditions and the following disclaimer.
43
44 * Redistributions in binary form must reproduce the above
45 copyright notice, this list of conditions and the following
46 disclaimer in the documentation and/or other materials provided
47 with the distribution.
48
49 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
50 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
52 PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
53 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
54 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
55 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
56 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
57 OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
58 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
59 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
60
61\**************************************************************************/
62
63#endregion
64
65using System;
66
67namespace GSF
68{
69 #region [ Enumerations ]
70
71 /// <summary>
72 /// Represents bits in a signed or unsigned integer value.
73 /// </summary>
74 [Flags(), CLSCompliant(false)]
75 public enum Bits : ulong
76 {
77 /// <summary>No bits set (0x0000000000000000)</summary>
78 Nil = 0x00000000,
79
80 // Byte 0, Bits 0-7
81
82 /// <summary>Bit 00 (0x0000000000000001)</summary>
83 Bit00 = 0x00000001, // 00000001 = 1
84
85 /// <summary>Bit 01 (0x0000000000000002)</summary>
86 Bit01 = Bit00 << 1, // 00000010 = 2
87
88 /// <summary>Bit 02 (0x0000000000000004)</summary>
89 Bit02 = Bit01 << 1, // 00000100 = 4
90
91 /// <summary>Bit 03 (0x0000000000000008)</summary>
92 Bit03 = Bit02 << 1, // 00001000 = 8
93
94 /// <summary>Bit 04 (0x0000000000000010)</summary>
95 Bit04 = Bit03 << 1, // 00010000 = 16
96
97 /// <summary>Bit 05 (0x0000000000000020)</summary>
98 Bit05 = Bit04 << 1, // 00100000 = 32
99
100 /// <summary>Bit 06 (0x0000000000000040)</summary>
101 Bit06 = Bit05 << 1, // 01000000 = 64
102
103 /// <summary>Bit 07 (0x0000000000000080)</summary>
104 Bit07 = Bit06 << 1, // 10000000 = 128
105
106 // Byte 1, Bits 8-15
107
108 /// <summary>Bit 08 (0x0000000000000100)</summary>
109 Bit08 = Bit07 << 1,
110
111 /// <summary>Bit 09 (0x0000000000000200)</summary>
112 Bit09 = Bit08 << 1,
113
114 /// <summary>Bit 10 (0x0000000000000400)</summary>
115 Bit10 = Bit09 << 1,
116
117 /// <summary>Bit 11 (0x0000000000000800)</summary>
118 Bit11 = Bit10 << 1,
119
120 /// <summary>Bit 12 (0x0000000000001000)</summary>
121 Bit12 = Bit11 << 1,
122
123 /// <summary>Bit 13 (0x0000000000002000)</summary>
124 Bit13 = Bit12 << 1,
125
126 /// <summary>Bit 14 (0x0000000000004000)</summary>
127 Bit14 = Bit13 << 1,
128
129 /// <summary>Bit 15 (0x0000000000008000)</summary>
130 Bit15 = Bit14 << 1,
131
132 // Byte 2, Bits 16-23
133
134 /// <summary>Bit 16 (0x0000000000010000)</summary>
135 Bit16 = Bit15 << 1,
136
137 /// <summary>Bit 17 (0x0000000000020000)</summary>
138 Bit17 = Bit16 << 1,
139
140 /// <summary>Bit 18 (0x0000000000040000)</summary>
141 Bit18 = Bit17 << 1,
142
143 /// <summary>Bit 19 (0x0000000000080000)</summary>
144 Bit19 = Bit18 << 1,
145
146 /// <summary>Bit 20 (0x0000000000100000)</summary>
147 Bit20 = Bit19 << 1,
148
149 /// <summary>Bit 21 (0x0000000000200000)</summary>
150 Bit21 = Bit20 << 1,
151
152 /// <summary>Bit 22 (0x0000000000400000)</summary>
153 Bit22 = Bit21 << 1,
154
155 /// <summary>Bit 23 (0x0000000000800000)</summary>
156 Bit23 = Bit22 << 1,
157
158 // Byte 3, Bits 24-31
159
160 /// <summary>Bit 24 (0x0000000001000000)</summary>
161 Bit24 = Bit23 << 1,
162
163 /// <summary>Bit 25 (0x0000000002000000)</summary>
164 Bit25 = Bit24 << 1,
165
166 /// <summary>Bit 26 (0x0000000004000000)</summary>
167 Bit26 = Bit25 << 1,
168
169 /// <summary>Bit 27 (0x0000000008000000)</summary>
170 Bit27 = Bit26 << 1,
171
172 /// <summary>Bit 28 (0x0000000010000000)</summary>
173 Bit28 = Bit27 << 1,
174
175 /// <summary>Bit 29 (0x0000000020000000)</summary>
176 Bit29 = Bit28 << 1,
177
178 /// <summary>Bit 30 (0x0000000040000000)</summary>
179 Bit30 = Bit29 << 1,
180
181 /// <summary>Bit 31 (0x0000000080000000)</summary>
182 Bit31 = Bit30 << 1,
183
184 // Byte 4, Bits 32-39
185
186 /// <summary>Bit 32 (0x0000000100000000)</summary>
187 Bit32 = Bit31 << 1,
188
189 /// <summary>Bit 33 (0x0000000200000000)</summary>
190 Bit33 = Bit32 << 1,
191
192 /// <summary>Bit 34 (0x0000000400000000)</summary>
193 Bit34 = Bit33 << 1,
194
195 /// <summary>Bit 35 (0x0000000800000000)</summary>
196 Bit35 = Bit34 << 1,
197
198 /// <summary>Bit 36 (0x0000001000000000)</summary>
199 Bit36 = Bit35 << 1,
200
201 /// <summary>Bit 37 (0x0000002000000000)</summary>
202 Bit37 = Bit36 << 1,
203
204 /// <summary>Bit 38 (0x0000004000000000)</summary>
205 Bit38 = Bit37 << 1,
206
207 /// <summary>Bit 39 (0x0000008000000000)</summary>
208 Bit39 = Bit38 << 1,
209
210 // Byte 5, Bits 40-47
211
212 /// <summary>Bit 40 (0x0000010000000000)</summary>
213 Bit40 = Bit39 << 1,
214
215 /// <summary>Bit 41 (0x0000020000000000)</summary>
216 Bit41 = Bit40 << 1,
217
218 /// <summary>Bit 42 (0x0000040000000000)</summary>
219 Bit42 = Bit41 << 1,
220
221 /// <summary>Bit 43 (0x0000080000000000)</summary>
222 Bit43 = Bit42 << 1,
223
224 /// <summary>Bit 44 (0x0000100000000000)</summary>
225 Bit44 = Bit43 << 1,
226
227 /// <summary>Bit 45 (0x0000200000000000)</summary>
228 Bit45 = Bit44 << 1,
229
230 /// <summary>Bit 46 (0x0000400000000000)</summary>
231 Bit46 = Bit45 << 1,
232
233 /// <summary>Bit 47 (0x0000800000000000)</summary>
234 Bit47 = Bit46 << 1,
235
236 // Byte 6, Bits 48-55
237
238 /// <summary>Bit 48 (0x0001000000000000)</summary>
239 Bit48 = Bit47 << 1,
240
241 /// <summary>Bit 49 (0x0002000000000000)</summary>
242 Bit49 = Bit48 << 1,
243
244 /// <summary>Bit 50 (0x0004000000000000)</summary>
245 Bit50 = Bit49 << 1,
246
247 /// <summary>Bit 51 (0x0008000000000000)</summary>
248 Bit51 = Bit50 << 1,
249
250 /// <summary>Bit 52 (0x0010000000000000)</summary>
251 Bit52 = Bit51 << 1,
252
253 /// <summary>Bit 53 (0x0020000000000000)</summary>
254 Bit53 = Bit52 << 1,
255
256 /// <summary>Bit 54 (0x0040000000000000)</summary>
257 Bit54 = Bit53 << 1,
258
259 /// <summary>Bit 55 (0x0080000000000000)</summary>
260 Bit55 = Bit54 << 1,
261
262 // Byte 7, Bits 56-63
263
264 /// <summary>Bit 56 (0x0100000000000000)</summary>
265 Bit56 = Bit55 << 1,
266
267 /// <summary>Bit 57 (0x0200000000000000)</summary>
268 Bit57 = Bit56 << 1,
269
270 /// <summary>Bit 58 (0x0400000000000000)</summary>
271 Bit58 = Bit57 << 1,
272
273 /// <summary>Bit 59 (0x0800000000000000)</summary>
274 Bit59 = Bit58 << 1,
275
276 /// <summary>Bit 60 (0x1000000000000000)</summary>
277 Bit60 = Bit59 << 1,
278
279 /// <summary>Bit 61 (0x2000000000000000)</summary>
280 Bit61 = Bit60 << 1,
281
282 /// <summary>Bit 62 (0x4000000000000000)</summary>
283 Bit62 = Bit61 << 1,
284
285 /// <summary>Bit 63 (0x8000000000000000)</summary>
286 Bit63 = Bit62 << 1
287 }
288
289 #endregion
290
291 /// <summary>
292 /// Defines extension methods related to bit operations.
293 /// </summary>
294 public static class BitExtensions
295 {
296 /// <summary>
297 /// Gets the bit value for the specified bit index (0 - 63).
298 /// </summary>
299 /// <param name="bit">Bit index (0 - 63)</param>
300 /// <returns>Value of the specified <paramref name="bit"/>.</returns>
301 /// <exception cref="ArgumentOutOfRangeException">Parameter must be between 0 and 63.</exception>
302 [CLSCompliant(false)]
303 public static Bits BitVal(int bit)
304 {
305 switch (bit)
306 {
307 #region [ Bit Cases (0 - 63) ]
308
309 case 00: return Bits.Bit00;
310 case 01: return Bits.Bit01;
311 case 02: return Bits.Bit02;
312 case 03: return Bits.Bit03;
313 case 04: return Bits.Bit04;
314 case 05: return Bits.Bit05;
315 case 06: return Bits.Bit06;
316 case 07: return Bits.Bit07;
317 case 08: return Bits.Bit08;
318 case 09: return Bits.Bit09;
319 case 10: return Bits.Bit10;
320 case 11: return Bits.Bit11;
321 case 12: return Bits.Bit12;
322 case 13: return Bits.Bit13;
323 case 14: return Bits.Bit14;
324 case 15: return Bits.Bit15;
325 case 16: return Bits.Bit16;
326 case 17: return Bits.Bit17;
327 case 18: return Bits.Bit18;
328 case 19: return Bits.Bit19;
329 case 20: return Bits.Bit20;
330 case 21: return Bits.Bit21;
331 case 22: return Bits.Bit22;
332 case 23: return Bits.Bit23;
333 case 24: return Bits.Bit24;
334 case 25: return Bits.Bit25;
335 case 26: return Bits.Bit26;
336 case 27: return Bits.Bit27;
337 case 28: return Bits.Bit28;
338 case 29: return Bits.Bit29;
339 case 30: return Bits.Bit30;
340 case 31: return Bits.Bit31;
341 case 32: return Bits.Bit32;
342 case 33: return Bits.Bit33;
343 case 34: return Bits.Bit34;
344 case 35: return Bits.Bit35;
345 case 36: return Bits.Bit36;
346 case 37: return Bits.Bit37;
347 case 38: return Bits.Bit38;
348 case 39: return Bits.Bit39;
349 case 40: return Bits.Bit40;
350 case 41: return Bits.Bit41;
351 case 42: return Bits.Bit42;
352 case 43: return Bits.Bit43;
353 case 44: return Bits.Bit44;
354 case 45: return Bits.Bit45;
355 case 46: return Bits.Bit46;
356 case 47: return Bits.Bit47;
357 case 48: return Bits.Bit48;
358 case 49: return Bits.Bit49;
359 case 50: return Bits.Bit50;
360 case 51: return Bits.Bit51;
361 case 52: return Bits.Bit52;
362 case 53: return Bits.Bit53;
363 case 54: return Bits.Bit54;
364 case 55: return Bits.Bit55;
365 case 56: return Bits.Bit56;
366 case 57: return Bits.Bit57;
367 case 58: return Bits.Bit58;
368 case 59: return Bits.Bit59;
369 case 60: return Bits.Bit60;
370 case 61: return Bits.Bit61;
371 case 62: return Bits.Bit62;
372 case 63: return Bits.Bit63;
373
374 #endregion
375
376 default:
377 throw new ArgumentOutOfRangeException("bit", "Parameter must be between 0 and 63");
378 }
379 }
380
381 #region [ SetBits Extensions ]
382
383 /// <summary>
384 /// Returns value with specified <paramref name="bits"/> set.
385 /// </summary>
386 /// <param name="source">Value source.</param>
387 /// <param name="bits"><see cref="Bits"/> to set.</param>
388 /// <returns><see cref="sbyte"/> value with specified <paramref name="bits"/> set.</returns>
389 [CLSCompliant(false)]
390 public static sbyte SetBits(this sbyte source, Bits bits)
391 {
392 checked
393 {
394 return SetBits(source, (sbyte)bits);
395 }
396 }
397
398 /// <summary>
399 /// Returns value with specified <paramref name="bits"/> set.
400 /// </summary>
401 /// <param name="source">Value source.</param>
402 /// <param name="bits">Bit-mask of the bits to set.</param>
403 /// <returns><see cref="sbyte"/> value with specified <paramref name="bits"/> set.</returns>
404 [CLSCompliant(false)]
405 public static sbyte SetBits(this sbyte source, sbyte bits)
406 {
407 return ((sbyte)(source | bits));
408 }
409
410 /// <summary>
411 /// Returns value with specified <paramref name="bits"/> set.
412 /// </summary>
413 /// <param name="source">Value source.</param>
414 /// <param name="bits"><see cref="Bits"/> to set.</param>
415 /// <returns><see cref="byte"/> value with specified <paramref name="bits"/> set.</returns>
416 [CLSCompliant(false)]
417 public static byte SetBits(this byte source, Bits bits)
418 {
419 checked
420 {
421 return SetBits(source, (byte)bits);
422 }
423 }
424
425 /// <summary>
426 /// Returns value with specified <paramref name="bits"/> set.
427 /// </summary>
428 /// <param name="source">Value source.</param>
429 /// <param name="bits">Bit-mask of the bits to set.</param>
430 /// <returns><see cref="byte"/> value with specified <paramref name="bits"/> set.</returns>
431 public static byte SetBits(this byte source, byte bits)
432 {
433 return ((byte)(source | bits));
434 }
435
436 /// <summary>
437 /// Returns value with specified <paramref name="bits"/> set.
438 /// </summary>
439 /// <param name="source">Value source.</param>
440 /// <param name="bits"><see cref="Bits"/> to set.</param>
441 /// <returns><see cref="short"/> value with specified <paramref name="bits"/> set.</returns>
442 [CLSCompliant(false)]
443 public static short SetBits(this short source, Bits bits)
444 {
445 checked
446 {
447 return SetBits(source, (short)bits);
448 }
449 }
450
451 /// <summary>
452 /// Returns value with specified <paramref name="bits"/> set.
453 /// </summary>
454 /// <param name="source">Value source.</param>
455 /// <param name="bits">Bit-mask of the bits to set.</param>
456 /// <returns><see cref="short"/> value with specified <paramref name="bits"/> set.</returns>
457 public static short SetBits(this short source, short bits)
458 {
459 return ((short)(source | bits));
460 }
461
462 /// <summary>
463 /// Returns value with specified <paramref name="bits"/> set.
464 /// </summary>
465 /// <param name="source">Value source.</param>
466 /// <param name="bits"><see cref="Bits"/> to set.</param>
467 /// <returns><see cref="ushort"/> value with specified <paramref name="bits"/> set.</returns>
468 [CLSCompliant(false)]
469 public static ushort SetBits(this ushort source, Bits bits)
470 {
471 checked
472 {
473 return SetBits(source, (ushort)bits);
474 }
475 }
476
477 /// <summary>
478 /// Returns value with specified <paramref name="bits"/> set.
479 /// </summary>
480 /// <param name="source">Value source.</param>
481 /// <param name="bits">Bit-mask of the bits to set.</param>
482 /// <returns><see cref="ushort"/> value with specified <paramref name="bits"/> set.</returns>
483 [CLSCompliant(false)]
484 public static ushort SetBits(this ushort source, ushort bits)
485 {
486 return ((ushort)(source | bits));
487 }
488
489 /// <summary>
490 /// Returns value with specified <paramref name="bits"/> set.
491 /// </summary>
492 /// <param name="source">Value source.</param>
493 /// <param name="bits"><see cref="Bits"/> to set.</param>
494 /// <returns><see cref="Int24"/> value with specified <paramref name="bits"/> set.</returns>
495 [CLSCompliant(false)]
496 public static Int24 SetBits(this Int24 source, Bits bits)
497 {
498 checked
499 {
500 return SetBits(source, (Int24)bits);
501 }
502 }
503
504 /// <summary>
505 /// Returns value with specified <paramref name="bits"/> set.
506 /// </summary>
507 /// <param name="source">Value source.</param>
508 /// <param name="bits">Bit-mask of the bits to set.</param>
509 /// <returns><see cref="Int24"/> value with specified <paramref name="bits"/> set.</returns>
510 public static Int24 SetBits(this Int24 source, Int24 bits)
511 {
512 return (source | bits);
513 }
514
515 /// <summary>
516 /// Returns value with specified <paramref name="bits"/> set.
517 /// </summary>
518 /// <param name="source">Value source.</param>
519 /// <param name="bits"><see cref="Bits"/> to set.</param>
520 /// <returns><see cref="UInt24"/> value with specified <paramref name="bits"/> set.</returns>
521 [CLSCompliant(false)]
522 public static UInt24 SetBits(this UInt24 source, Bits bits)
523 {
524 checked
525 {
526 return SetBits(source, (UInt24)bits);
527 }
528 }
529
530 /// <summary>
531 /// Returns value with specified <paramref name="bits"/> set.
532 /// </summary>
533 /// <param name="source">Value source.</param>
534 /// <param name="bits">Bit-mask of the bits to set.</param>
535 /// <returns><see cref="UInt24"/> value with specified <paramref name="bits"/> set.</returns>
536 [CLSCompliant(false)]
537 public static UInt24 SetBits(this UInt24 source, UInt24 bits)
538 {
539 return (source | bits);
540 }
541
542 /// <summary>
543 /// Returns value with specified <paramref name="bits"/> set.
544 /// </summary>
545 /// <param name="source">Value source.</param>
546 /// <param name="bits"><see cref="Bits"/> to set.</param>
547 /// <returns><see cref="int"/> value with specified <paramref name="bits"/> set.</returns>
548 [CLSCompliant(false)]
549 public static int SetBits(this int source, Bits bits)
550 {
551 checked
552 {
553 return SetBits(source, (int)bits);
554 }
555 }
556
557 /// <summary>
558 /// Returns value with specified <paramref name="bits"/> set.
559 /// </summary>
560 /// <param name="source">Value source.</param>
561 /// <param name="bits">Bit-mask of the bits to set.</param>
562 /// <returns><see cref="int"/> value with specified <paramref name="bits"/> set.</returns>
563 public static int SetBits(this int source, int bits)
564 {
565 return (source | bits);
566 }
567
568 /// <summary>
569 /// Returns value with specified <paramref name="bits"/> set.
570 /// </summary>
571 /// <param name="source">Value source.</param>
572 /// <param name="bits"><see cref="Bits"/> to set.</param>
573 /// <returns><see cref="uint"/> value with specified <paramref name="bits"/> set.</returns>
574 [CLSCompliant(false)]
575 public static uint SetBits(this uint source, Bits bits)
576 {
577 checked
578 {
579 return SetBits(source, (uint)bits);
580 }
581 }
582
583 /// <summary>
584 /// Returns value with specified <paramref name="bits"/> set.
585 /// </summary>
586 /// <param name="source">Value source.</param>
587 /// <param name="bits">Bit-mask of the bits to set.</param>
588 /// <returns><see cref="uint"/> value with specified <paramref name="bits"/> set.</returns>
589 [CLSCompliant(false)]
590 public static uint SetBits(this uint source, uint bits)
591 {
592 return (source | bits);
593 }
594
595 /// <summary>
596 /// Returns value with specified <paramref name="bits"/> set.
597 /// </summary>
598 /// <param name="source">Value source.</param>
599 /// <param name="bits"><see cref="Bits"/> to set.</param>
600 /// <returns><see cref="long"/> value with specified <paramref name="bits"/> set.</returns>
601 [CLSCompliant(false)]
602 public static long SetBits(this long source, Bits bits)
603 {
604 checked
605 {
606 return SetBits(source, (long)bits);
607 }
608 }
609
610 /// <summary>
611 /// Returns value with specified <paramref name="bits"/> set.
612 /// </summary>
613 /// <param name="source">Value source.</param>
614 /// <param name="bits">Bit-mask of the bits to set.</param>
615 /// <returns><see cref="long"/> value with specified <paramref name="bits"/> set.</returns>
616 public static long SetBits(this long source, long bits)
617 {
618 return (source | bits);
619 }
620
621 /// <summary>
622 /// Returns value with specified <paramref name="bits"/> set.
623 /// </summary>
624 /// <param name="source">Value source.</param>
625 /// <param name="bits"><see cref="Bits"/> to set.</param>
626 /// <returns><see cref="ulong"/> value with specified <paramref name="bits"/> set.</returns>
627 [CLSCompliant(false)]
628 public static ulong SetBits(this ulong source, Bits bits)
629 {
630 checked
631 {
632 return SetBits(source, (ulong)bits);
633 }
634 }
635
636 /// <summary>
637 /// Returns value with specified <paramref name="bits"/> set.
638 /// </summary>
639 /// <param name="source">Value source.</param>
640 /// <param name="bits">Bit-mask of the bits to set.</param>
641 /// <returns><see cref="ulong"/> value with specified <paramref name="bits"/> set.</returns>
642 [CLSCompliant(false)]
643 public static ulong SetBits(this ulong source, ulong bits)
644 {
645 return (source | bits);
646 }
647
648 #endregion
649
650 #region [ ClearBits Extensions ]
651
652 /// <summary>
653 /// Returns value with specified <paramref name="bits"/> cleared.
654 /// </summary>
655 /// <param name="source">Value source.</param>
656 /// <param name="bits"><see cref="Bits"/> to clear.</param>
657 /// <returns><see cref="sbyte"/> value with specified <paramref name="bits"/> cleared.</returns>
658 [CLSCompliant(false)]
659 public static sbyte ClearBits(this sbyte source, Bits bits)
660 {
661 checked
662 {
663 return ClearBits(source, (sbyte)bits);
664 }
665 }
666
667 /// <summary>
668 /// Returns value with specified <paramref name="bits"/> cleared.
669 /// </summary>
670 /// <param name="source">Value source.</param>
671 /// <param name="bits">Bit-mask of the bits to clear.</param>
672 /// <returns><see cref="sbyte"/> value with specified <paramref name="bits"/> cleared.</returns>
673 [CLSCompliant(false)]
674 public static sbyte ClearBits(this sbyte source, sbyte bits)
675 {
676 return ((sbyte)(source & ~bits));
677 }
678
679 /// <summary>
680 /// Returns value with specified <paramref name="bits"/> cleared.
681 /// </summary>
682 /// <param name="source">Value source.</param>
683 /// <param name="bits"><see cref="Bits"/> to clear.</param>
684 /// <returns><see cref="byte"/> value with specified <paramref name="bits"/> cleared.</returns>
685 [CLSCompliant(false)]
686 public static byte ClearBits(this byte source, Bits bits)
687 {
688 checked
689 {
690 return ClearBits(source, (byte)bits);
691 }
692 }
693
694 /// <summary>
695 /// Returns value with specified <paramref name="bits"/> cleared.
696 /// </summary>
697 /// <param name="source">Value source.</param>
698 /// <param name="bits">Bit-mask of the bits to clear.</param>
699 /// <returns><see cref="byte"/> value with specified <paramref name="bits"/> cleared.</returns>
700 public static byte ClearBits(this byte source, byte bits)
701 {
702 return ((byte)(source & ~bits));
703 }
704
705 /// <summary>
706 /// Returns value with specified <paramref name="bits"/> cleared.
707 /// </summary>
708 /// <param name="source">Value source.</param>
709 /// <param name="bits"><see cref="Bits"/> to clear.</param>
710 /// <returns><see cref="short"/> value with specified <paramref name="bits"/> cleared.</returns>
711 [CLSCompliant(false)]
712 public static short ClearBits(this short source, Bits bits)
713 {
714 checked
715 {
716 return ClearBits(source, (short)bits);
717 }
718 }
719
720 /// <summary>
721 /// Returns value with specified <paramref name="bits"/> cleared.
722 /// </summary>
723 /// <param name="source">Value source.</param>
724 /// <param name="bits">Bit-mask of the bits to clear.</param>
725 /// <returns><see cref="short"/> value with specified <paramref name="bits"/> cleared.</returns>
726 public static short ClearBits(this short source, short bits)
727 {
728 return ((short)(source & ~bits));
729 }
730
731 /// <summary>
732 /// Returns value with specified <paramref name="bits"/> cleared.
733 /// </summary>
734 /// <param name="source">Value source.</param>
735 /// <param name="bits"><see cref="Bits"/> to clear.</param>
736 /// <returns><see cref="ushort"/> value with specified <paramref name="bits"/> cleared.</returns>
737 [CLSCompliant(false)]
738 public static ushort ClearBits(this ushort source, Bits bits)
739 {
740 checked
741 {
742 return ClearBits(source, (ushort)bits);
743 }
744 }
745
746 /// <summary>
747 /// Returns value with specified <paramref name="bits"/> cleared.
748 /// </summary>
749 /// <param name="source">Value source.</param>
750 /// <param name="bits">Bit-mask of the bits to clear.</param>
751 /// <returns><see cref="ushort"/> value with specified <paramref name="bits"/> cleared.</returns>
752 [CLSCompliant(false)]
753 public static ushort ClearBits(this ushort source, ushort bits)
754 {
755 return ((ushort)(source & ~bits));
756 }
757
758 /// <summary>
759 /// Returns value with specified <paramref name="bits"/> cleared.
760 /// </summary>
761 /// <param name="source">Value source.</param>
762 /// <param name="bits"><see cref="Bits"/> to clear.</param>
763 /// <returns><see cref="Int24"/> value with specified <paramref name="bits"/> cleared.</returns>
764 [CLSCompliant(false)]
765 public static Int24 ClearBits(this Int24 source, Bits bits)
766 {
767 checked
768 {
769 return ClearBits(source, (Int24)bits);
770 }
771 }
772
773 /// <summary>
774 /// Returns value with specified <paramref name="bits"/> cleared.
775 /// </summary>
776 /// <param name="source">Value source.</param>
777 /// <param name="bits">Bit-mask of the bits to clear.</param>
778 /// <returns><see cref="Int24"/> value with specified <paramref name="bits"/> cleared.</returns>
779 public static Int24 ClearBits(this Int24 source, Int24 bits)
780 {
781 return (source & ~bits);
782 }
783
784 /// <summary>
785 /// Returns value with specified <paramref name="bits"/> cleared.
786 /// </summary>
787 /// <param name="source">Value source.</param>
788 /// <param name="bits"><see cref="Bits"/> to clear.</param>
789 /// <returns><see cref="UInt24"/> value with specified <paramref name="bits"/> cleared.</returns>
790 [CLSCompliant(false)]
791 public static UInt24 ClearBits(this UInt24 source, Bits bits)
792 {
793 checked
794 {
795 return ClearBits(source, (UInt24)bits);
796 }
797 }
798
799 /// <summary>
800 /// Returns value with specified <paramref name="bits"/> cleared.
801 /// </summary>
802 /// <param name="source">Value source.</param>
803 /// <param name="bits">Bit-mask of the bits to clear.</param>
804 /// <returns><see cref="UInt24"/> value with specified <paramref name="bits"/> cleared.</returns>
805 [CLSCompliant(false)]
806 public static UInt24 ClearBits(this UInt24 source, UInt24 bits)
807 {
808 return (source & ~bits);
809 }
810
811 /// <summary>
812 /// Returns value with specified <paramref name="bits"/> cleared.
813 /// </summary>
814 /// <param name="source">Value source.</param>
815 /// <param name="bits"><see cref="Bits"/> to clear.</param>
816 /// <returns><see cref="int"/> value with specified <paramref name="bits"/> cleared.</returns>
817 [CLSCompliant(false)]
818 public static int ClearBits(this int source, Bits bits)
819 {
820 checked
821 {
822 return ClearBits(source, (int)bits);
823 }
824 }
825
826 /// <summary>
827 /// Returns value with specified <paramref name="bits"/> cleared.
828 /// </summary>
829 /// <param name="source">Value source.</param>
830 /// <param name="bits">Bit-mask of the bits to clear.</param>
831 /// <returns><see cref="int"/> value with specified <paramref name="bits"/> cleared.</returns>
832 public static int ClearBits(this int source, int bits)
833 {
834 return (source & ~bits);
835 }
836
837 /// <summary>
838 /// Returns value with specified <paramref name="bits"/> cleared.
839 /// </summary>
840 /// <param name="source">Value source.</param>
841 /// <param name="bits"><see cref="Bits"/> to clear.</param>
842 /// <returns><see cref="uint"/> value with specified <paramref name="bits"/> cleared.</returns>
843 [CLSCompliant(false)]
844 public static uint ClearBits(this uint source, Bits bits)
845 {
846 checked
847 {
848 return ClearBits(source, (uint)bits);
849 }
850 }
851
852 /// <summary>
853 /// Returns value with specified <paramref name="bits"/> cleared.
854 /// </summary>
855 /// <param name="source">Value source.</param>
856 /// <param name="bits">Bit-mask of the bits to clear.</param>
857 /// <returns><see cref="uint"/> value with specified <paramref name="bits"/> cleared.</returns>
858 [CLSCompliant(false)]
859 public static uint ClearBits(this uint source, uint bits)
860 {
861 return (source & ~bits);
862 }
863
864 /// <summary>
865 /// Returns value with specified <paramref name="bits"/> cleared.
866 /// </summary>
867 /// <param name="source">Value source.</param>
868 /// <param name="bits"><see cref="Bits"/> to clear.</param>
869 /// <returns><see cref="long"/> value with specified <paramref name="bits"/> cleared.</returns>
870 [CLSCompliant(false)]
871 public static long ClearBits(this long source, Bits bits)
872 {
873 checked
874 {
875 return ClearBits(source, (long)bits);
876 }
877 }
878
879 /// <summary>
880 /// Returns value with specified <paramref name="bits"/> cleared.
881 /// </summary>
882 /// <param name="source">Value source.</param>
883 /// <param name="bits">Bit-mask of the bits to clear.</param>
884 /// <returns><see cref="long"/> value with specified <paramref name="bits"/> cleared.</returns>
885 public static long ClearBits(this long source, long bits)
886 {
887 return (source & ~bits);
888 }
889
890 /// <summary>
891 /// Returns value with specified <paramref name="bits"/> cleared.
892 /// </summary>
893 /// <param name="source">Value source.</param>
894 /// <param name="bits"><see cref="Bits"/> to clear.</param>
895 /// <returns><see cref="ulong"/> value with specified <paramref name="bits"/> cleared.</returns>
896 [CLSCompliant(false)]
897 public static ulong ClearBits(this ulong source, Bits bits)
898 {
899 checked
900 {
901 return ClearBits(source, (ulong)bits);
902 }
903 }
904
905 /// <summary>
906 /// Returns value with specified <paramref name="bits"/> cleared.
907 /// </summary>
908 /// <param name="source">Value source.</param>
909 /// <param name="bits">Bit-mask of the bits to clear.</param>
910 /// <returns><see cref="ulong"/> value with specified <paramref name="bits"/> cleared.</returns>
911 [CLSCompliant(false)]
912 public static ulong ClearBits(this ulong source, ulong bits)
913 {
914 return (source & ~bits);
915 }
916
917 #endregion
918
919 #region [ CheckBits Extensions ]
920
921 /// <summary>
922 /// Determines if specified <paramref name="bits"/> are set.
923 /// </summary>
924 /// <param name="source">Value source.</param>
925 /// <param name="bits"><see cref="Bits"/> to check.</param>
926 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
927 [CLSCompliant(false)]
928 public static bool CheckBits(this sbyte source, Bits bits)
929 {
930 checked
931 {
932 return CheckBits(source, (sbyte)bits);
933 }
934 }
935
936 /// <summary>
937 /// Determines if specified <paramref name="bits"/> are set.
938 /// </summary>
939 /// <param name="source">Value source.</param>
940 /// <param name="bits">Bit-mask of the bits to check.</param>
941 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
942 [CLSCompliant(false)]
943 public static bool CheckBits(this sbyte source, sbyte bits)
944 {
945 return CheckBits(source, bits, true);
946 }
947
948 /// <summary>
949 /// Determines if specified <paramref name="bits"/> are set.
950 /// </summary>
951 /// <param name="source">Value source.</param>
952 /// <param name="bits"><see cref="Bits"/> to check.</param>
953 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
954 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
955 [CLSCompliant(false)]
956 public static bool CheckBits(this sbyte source, Bits bits, bool allBits)
957 {
958 checked
959 {
960 return CheckBits(source, (sbyte)bits, allBits);
961 }
962 }
963
964 /// <summary>
965 /// Determines if specified <paramref name="bits"/> are set.
966 /// </summary>
967 /// <param name="source">Value source.</param>
968 /// <param name="bits">Bit-mask of the bits to check.</param>
969 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
970 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
971 [CLSCompliant(false)]
972 public static bool CheckBits(this sbyte source, sbyte bits, bool allBits)
973 {
974 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
975 }
976
977 /// <summary>
978 /// Determines if specified <paramref name="bits"/> are set.
979 /// </summary>
980 /// <param name="source">Value source.</param>
981 /// <param name="bits"><see cref="Bits"/> to check.</param>
982 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
983 [CLSCompliant(false)]
984 public static bool CheckBits(this byte source, Bits bits)
985 {
986 checked
987 {
988 return CheckBits(source, (byte)bits);
989 }
990 }
991
992 /// <summary>
993 /// Determines if specified <paramref name="bits"/> are set.
994 /// </summary>
995 /// <param name="source">Value source.</param>
996 /// <param name="bits">Bit-mask of the bits to check.</param>
997 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
998 public static bool CheckBits(this byte source, byte bits)
999 {
1000 return CheckBits(source, bits, true);
1001 }
1002
1003 /// <summary>
1004 /// Determines if specified <paramref name="bits"/> are set.
1005 /// </summary>
1006 /// <param name="source">Value source.</param>
1007 /// <param name="bits"><see cref="Bits"/> to check.</param>
1008 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1009 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1010 [CLSCompliant(false)]
1011 public static bool CheckBits(this byte source, Bits bits, bool allBits)
1012 {
1013 checked
1014 {
1015 return CheckBits(source, (byte)bits, allBits);
1016 }
1017 }
1018
1019 /// <summary>
1020 /// Determines if specified <paramref name="bits"/> are set.
1021 /// </summary>
1022 /// <param name="source">Value source.</param>
1023 /// <param name="bits">Bit-mask of the bits to check.</param>
1024 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1025 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1026 public static bool CheckBits(this byte source, byte bits, bool allBits)
1027 {
1028 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
1029 }
1030
1031 /// <summary>
1032 /// Determines if specified <paramref name="bits"/> are set.
1033 /// </summary>
1034 /// <param name="source">Value source.</param>
1035 /// <param name="bits"><see cref="Bits"/> to check.</param>
1036 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1037 [CLSCompliant(false)]
1038 public static bool CheckBits(this short source, Bits bits)
1039 {
1040 checked
1041 {
1042 return CheckBits(source, (short)bits);
1043 }
1044 }
1045
1046 /// <summary>
1047 /// Determines if specified <paramref name="bits"/> are set.
1048 /// </summary>
1049 /// <param name="source">Value source.</param>
1050 /// <param name="bits">Bit-mask of the bits to check.</param>
1051 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1052 public static bool CheckBits(this short source, short bits)
1053 {
1054 return CheckBits(source, bits, true);
1055 }
1056
1057 /// <summary>
1058 /// Determines if specified <paramref name="bits"/> are set.
1059 /// </summary>
1060 /// <param name="source">Value source.</param>
1061 /// <param name="bits"><see cref="Bits"/> to check.</param>
1062 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1063 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1064 [CLSCompliant(false)]
1065 public static bool CheckBits(this short source, Bits bits, bool allBits)
1066 {
1067 checked
1068 {
1069 return CheckBits(source, (short)bits, allBits);
1070 }
1071 }
1072
1073 /// <summary>
1074 /// Determines if specified <paramref name="bits"/> are set.
1075 /// </summary>
1076 /// <param name="source">Value source.</param>
1077 /// <param name="bits">Bit-mask of the bits to check.</param>
1078 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1079 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1080 public static bool CheckBits(this short source, short bits, bool allBits)
1081 {
1082 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
1083 }
1084
1085 /// <summary>
1086 /// Determines if specified <paramref name="bits"/> are set.
1087 /// </summary>
1088 /// <param name="source">Value source.</param>
1089 /// <param name="bits"><see cref="Bits"/> to check.</param>
1090 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1091 [CLSCompliant(false)]
1092 public static bool CheckBits(this ushort source, Bits bits)
1093 {
1094 checked
1095 {
1096 return CheckBits(source, (ushort)bits);
1097 }
1098 }
1099
1100 /// <summary>
1101 /// Determines if specified <paramref name="bits"/> are set.
1102 /// </summary>
1103 /// <param name="source">Value source.</param>
1104 /// <param name="bits">Bit-mask of the bits to check.</param>
1105 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1106 [CLSCompliant(false)]
1107 public static bool CheckBits(this ushort source, ushort bits)
1108 {
1109 return CheckBits(source, bits, true);
1110 }
1111
1112 /// <summary>
1113 /// Determines if specified <paramref name="bits"/> are set.
1114 /// </summary>
1115 /// <param name="source">Value source.</param>
1116 /// <param name="bits"><see cref="Bits"/> to check.</param>
1117 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1118 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1119 [CLSCompliant(false)]
1120 public static bool CheckBits(this ushort source, Bits bits, bool allBits)
1121 {
1122 checked
1123 {
1124 return CheckBits(source, (ushort)bits, allBits);
1125 }
1126 }
1127
1128 /// <summary>
1129 /// Determines if specified <paramref name="bits"/> are set.
1130 /// </summary>
1131 /// <param name="source">Value source.</param>
1132 /// <param name="bits">Bit-mask of the bits to check.</param>
1133 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1134 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1135 [CLSCompliant(false)]
1136 public static bool CheckBits(this ushort source, ushort bits, bool allBits)
1137 {
1138 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
1139 }
1140
1141 /// <summary>
1142 /// Determines if specified <paramref name="bits"/> are set.
1143 /// </summary>
1144 /// <param name="source">Value source.</param>
1145 /// <param name="bits"><see cref="Bits"/> to check.</param>
1146 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1147 [CLSCompliant(false)]
1148 public static bool CheckBits(this Int24 source, Bits bits)
1149 {
1150 checked
1151 {
1152 return CheckBits(source, (Int24)bits);
1153 }
1154 }
1155
1156 /// <summary>
1157 /// Determines if specified <paramref name="bits"/> are set.
1158 /// </summary>
1159 /// <param name="source">Value source.</param>
1160 /// <param name="bits">Bit-mask of the bits to check.</param>
1161 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1162 public static bool CheckBits(this Int24 source, Int24 bits)
1163 {
1164 return CheckBits(source, bits, true);
1165 }
1166
1167 /// <summary>
1168 /// Determines if specified <paramref name="bits"/> are set.
1169 /// </summary>
1170 /// <param name="source">Value source.</param>
1171 /// <param name="bits"><see cref="Bits"/> to check.</param>
1172 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1173 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1174 [CLSCompliant(false)]
1175 public static bool CheckBits(this Int24 source, Bits bits, bool allBits)
1176 {
1177 checked
1178 {
1179 return CheckBits(source, (Int24)bits, allBits);
1180 }
1181 }
1182
1183 /// <summary>
1184 /// Determines if specified <paramref name="bits"/> are set.
1185 /// </summary>
1186 /// <param name="source">Value source.</param>
1187 /// <param name="bits">Bit-mask of the bits to check.</param>
1188 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1189 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1190 public static bool CheckBits(this Int24 source, Int24 bits, bool allBits)
1191 {
1192 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
1193 }
1194
1195 /// <summary>
1196 /// Determines if specified <paramref name="bits"/> are set.
1197 /// </summary>
1198 /// <param name="source">Value source.</param>
1199 /// <param name="bits"><see cref="Bits"/> to check.</param>
1200 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1201 [CLSCompliant(false)]
1202 public static bool CheckBits(this UInt24 source, Bits bits)
1203 {
1204 checked
1205 {
1206 return CheckBits(source, (UInt24)bits);
1207 }
1208 }
1209
1210 /// <summary>
1211 /// Determines if specified <paramref name="bits"/> are set.
1212 /// </summary>
1213 /// <param name="source">Value source.</param>
1214 /// <param name="bits">Bit-mask of the bits to check.</param>
1215 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1216 [CLSCompliant(false)]
1217 public static bool CheckBits(this UInt24 source, UInt24 bits)
1218 {
1219 return CheckBits(source, bits, true);
1220 }
1221
1222 /// <summary>
1223 /// Determines if specified <paramref name="bits"/> are set.
1224 /// </summary>
1225 /// <param name="source">Value source.</param>
1226 /// <param name="bits"><see cref="Bits"/> to check.</param>
1227 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1228 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1229 [CLSCompliant(false)]
1230 public static bool CheckBits(this UInt24 source, Bits bits, bool allBits)
1231 {
1232 checked
1233 {
1234 return CheckBits(source, (UInt24)bits, allBits);
1235 }
1236 }
1237
1238 /// <summary>
1239 /// Determines if specified <paramref name="bits"/> are set.
1240 /// </summary>
1241 /// <param name="source">Value source.</param>
1242 /// <param name="bits">Bit-mask of the bits to check.</param>
1243 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1244 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1245 [CLSCompliant(false)]
1246 public static bool CheckBits(this UInt24 source, UInt24 bits, bool allBits)
1247 {
1248 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
1249 }
1250
1251 /// <summary>
1252 /// Determines if specified <paramref name="bits"/> are set.
1253 /// </summary>
1254 /// <param name="source">Value source.</param>
1255 /// <param name="bits"><see cref="Bits"/> to check.</param>
1256 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1257 [CLSCompliant(false)]
1258 public static bool CheckBits(this int source, Bits bits)
1259 {
1260 checked
1261 {
1262 return CheckBits(source, (int)bits);
1263 }
1264 }
1265
1266 /// <summary>
1267 /// Determines if specified <paramref name="bits"/> are set.
1268 /// </summary>
1269 /// <param name="source">Value source.</param>
1270 /// <param name="bits">Bit-mask of the bits to check.</param>
1271 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1272 public static bool CheckBits(this int source, int bits)
1273 {
1274 return CheckBits(source, bits, true);
1275 }
1276
1277 /// <summary>
1278 /// Determines if specified <paramref name="bits"/> are set.
1279 /// </summary>
1280 /// <param name="source">Value source.</param>
1281 /// <param name="bits"><see cref="Bits"/> to check.</param>
1282 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1283 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1284 [CLSCompliant(false)]
1285 public static bool CheckBits(this int source, Bits bits, bool allBits)
1286 {
1287 checked
1288 {
1289 return CheckBits(source, (int)bits, allBits);
1290 }
1291 }
1292
1293 /// <summary>
1294 /// Determines if specified <paramref name="bits"/> are set.
1295 /// </summary>
1296 /// <param name="source">Value source.</param>
1297 /// <param name="bits">Bit-mask of the bits to check.</param>
1298 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1299 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1300 public static bool CheckBits(this int source, int bits, bool allBits)
1301 {
1302 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
1303 }
1304
1305 /// <summary>
1306 /// Determines if specified <paramref name="bits"/> are set.
1307 /// </summary>
1308 /// <param name="source">Value source.</param>
1309 /// <param name="bits"><see cref="Bits"/> to check.</param>
1310 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1311 [CLSCompliant(false)]
1312 public static bool CheckBits(this uint source, Bits bits)
1313 {
1314 checked
1315 {
1316 return CheckBits(source, (uint)bits);
1317 }
1318 }
1319
1320 /// <summary>
1321 /// Determines if specified <paramref name="bits"/> are set.
1322 /// </summary>
1323 /// <param name="source">Value source.</param>
1324 /// <param name="bits">Bit-mask of the bits to check.</param>
1325 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1326 [CLSCompliant(false)]
1327 public static bool CheckBits(this uint source, uint bits)
1328 {
1329 return CheckBits(source, bits, true);
1330 }
1331
1332 /// <summary>
1333 /// Determines if specified <paramref name="bits"/> are set.
1334 /// </summary>
1335 /// <param name="source">Value source.</param>
1336 /// <param name="bits"><see cref="Bits"/> to check.</param>
1337 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1338 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1339 [CLSCompliant(false)]
1340 public static bool CheckBits(this uint source, Bits bits, bool allBits)
1341 {
1342 checked
1343 {
1344 return CheckBits(source, (uint)bits, allBits);
1345 }
1346 }
1347
1348 /// <summary>
1349 /// Determines if specified <paramref name="bits"/> are set.
1350 /// </summary>
1351 /// <param name="source">Value source.</param>
1352 /// <param name="bits">Bit-mask of the bits to check.</param>
1353 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1354 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1355 [CLSCompliant(false)]
1356 public static bool CheckBits(this uint source, uint bits, bool allBits)
1357 {
1358 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
1359 }
1360
1361 /// <summary>
1362 /// Determines if specified <paramref name="bits"/> are set.
1363 /// </summary>
1364 /// <param name="source">Value source.</param>
1365 /// <param name="bits"><see cref="Bits"/> to check.</param>
1366 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1367 [CLSCompliant(false)]
1368 public static bool CheckBits(this long source, Bits bits)
1369 {
1370 checked
1371 {
1372 return CheckBits(source, (long)bits);
1373 }
1374 }
1375
1376 /// <summary>
1377 /// Determines if specified <paramref name="bits"/> are set.
1378 /// </summary>
1379 /// <param name="source">Value source.</param>
1380 /// <param name="bits">Bit-mask of the bits to check.</param>
1381 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1382 public static bool CheckBits(this long source, long bits)
1383 {
1384 return CheckBits(source, bits, true);
1385 }
1386
1387 /// <summary>
1388 /// Determines if specified <paramref name="bits"/> are set.
1389 /// </summary>
1390 /// <param name="source">Value source.</param>
1391 /// <param name="bits"><see cref="Bits"/> to check.</param>
1392 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1393 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1394 [CLSCompliant(false)]
1395 public static bool CheckBits(this long source, Bits bits, bool allBits)
1396 {
1397 checked
1398 {
1399 return CheckBits(source, (long)bits, allBits);
1400 }
1401 }
1402
1403 /// <summary>
1404 /// Determines if specified <paramref name="bits"/> are set.
1405 /// </summary>
1406 /// <param name="source">Value source.</param>
1407 /// <param name="bits">Bit-mask of the bits to check.</param>
1408 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1409 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1410 public static bool CheckBits(this long source, long bits, bool allBits)
1411 {
1412 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
1413 }
1414
1415 /// <summary>
1416 /// Determines if specified <paramref name="bits"/> are set.
1417 /// </summary>
1418 /// <param name="source">Value source.</param>
1419 /// <param name="bits"><see cref="Bits"/> to check.</param>
1420 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1421 [CLSCompliant(false)]
1422 public static bool CheckBits(this ulong source, Bits bits)
1423 {
1424 checked
1425 {
1426 return CheckBits(source, (ulong)bits);
1427 }
1428 }
1429
1430 /// <summary>
1431 /// Determines if specified <paramref name="bits"/> are set.
1432 /// </summary>
1433 /// <param name="source">Value source.</param>
1434 /// <param name="bits">Bit-mask of the bits to check.</param>
1435 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1436 [CLSCompliant(false)]
1437 public static bool CheckBits(this ulong source, ulong bits)
1438 {
1439 return CheckBits(source, bits, true);
1440 }
1441
1442 /// <summary>
1443 /// Determines if specified <paramref name="bits"/> are set.
1444 /// </summary>
1445 /// <param name="source">Value source.</param>
1446 /// <param name="bits"><see cref="Bits"/> to check.</param>
1447 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1448 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1449 [CLSCompliant(false)]
1450 public static bool CheckBits(this ulong source, Bits bits, bool allBits)
1451 {
1452 checked
1453 {
1454 return CheckBits(source, (ulong)bits, allBits);
1455 }
1456 }
1457
1458 /// <summary>
1459 /// Determines if specified <paramref name="bits"/> are set.
1460 /// </summary>
1461 /// <param name="source">Value source.</param>
1462 /// <param name="bits">Bit-mask of the bits to check.</param>
1463 /// <param name="allBits">true to check if all <paramref name="bits"/> are set; otherwise false.</param>
1464 /// <returns>true if specified <paramref name="bits"/> are set in <paramref name="source"/> value; otherwise false.</returns>
1465 [CLSCompliant(false)]
1466 public static bool CheckBits(this ulong source, ulong bits, bool allBits)
1467 {
1468 return (allBits ? ((source & bits) == bits) : ((source & bits) != 0));
1469 }
1470
1471 #endregion
1472
1473 #region [ ToggleBits Extensions ]
1474
1475 /// <summary>
1476 /// Returns value with specified <paramref name="bits"/> toggled.
1477 /// </summary>
1478 /// <param name="source">Value source.</param>
1479 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1480 /// <returns><see cref="sbyte"/> value with specified <paramref name="bits"/> toggled.</returns>
1481 [CLSCompliant(false)]
1482 public static sbyte ToggleBits(this sbyte source, Bits bits)
1483 {
1484 checked
1485 {
1486 return ToggleBits(source, (sbyte)bits);
1487 }
1488 }
1489
1490 /// <summary>
1491 /// Returns value with specified <paramref name="bits"/> toggled.
1492 /// </summary>
1493 /// <param name="source">Value source.</param>
1494 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1495 /// <returns><see cref="sbyte"/> value with specified <paramref name="bits"/> toggled.</returns>
1496 [CLSCompliant(false)]
1497 public static sbyte ToggleBits(this sbyte source, sbyte bits)
1498 {
1499 return ((sbyte)(source ^ bits));
1500 }
1501
1502 /// <summary>
1503 /// Returns value with specified <paramref name="bits"/> toggled.
1504 /// </summary>
1505 /// <param name="source">Value source.</param>
1506 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1507 /// <returns><see cref="byte"/> value with specified <paramref name="bits"/> toggled.</returns>
1508 [CLSCompliant(false)]
1509 public static byte ToggleBits(this byte source, Bits bits)
1510 {
1511 checked
1512 {
1513 return ToggleBits(source, (byte)bits);
1514 }
1515 }
1516
1517 /// <summary>
1518 /// Returns value with specified <paramref name="bits"/> toggled.
1519 /// </summary>
1520 /// <param name="source">Value source.</param>
1521 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1522 /// <returns><see cref="byte"/> value with specified <paramref name="bits"/> toggled.</returns>
1523 public static byte ToggleBits(this byte source, byte bits)
1524 {
1525 return ((byte)(source ^ bits));
1526 }
1527
1528 /// <summary>
1529 /// Returns value with specified <paramref name="bits"/> toggled.
1530 /// </summary>
1531 /// <param name="source">Value source.</param>
1532 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1533 /// <returns><see cref="short"/> value with specified <paramref name="bits"/> toggled.</returns>
1534 [CLSCompliant(false)]
1535 public static short ToggleBits(this short source, Bits bits)
1536 {
1537 checked
1538 {
1539 return ToggleBits(source, (short)bits);
1540 }
1541 }
1542
1543 /// <summary>
1544 /// Returns value with specified <paramref name="bits"/> toggled.
1545 /// </summary>
1546 /// <param name="source">Value source.</param>
1547 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1548 /// <returns><see cref="short"/> value with specified <paramref name="bits"/> toggled.</returns>
1549 public static short ToggleBits(this short source, short bits)
1550 {
1551 return ((short)(source ^ bits));
1552 }
1553
1554 /// <summary>
1555 /// Returns value with specified <paramref name="bits"/> toggled.
1556 /// </summary>
1557 /// <param name="source">Value source.</param>
1558 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1559 /// <returns><see cref="ushort"/> value with specified <paramref name="bits"/> toggled.</returns>
1560 [CLSCompliant(false)]
1561 public static ushort ToggleBits(this ushort source, Bits bits)
1562 {
1563 checked
1564 {
1565 return ToggleBits(source, (ushort)bits);
1566 }
1567 }
1568
1569 /// <summary>
1570 /// Returns value with specified <paramref name="bits"/> toggled.
1571 /// </summary>
1572 /// <param name="source">Value source.</param>
1573 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1574 /// <returns><see cref="ushort"/> value with specified <paramref name="bits"/> toggled.</returns>
1575 [CLSCompliant(false)]
1576 public static ushort ToggleBits(this ushort source, ushort bits)
1577 {
1578 return ((ushort)(source ^ bits));
1579 }
1580
1581 /// <summary>
1582 /// Returns value with specified <paramref name="bits"/> toggled.
1583 /// </summary>
1584 /// <param name="source">Value source.</param>
1585 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1586 /// <returns><see cref="Int24"/> value with specified <paramref name="bits"/> toggled.</returns>
1587 [CLSCompliant(false)]
1588 public static Int24 ToggleBits(this Int24 source, Bits bits)
1589 {
1590 checked
1591 {
1592 return ToggleBits(source, (Int24)bits);
1593 }
1594 }
1595
1596 /// <summary>
1597 /// Returns value with specified <paramref name="bits"/> toggled.
1598 /// </summary>
1599 /// <param name="source">Value source.</param>
1600 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1601 /// <returns><see cref="Int24"/> value with specified <paramref name="bits"/> toggled.</returns>
1602 public static Int24 ToggleBits(this Int24 source, Int24 bits)
1603 {
1604 return (source ^ bits);
1605 }
1606
1607 /// <summary>
1608 /// Returns value with specified <paramref name="bits"/> toggled.
1609 /// </summary>
1610 /// <param name="source">Value source.</param>
1611 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1612 /// <returns><see cref="UInt24"/> value with specified <paramref name="bits"/> toggled.</returns>
1613 [CLSCompliant(false)]
1614 public static UInt24 ToggleBits(this UInt24 source, Bits bits)
1615 {
1616 checked
1617 {
1618 return ToggleBits(source, (UInt24)bits);
1619 }
1620 }
1621
1622 /// <summary>
1623 /// Returns value with specified <paramref name="bits"/> toggled.
1624 /// </summary>
1625 /// <param name="source">Value source.</param>
1626 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1627 /// <returns><see cref="UInt24"/> value with specified <paramref name="bits"/> toggled.</returns>
1628 [CLSCompliant(false)]
1629 public static UInt24 ToggleBits(this UInt24 source, UInt24 bits)
1630 {
1631 return (source ^ bits);
1632 }
1633
1634 /// <summary>
1635 /// Returns value with specified <paramref name="bits"/> toggled.
1636 /// </summary>
1637 /// <param name="source">Value source.</param>
1638 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1639 /// <returns><see cref="int"/> value with specified <paramref name="bits"/> toggled.</returns>
1640 [CLSCompliant(false)]
1641 public static int ToggleBits(this int source, Bits bits)
1642 {
1643 checked
1644 {
1645 return ToggleBits(source, (int)bits);
1646 }
1647 }
1648
1649 /// <summary>
1650 /// Returns value with specified <paramref name="bits"/> toggled.
1651 /// </summary>
1652 /// <param name="source">Value source.</param>
1653 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1654 /// <returns><see cref="int"/> value with specified <paramref name="bits"/> toggled.</returns>
1655 public static int ToggleBits(this int source, int bits)
1656 {
1657 return (source ^ bits);
1658 }
1659
1660 /// <summary>
1661 /// Returns value with specified <paramref name="bits"/> toggled.
1662 /// </summary>
1663 /// <param name="source">Value source.</param>
1664 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1665 /// <returns><see cref="uint"/> value with specified <paramref name="bits"/> toggled.</returns>
1666 [CLSCompliant(false)]
1667 public static uint ToggleBits(this uint source, Bits bits)
1668 {
1669 checked
1670 {
1671 return ToggleBits(source, (uint)bits);
1672 }
1673 }
1674
1675 /// <summary>
1676 /// Returns value with specified <paramref name="bits"/> toggled.
1677 /// </summary>
1678 /// <param name="source">Value source.</param>
1679 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1680 /// <returns><see cref="uint"/> value with specified <paramref name="bits"/> toggled.</returns>
1681 [CLSCompliant(false)]
1682 public static uint ToggleBits(this uint source, uint bits)
1683 {
1684 return (source ^ bits);
1685 }
1686
1687 /// <summary>
1688 /// Returns value with specified <paramref name="bits"/> toggled.
1689 /// </summary>
1690 /// <param name="source">Value source.</param>
1691 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1692 /// <returns><see cref="long"/> value with specified <paramref name="bits"/> toggled.</returns>
1693 [CLSCompliant(false)]
1694 public static long ToggleBits(this long source, Bits bits)
1695 {
1696 checked
1697 {
1698 return ToggleBits(source, (long)bits);
1699 }
1700 }
1701
1702 /// <summary>
1703 /// Returns value with specified <paramref name="bits"/> toggled.
1704 /// </summary>
1705 /// <param name="source">Value source.</param>
1706 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1707 /// <returns><see cref="long"/> value with specified <paramref name="bits"/> toggled.</returns>
1708 public static long ToggleBits(this long source, long bits)
1709 {
1710 return (source ^ bits);
1711 }
1712
1713 /// <summary>
1714 /// Returns value with specified <paramref name="bits"/> toggled.
1715 /// </summary>
1716 /// <param name="source">Value source.</param>
1717 /// <param name="bits"><see cref="Bits"/> to toggle.</param>
1718 /// <returns><see cref="ulong"/> value with specified <paramref name="bits"/> toggled.</returns>
1719 [CLSCompliant(false)]
1720 public static ulong ToggleBits(this ulong source, Bits bits)
1721 {
1722 checked
1723 {
1724 return ToggleBits(source, (ulong)bits);
1725 }
1726 }
1727
1728 /// <summary>
1729 /// Returns value with specified <paramref name="bits"/> toggled.
1730 /// </summary>
1731 /// <param name="source">Value source.</param>
1732 /// <param name="bits">Bit-mask of the bits to toggle.</param>
1733 /// <returns><see cref="ulong"/> value with specified <paramref name="bits"/> toggled.</returns>
1734 [CLSCompliant(false)]
1735 public static ulong ToggleBits(this ulong source, ulong bits)
1736 {
1737 return (source ^ bits);
1738 }
1739
1740 #endregion
1741
1742 #region [ GetMaskedValue Extensions ]
1743
1744 /// <summary>
1745 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1746 /// </summary>
1747 /// <param name="source">Value source.</param>
1748 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1749 /// <returns><see cref="sbyte"/> value.</returns>
1750 [CLSCompliant(false)]
1751 public static sbyte GetMaskedValue(this sbyte source, Bits bitmask)
1752 {
1753 checked
1754 {
1755 return GetMaskedValue(source, (sbyte)bitmask);
1756 }
1757 }
1758
1759 /// <summary>
1760 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1761 /// </summary>
1762 /// <param name="source">Value source.</param>
1763 /// <param name="bitmask">Bit-mask of the bits involved.</param>
1764 /// <returns><see cref="sbyte"/> value.</returns>
1765 [CLSCompliant(false)]
1766 public static sbyte GetMaskedValue(this sbyte source, sbyte bitmask)
1767 {
1768 return ((sbyte)(source & bitmask));
1769 }
1770
1771 /// <summary>
1772 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1773 /// </summary>
1774 /// <param name="source">Value source.</param>
1775 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1776 /// <returns><see cref="byte"/> value.</returns>
1777 [CLSCompliant(false)]
1778 public static byte GetMaskedValue(this byte source, Bits bitmask)
1779 {
1780 checked
1781 {
1782 return GetMaskedValue(source, (byte)bitmask);
1783 }
1784 }
1785
1786 /// <summary>
1787 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1788 /// </summary>
1789 /// <param name="source">Value source.</param>
1790 /// <param name="bitmask">Bit-mask of the bits involved.</param>
1791 /// <returns><see cref="byte"/> value.</returns>
1792 public static byte GetMaskedValue(this byte source, byte bitmask)
1793 {
1794 return ((byte)(source & bitmask));
1795 }
1796
1797 /// <summary>
1798 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1799 /// </summary>
1800 /// <param name="source">Value source.</param>
1801 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1802 /// <returns><see cref="short"/> value.</returns>
1803 [CLSCompliant(false)]
1804 public static short GetMaskedValue(this short source, Bits bitmask)
1805 {
1806 checked
1807 {
1808 return GetMaskedValue(source, (short)bitmask);
1809 }
1810 }
1811
1812 /// <summary>
1813 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1814 /// </summary>
1815 /// <param name="source">Value source.</param>
1816 /// <param name="bitmask">Bit-mask of the bits involved.</param>
1817 /// <returns><see cref="short"/> value.</returns>
1818 public static short GetMaskedValue(this short source, short bitmask)
1819 {
1820 return ((short)(source & bitmask));
1821 }
1822
1823 /// <summary>
1824 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1825 /// </summary>
1826 /// <param name="source">Value source.</param>
1827 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1828 /// <returns><see cref="ushort"/> value.</returns>
1829 [CLSCompliant(false)]
1830 public static ushort GetMaskedValue(this ushort source, Bits bitmask)
1831 {
1832 checked
1833 {
1834 return GetMaskedValue(source, (ushort)bitmask);
1835 }
1836 }
1837
1838 /// <summary>
1839 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1840 /// </summary>
1841 /// <param name="source">Value source.</param>
1842 /// <param name="bitmask">Bit-mask of the bits involved.</param>
1843 /// <returns><see cref="ushort"/> value.</returns>
1844 [CLSCompliant(false)]
1845 public static ushort GetMaskedValue(this ushort source, ushort bitmask)
1846 {
1847 return ((ushort)(source & bitmask));
1848 }
1849
1850 /// <summary>
1851 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1852 /// </summary>
1853 /// <param name="source">Value source.</param>
1854 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1855 /// <returns><see cref="Int24"/> value.</returns>
1856 [CLSCompliant(false)]
1857 public static Int24 GetMaskedValue(this Int24 source, Bits bitmask)
1858 {
1859 checked
1860 {
1861 return GetMaskedValue(source, (Int24)bitmask);
1862 }
1863 }
1864
1865 /// <summary>
1866 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1867 /// </summary>
1868 /// <param name="source">Value source.</param>
1869 /// <param name="bitmask">Bit-mask of the bits involved.</param>
1870 /// <returns><see cref="Int24"/> value.</returns>
1871 public static Int24 GetMaskedValue(this Int24 source, Int24 bitmask)
1872 {
1873 return (source & bitmask);
1874 }
1875
1876 /// <summary>
1877 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1878 /// </summary>
1879 /// <param name="source">Value source.</param>
1880 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1881 /// <returns><see cref="UInt24"/> value.</returns>
1882 [CLSCompliant(false)]
1883 public static UInt24 GetMaskedValue(this UInt24 source, Bits bitmask)
1884 {
1885 checked
1886 {
1887 return GetMaskedValue(source, (UInt24)bitmask);
1888 }
1889 }
1890
1891 /// <summary>
1892 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1893 /// </summary>
1894 /// <param name="source">Value source.</param>
1895 /// <param name="bitmask">Bit-mask of the bits involved.</param>
1896 /// <returns><see cref="UInt24"/> value.</returns>
1897 [CLSCompliant(false)]
1898 public static UInt24 GetMaskedValue(this UInt24 source, UInt24 bitmask)
1899 {
1900 return (source & bitmask);
1901 }
1902
1903 /// <summary>
1904 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1905 /// </summary>
1906 /// <param name="source">Value source.</param>
1907 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1908 /// <returns><see cref="int"/> value.</returns>
1909 [CLSCompliant(false)]
1910 public static int GetMaskedValue(this int source, Bits bitmask)
1911 {
1912 checked
1913 {
1914 return GetMaskedValue(source, (int)bitmask);
1915 }
1916 }
1917
1918 /// <summary>
1919 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1920 /// </summary>
1921 /// <param name="source">Value source.</param>
1922 /// <param name="bitmask">Bit-mask of the bits involved.</param>
1923 /// <returns><see cref="int"/> value.</returns>
1924 public static int GetMaskedValue(this int source, int bitmask)
1925 {
1926 return (source & bitmask);
1927 }
1928
1929 /// <summary>
1930 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1931 /// </summary>
1932 /// <param name="source">Value source.</param>
1933 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1934 /// <returns><see cref="uint"/> value.</returns>
1935 [CLSCompliant(false)]
1936 public static uint GetMaskedValue(this uint source, Bits bitmask)
1937 {
1938 checked
1939 {
1940 return GetMaskedValue(source, (uint)bitmask);
1941 }
1942 }
1943
1944 /// <summary>
1945 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1946 /// </summary>
1947 /// <param name="source">Value source.</param>
1948 /// <param name="bitmask">Bit-mask of the bits involved.</param>
1949 /// <returns><see cref="uint"/> value.</returns>
1950 [CLSCompliant(false)]
1951 public static uint GetMaskedValue(this uint source, uint bitmask)
1952 {
1953 return (source & bitmask);
1954 }
1955
1956 /// <summary>
1957 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1958 /// </summary>
1959 /// <param name="source">Value source.</param>
1960 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1961 /// <returns><see cref="long"/> value.</returns>
1962 [CLSCompliant(false)]
1963 public static long GetMaskedValue(this long source, Bits bitmask)
1964 {
1965 checked
1966 {
1967 return GetMaskedValue(source, (long)bitmask);
1968 }
1969 }
1970
1971 /// <summary>
1972 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1973 /// </summary>
1974 /// <param name="source">Value source.</param>
1975 /// <param name="bitmask">Bit-mask of the bits involved.</param>
1976 /// <returns><see cref="long"/> value.</returns>
1977 public static long GetMaskedValue(this long source, long bitmask)
1978 {
1979 return (source & bitmask);
1980 }
1981
1982 /// <summary>
1983 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1984 /// </summary>
1985 /// <param name="source">Value source.</param>
1986 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
1987 /// <returns><see cref="ulong"/> value.</returns>
1988 [CLSCompliant(false)]
1989 public static ulong GetMaskedValue(this ulong source, Bits bitmask)
1990 {
1991 checked
1992 {
1993 return GetMaskedValue(source, (ulong)bitmask);
1994 }
1995 }
1996
1997 /// <summary>
1998 /// Returns value stored in the bits represented by the specified <paramref name="bitmask"/>.
1999 /// </summary>
2000 /// <param name="source">Value source.</param>
2001 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2002 /// <returns><see cref="ulong"/> value.</returns>
2003 [CLSCompliant(false)]
2004 public static ulong GetMaskedValue(this ulong source, ulong bitmask)
2005 {
2006 return (source & bitmask);
2007 }
2008
2009 #endregion
2010
2011 #region [ SetMaskedValue Extensions ]
2012
2013 /// <summary>
2014 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2015 /// </summary>
2016 /// <param name="source">Value source.</param>
2017 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2018 /// <param name="value">New value.</param>
2019 /// <returns><see cref="sbyte"/> value.</returns>
2020 [CLSCompliant(false)]
2021 public static sbyte SetMaskedValue(this sbyte source, Bits bitmask, sbyte value)
2022 {
2023 checked
2024 {
2025 return SetMaskedValue(source, (sbyte)bitmask, value);
2026 }
2027 }
2028
2029 /// <summary>
2030 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2031 /// </summary>
2032 /// <param name="source">Value source.</param>
2033 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2034 /// <param name="value">New value.</param>
2035 /// <returns><see cref="sbyte"/> value.</returns>
2036 [CLSCompliant(false)]
2037 public static sbyte SetMaskedValue(this sbyte source, sbyte bitmask, sbyte value)
2038 {
2039 return ((sbyte)((sbyte)(source & ~bitmask) | value));
2040 }
2041
2042 /// <summary>
2043 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2044 /// </summary>
2045 /// <param name="source">Value source.</param>
2046 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2047 /// <param name="value">New value.</param>
2048 /// <returns><see cref="byte"/> value.</returns>
2049 [CLSCompliant(false)]
2050 public static byte SetMaskedValue(this byte source, Bits bitmask, byte value)
2051 {
2052 checked
2053 {
2054 return SetMaskedValue(source, (byte)bitmask, value);
2055 }
2056 }
2057
2058 /// <summary>
2059 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2060 /// </summary>
2061 /// <param name="source">Value source.</param>
2062 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2063 /// <param name="value">New value.</param>
2064 /// <returns><see cref="byte"/> value.</returns>
2065 public static byte SetMaskedValue(this byte source, byte bitmask, byte value)
2066 {
2067 return ((byte)((source & ~bitmask) | value));
2068 }
2069
2070 /// <summary>
2071 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2072 /// </summary>
2073 /// <param name="source">Value source.</param>
2074 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2075 /// <param name="value">New value.</param>
2076 /// <returns><see cref="short"/> value.</returns>
2077 [CLSCompliant(false)]
2078 public static short SetMaskedValue(this short source, Bits bitmask, short value)
2079 {
2080 checked
2081 {
2082 return SetMaskedValue(source, (short)bitmask, value);
2083 }
2084 }
2085
2086 /// <summary>
2087 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2088 /// </summary>
2089 /// <param name="source">Value source.</param>
2090 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2091 /// <param name="value">New value.</param>
2092 /// <returns><see cref="short"/> value.</returns>
2093 public static short SetMaskedValue(this short source, short bitmask, short value)
2094 {
2095 return ((short)((short)(source & ~bitmask) | value));
2096 }
2097
2098 /// <summary>
2099 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2100 /// </summary>
2101 /// <param name="source">Value source.</param>
2102 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2103 /// <param name="value">New value.</param>
2104 /// <returns><see cref="ushort"/> value.</returns>
2105 [CLSCompliant(false)]
2106 public static ushort SetMaskedValue(this ushort source, Bits bitmask, ushort value)
2107 {
2108 checked
2109 {
2110 return SetMaskedValue(source, (ushort)bitmask, value);
2111 }
2112 }
2113
2114 /// <summary>
2115 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2116 /// </summary>
2117 /// <param name="source">Value source.</param>
2118 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2119 /// <param name="value">New value.</param>
2120 /// <returns><see cref="ushort"/> value.</returns>
2121 [CLSCompliant(false)]
2122 public static ushort SetMaskedValue(this ushort source, ushort bitmask, ushort value)
2123 {
2124 return ((ushort)((source & ~bitmask) | value));
2125 }
2126
2127 /// <summary>
2128 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2129 /// </summary>
2130 /// <param name="source">Value source.</param>
2131 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2132 /// <param name="value">New value.</param>
2133 /// <returns><see cref="Int24"/> value.</returns>
2134 [CLSCompliant(false)]
2135 public static Int24 SetMaskedValue(this Int24 source, Bits bitmask, Int24 value)
2136 {
2137 checked
2138 {
2139 return SetMaskedValue(source, (Int24)bitmask, value);
2140 }
2141 }
2142
2143 /// <summary>
2144 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2145 /// </summary>
2146 /// <param name="source">Value source.</param>
2147 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2148 /// <param name="value">New value.</param>
2149 /// <returns><see cref="Int24"/> value.</returns>
2150 public static Int24 SetMaskedValue(this Int24 source, Int24 bitmask, Int24 value)
2151 {
2152 return ((source & ~bitmask) | value);
2153 }
2154
2155 /// <summary>
2156 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2157 /// </summary>
2158 /// <param name="source">Value source.</param>
2159 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2160 /// <param name="value">New value.</param>
2161 /// <returns><see cref="UInt24"/> value.</returns>
2162 [CLSCompliant(false)]
2163 public static UInt24 SetMaskedValue(this UInt24 source, Bits bitmask, UInt24 value)
2164 {
2165 checked
2166 {
2167 return SetMaskedValue(source, (UInt24)bitmask, value);
2168 }
2169 }
2170
2171 /// <summary>
2172 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2173 /// </summary>
2174 /// <param name="source">Value source.</param>
2175 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2176 /// <param name="value">New value.</param>
2177 /// <returns><see cref="UInt24"/> value.</returns>
2178 [CLSCompliant(false)]
2179 public static UInt24 SetMaskedValue(this UInt24 source, UInt24 bitmask, UInt24 value)
2180 {
2181 return ((source & ~bitmask) | value);
2182 }
2183
2184 /// <summary>
2185 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2186 /// </summary>
2187 /// <param name="source">Value source.</param>
2188 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2189 /// <param name="value">New value.</param>
2190 /// <returns><see cref="int"/> value.</returns>
2191 [CLSCompliant(false)]
2192 public static int SetMaskedValue(this int source, Bits bitmask, int value)
2193 {
2194 checked
2195 {
2196 return SetMaskedValue(source, (int)bitmask, value);
2197 }
2198 }
2199
2200 /// <summary>
2201 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2202 /// </summary>
2203 /// <param name="source">Value source.</param>
2204 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2205 /// <param name="value">New value.</param>
2206 /// <returns><see cref="int"/> value.</returns>
2207 public static int SetMaskedValue(this int source, int bitmask, int value)
2208 {
2209 return ((source & ~bitmask) | value);
2210 }
2211
2212 /// <summary>
2213 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2214 /// </summary>
2215 /// <param name="source">Value source.</param>
2216 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2217 /// <param name="value">New value.</param>
2218 /// <returns><see cref="uint"/> value.</returns>
2219 [CLSCompliant(false)]
2220 public static uint SetMaskedValue(this uint source, Bits bitmask, uint value)
2221 {
2222 checked
2223 {
2224 return SetMaskedValue(source, (uint)bitmask, value);
2225 }
2226 }
2227
2228 /// <summary>
2229 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2230 /// </summary>
2231 /// <param name="source">Value source.</param>
2232 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2233 /// <param name="value">New value.</param>
2234 /// <returns><see cref="uint"/> value.</returns>
2235 [CLSCompliant(false)]
2236 public static uint SetMaskedValue(this uint source, uint bitmask, uint value)
2237 {
2238 return ((source & ~bitmask) | value);
2239 }
2240
2241 /// <summary>
2242 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2243 /// </summary>
2244 /// <param name="source">Value source.</param>
2245 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2246 /// <param name="value">New value.</param>
2247 /// <returns><see cref="long"/> value.</returns>
2248 [CLSCompliant(false)]
2249 public static long SetMaskedValue(this long source, Bits bitmask, long value)
2250 {
2251 checked
2252 {
2253 return SetMaskedValue(source, (long)bitmask, value);
2254 }
2255 }
2256
2257 /// <summary>
2258 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2259 /// </summary>
2260 /// <param name="source">Value source.</param>
2261 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2262 /// <param name="value">New value.</param>
2263 /// <returns><see cref="long"/> value.</returns>
2264 public static long SetMaskedValue(this long source, long bitmask, long value)
2265 {
2266 return ((source & ~bitmask) | value);
2267 }
2268
2269 /// <summary>
2270 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2271 /// </summary>
2272 /// <param name="source">Value source.</param>
2273 /// <param name="bitmask"><see cref="Bits"/> that make-up the bit-mask.</param>
2274 /// <param name="value">New value.</param>
2275 /// <returns><see cref="ulong"/> value.</returns>
2276 [CLSCompliant(false)]
2277 public static ulong SetMaskedValue(this ulong source, Bits bitmask, ulong value)
2278 {
2279 checked
2280 {
2281 return SetMaskedValue(source, (ulong)bitmask, value);
2282 }
2283 }
2284
2285 /// <summary>
2286 /// Returns value after setting a new <paramref name="value"/> for the bits specified by the <paramref name="bitmask"/>.
2287 /// </summary>
2288 /// <param name="source">Value source.</param>
2289 /// <param name="bitmask">Bit-mask of the bits involved.</param>
2290 /// <param name="value">New value.</param>
2291 /// <returns><see cref="ulong"/> value.</returns>
2292 [CLSCompliant(false)]
2293 public static ulong SetMaskedValue(this ulong source, ulong bitmask, ulong value)
2294 {
2295 return ((source & ~bitmask) | value);
2296 }
2297
2298 #endregion
2299
2300 #region [ Bit Rotation Extensions ]
2301
2302 /// <summary>
2303 /// Performs rightwise bit-rotation for the specified number of rotations.
2304 /// </summary>
2305 /// <param name="value">Value used for bit-rotation.</param>
2306 /// <param name="rotations">Number of rotations to perform.</param>
2307 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2308 /// <remarks>
2309 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2310 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2311 /// architectures.
2312 /// </remarks>
2313 public static byte BitRotL(this byte value, int rotations)
2314 {
2315 bool hiBitSet;
2316
2317 for (int x = 1; x <= (rotations % 8); x++)
2318 {
2319 hiBitSet = value.CheckBits(Bits.Bit07);
2320
2321 value <<= 1;
2322
2323 if (hiBitSet)
2324 value = value.SetBits(Bits.Bit00);
2325 }
2326
2327 return value;
2328 }
2329
2330 /// <summary>
2331 /// Performs rightwise bit-rotation for the specified number of rotations.
2332 /// </summary>
2333 /// <param name="value">Value used for bit-rotation.</param>
2334 /// <param name="rotations">Number of rotations to perform.</param>
2335 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2336 /// <remarks>
2337 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2338 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2339 /// architectures.
2340 /// </remarks>
2341 [CLSCompliant(false)]
2342 public static sbyte BitRotL(this sbyte value, int rotations)
2343 {
2344 bool hiBitSet;
2345
2346 for (int x = 1; x <= (rotations % 8); x++)
2347 {
2348 hiBitSet = value.CheckBits(Bits.Bit07);
2349
2350 value <<= 1;
2351
2352 if (hiBitSet)
2353 value = value.SetBits(Bits.Bit00);
2354 }
2355
2356 return value;
2357 }
2358
2359 /// <summary>
2360 /// Performs rightwise bit-rotation for the specified number of rotations.
2361 /// </summary>
2362 /// <param name="value">Value used for bit-rotation.</param>
2363 /// <param name="rotations">Number of rotations to perform.</param>
2364 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2365 /// <remarks>
2366 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2367 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2368 /// architectures.
2369 /// </remarks>
2370 public static short BitRotL(this short value, int rotations)
2371 {
2372 bool hiBitSet;
2373
2374 for (int x = 1; x <= (rotations % 16); x++)
2375 {
2376 hiBitSet = value.CheckBits(Bits.Bit15);
2377
2378 value <<= 1;
2379
2380 if (hiBitSet)
2381 value = value.SetBits(Bits.Bit00);
2382 }
2383
2384 return value;
2385 }
2386
2387 /// <summary>
2388 /// Performs rightwise bit-rotation for the specified number of rotations.
2389 /// </summary>
2390 /// <param name="value">Value used for bit-rotation.</param>
2391 /// <param name="rotations">Number of rotations to perform.</param>
2392 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2393 /// <remarks>
2394 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2395 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2396 /// architectures.
2397 /// </remarks>
2398 [CLSCompliant(false)]
2399 public static ushort BitRotL(this ushort value, int rotations)
2400 {
2401 bool hiBitSet;
2402
2403 for (int x = 1; x <= (rotations % 16); x++)
2404 {
2405 hiBitSet = value.CheckBits(Bits.Bit15);
2406
2407 value <<= 1;
2408
2409 if (hiBitSet)
2410 value = value.SetBits(Bits.Bit00);
2411 }
2412
2413 return value;
2414 }
2415
2416 /// <summary>
2417 /// Performs rightwise bit-rotation for the specified number of rotations.
2418 /// </summary>
2419 /// <param name="value">Value used for bit-rotation.</param>
2420 /// <param name="rotations">Number of rotations to perform.</param>
2421 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2422 /// <remarks>
2423 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2424 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2425 /// architectures.
2426 /// </remarks>
2427 public static Int24 BitRotL(this Int24 value, int rotations)
2428 {
2429 bool hiBitSet;
2430
2431 for (int x = 1; x <= (rotations % 24); x++)
2432 {
2433 hiBitSet = value.CheckBits(Bits.Bit23);
2434
2435 value <<= 1;
2436
2437 if (hiBitSet)
2438 value = value.SetBits(Bits.Bit00);
2439 }
2440
2441 return value;
2442 }
2443
2444 /// <summary>
2445 /// Performs rightwise bit-rotation for the specified number of rotations.
2446 /// </summary>
2447 /// <param name="value">Value used for bit-rotation.</param>
2448 /// <param name="rotations">Number of rotations to perform.</param>
2449 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2450 /// <remarks>
2451 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2452 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2453 /// architectures.
2454 /// </remarks>
2455 [CLSCompliant(false)]
2456 public static UInt24 BitRotL(this UInt24 value, int rotations)
2457 {
2458 bool hiBitSet;
2459
2460 for (int x = 1; x <= (rotations % 24); x++)
2461 {
2462 hiBitSet = value.CheckBits(Bits.Bit23);
2463
2464 value <<= 1;
2465
2466 if (hiBitSet)
2467 value = value.SetBits(Bits.Bit00);
2468 }
2469
2470 return value;
2471 }
2472
2473 /// <summary>
2474 /// Performs rightwise bit-rotation for the specified number of rotations.
2475 /// </summary>
2476 /// <param name="value">Value used for bit-rotation.</param>
2477 /// <param name="rotations">Number of rotations to perform.</param>
2478 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2479 /// <remarks>
2480 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2481 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2482 /// architectures.
2483 /// </remarks>
2484 public static int BitRotL(this int value, int rotations)
2485 {
2486 bool hiBitSet;
2487
2488 for (int x = 1; x <= (rotations % 32); x++)
2489 {
2490 hiBitSet = value.CheckBits(Bits.Bit31);
2491
2492 value <<= 1;
2493
2494 if (hiBitSet)
2495 value = value.SetBits(Bits.Bit00);
2496 }
2497
2498 return value;
2499 }
2500
2501 /// <summary>
2502 /// Performs rightwise bit-rotation for the specified number of rotations.
2503 /// </summary>
2504 /// <param name="value">Value used for bit-rotation.</param>
2505 /// <param name="rotations">Number of rotations to perform.</param>
2506 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2507 /// <remarks>
2508 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2509 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2510 /// architectures.
2511 /// </remarks>
2512 [CLSCompliant(false)]
2513 public static uint BitRotL(this uint value, int rotations)
2514 {
2515 bool hiBitSet;
2516
2517 for (int x = 1; x <= (rotations % 32); x++)
2518 {
2519 hiBitSet = value.CheckBits(Bits.Bit31);
2520
2521 value <<= 1;
2522
2523 if (hiBitSet)
2524 value = value.SetBits(Bits.Bit00);
2525 }
2526
2527 return value;
2528 }
2529
2530 /// <summary>
2531 /// Performs rightwise bit-rotation for the specified number of rotations.
2532 /// </summary>
2533 /// <param name="value">Value used for bit-rotation.</param>
2534 /// <param name="rotations">Number of rotations to perform.</param>
2535 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2536 /// <remarks>
2537 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2538 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2539 /// architectures.
2540 /// </remarks>
2541 public static long BitRotL(this long value, int rotations)
2542 {
2543 bool hiBitSet;
2544
2545 for (int x = 1; x <= (rotations % 64); x++)
2546 {
2547 hiBitSet = value.CheckBits(Bits.Bit63);
2548
2549 value <<= 1;
2550
2551 if (hiBitSet)
2552 value = value.SetBits(Bits.Bit00);
2553 }
2554
2555 return value;
2556 }
2557
2558 /// <summary>
2559 /// Performs rightwise bit-rotation for the specified number of rotations.
2560 /// </summary>
2561 /// <param name="value">Value used for bit-rotation.</param>
2562 /// <param name="rotations">Number of rotations to perform.</param>
2563 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2564 /// <remarks>
2565 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2566 /// .NET bit shift operators. As a result bits may actually appear to rotate right on little-endian
2567 /// architectures.
2568 /// </remarks>
2569 [CLSCompliant(false)]
2570 public static ulong BitRotL(this ulong value, int rotations)
2571 {
2572 bool hiBitSet;
2573
2574 for (int x = 1; x <= (rotations % 64); x++)
2575 {
2576 hiBitSet = value.CheckBits(Bits.Bit63);
2577
2578 value <<= 1;
2579
2580 if (hiBitSet)
2581 value = value.SetBits(Bits.Bit00);
2582 }
2583
2584 return value;
2585 }
2586
2587 /// <summary>
2588 /// Performs rightwise bit-rotation for the specified number of rotations.
2589 /// </summary>
2590 /// <param name="value">Value used for bit-rotation.</param>
2591 /// <param name="rotations">Number of rotations to perform.</param>
2592 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2593 /// <remarks>
2594 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2595 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2596 /// architectures.
2597 /// </remarks>
2598 public static byte BitRotR(this byte value, int rotations)
2599 {
2600 bool loBitSet;
2601
2602 for (int x = 1; x <= (rotations % 8); x++)
2603 {
2604 loBitSet = value.CheckBits(Bits.Bit00);
2605
2606 value >>= 1;
2607
2608 if (loBitSet)
2609 value = value.SetBits(Bits.Bit07);
2610 else
2611 value = value.ClearBits(Bits.Bit07);
2612 }
2613
2614 return value;
2615 }
2616
2617 /// <summary>
2618 /// Performs rightwise bit-rotation for the specified number of rotations.
2619 /// </summary>
2620 /// <param name="value">Value used for bit-rotation.</param>
2621 /// <param name="rotations">Number of rotations to perform.</param>
2622 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2623 /// <remarks>
2624 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2625 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2626 /// architectures.
2627 /// </remarks>
2628 [CLSCompliant(false)]
2629 public static sbyte BitRotR(this sbyte value, int rotations)
2630 {
2631 bool loBitSet;
2632
2633 for (int x = 1; x <= (rotations % 8); x++)
2634 {
2635 loBitSet = value.CheckBits(Bits.Bit00);
2636
2637 value >>= 1;
2638
2639 if (loBitSet)
2640 value = value.SetBits(Bits.Bit07);
2641 else
2642 value = value.ClearBits(Bits.Bit07);
2643 }
2644
2645 return value;
2646 }
2647
2648 /// <summary>
2649 /// Performs rightwise bit-rotation for the specified number of rotations.
2650 /// </summary>
2651 /// <param name="value">Value used for bit-rotation.</param>
2652 /// <param name="rotations">Number of rotations to perform.</param>
2653 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2654 /// <remarks>
2655 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2656 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2657 /// architectures.
2658 /// </remarks>
2659 public static short BitRotR(this short value, int rotations)
2660 {
2661 bool loBitSet;
2662
2663 for (int x = 1; x <= (rotations % 16); x++)
2664 {
2665 loBitSet = value.CheckBits(Bits.Bit00);
2666
2667 value >>= 1;
2668
2669 if (loBitSet)
2670 value = value.SetBits(Bits.Bit15);
2671 else
2672 value = value.ClearBits(Bits.Bit15);
2673 }
2674
2675 return value;
2676 }
2677
2678 /// <summary>
2679 /// Performs rightwise bit-rotation for the specified number of rotations.
2680 /// </summary>
2681 /// <param name="value">Value used for bit-rotation.</param>
2682 /// <param name="rotations">Number of rotations to perform.</param>
2683 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2684 /// <remarks>
2685 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2686 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2687 /// architectures.
2688 /// </remarks>
2689 [CLSCompliant(false)]
2690 public static ushort BitRotR(this ushort value, int rotations)
2691 {
2692 bool loBitSet;
2693
2694 for (int x = 1; x <= (rotations % 16); x++)
2695 {
2696 loBitSet = value.CheckBits(Bits.Bit00);
2697
2698 value >>= 1;
2699
2700 if (loBitSet)
2701 value = value.SetBits(Bits.Bit15);
2702 else
2703 value = value.ClearBits(Bits.Bit15);
2704 }
2705
2706 return value;
2707 }
2708
2709 /// <summary>
2710 /// Performs rightwise bit-rotation for the specified number of rotations.
2711 /// </summary>
2712 /// <param name="value">Value used for bit-rotation.</param>
2713 /// <param name="rotations">Number of rotations to perform.</param>
2714 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2715 /// <remarks>
2716 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2717 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2718 /// architectures.
2719 /// </remarks>
2720 public static Int24 BitRotR(this Int24 value, int rotations)
2721 {
2722 bool loBitSet;
2723
2724 for (int x = 1; x <= (rotations % 24); x++)
2725 {
2726 loBitSet = value.CheckBits(Bits.Bit00);
2727
2728 value >>= 1;
2729
2730 if (loBitSet)
2731 value = value.SetBits(Bits.Bit23);
2732 else
2733 value = value.ClearBits(Bits.Bit23);
2734 }
2735
2736 return value;
2737 }
2738
2739 /// <summary>
2740 /// Performs rightwise bit-rotation for the specified number of rotations.
2741 /// </summary>
2742 /// <param name="value">Value used for bit-rotation.</param>
2743 /// <param name="rotations">Number of rotations to perform.</param>
2744 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2745 /// <remarks>
2746 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2747 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2748 /// architectures.
2749 /// </remarks>
2750 [CLSCompliant(false)]
2751 public static UInt24 BitRotR(this UInt24 value, int rotations)
2752 {
2753 bool loBitSet;
2754
2755 for (int x = 1; x <= (rotations % 24); x++)
2756 {
2757 loBitSet = value.CheckBits(Bits.Bit00);
2758
2759 value >>= 1;
2760
2761 if (loBitSet)
2762 value = value.SetBits(Bits.Bit23);
2763 else
2764 value = value.ClearBits(Bits.Bit23);
2765 }
2766
2767 return value;
2768 }
2769
2770 /// <summary>
2771 /// Performs rightwise bit-rotation for the specified number of rotations.
2772 /// </summary>
2773 /// <param name="value">Value used for bit-rotation.</param>
2774 /// <param name="rotations">Number of rotations to perform.</param>
2775 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2776 /// <remarks>
2777 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2778 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2779 /// architectures.
2780 /// </remarks>
2781 public static int BitRotR(this int value, int rotations)
2782 {
2783 bool loBitSet;
2784
2785 for (int x = 1; x <= (rotations % 32); x++)
2786 {
2787 loBitSet = value.CheckBits(Bits.Bit00);
2788
2789 value >>= 1;
2790
2791 if (loBitSet)
2792 value = value.SetBits(Bits.Bit31);
2793 else
2794 value = value.ClearBits(Bits.Bit31);
2795 }
2796
2797 return value;
2798 }
2799
2800 /// <summary>
2801 /// Performs rightwise bit-rotation for the specified number of rotations.
2802 /// </summary>
2803 /// <param name="value">Value used for bit-rotation.</param>
2804 /// <param name="rotations">Number of rotations to perform.</param>
2805 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2806 /// <remarks>
2807 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2808 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2809 /// architectures.
2810 /// </remarks>
2811 [CLSCompliant(false)]
2812 public static uint BitRotR(this uint value, int rotations)
2813 {
2814 bool loBitSet;
2815
2816 for (int x = 1; x <= (rotations % 32); x++)
2817 {
2818 loBitSet = value.CheckBits(Bits.Bit00);
2819
2820 value >>= 1;
2821
2822 if (loBitSet)
2823 value = value.SetBits(Bits.Bit31);
2824 else
2825 value = value.ClearBits(Bits.Bit31);
2826 }
2827
2828 return value;
2829 }
2830
2831 /// <summary>
2832 /// Performs rightwise bit-rotation for the specified number of rotations.
2833 /// </summary>
2834 /// <param name="value">Value used for bit-rotation.</param>
2835 /// <param name="rotations">Number of rotations to perform.</param>
2836 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2837 /// <remarks>
2838 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2839 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2840 /// architectures.
2841 /// </remarks>
2842 public static long BitRotR(this long value, int rotations)
2843 {
2844 bool loBitSet;
2845
2846 for (int x = 1; x <= (rotations % 64); x++)
2847 {
2848 loBitSet = value.CheckBits(Bits.Bit00);
2849
2850 value >>= 1;
2851
2852 if (loBitSet)
2853 value = value.SetBits(Bits.Bit63);
2854 else
2855 value = value.ClearBits(Bits.Bit63);
2856 }
2857
2858 return value;
2859 }
2860
2861 /// <summary>
2862 /// Performs rightwise bit-rotation for the specified number of rotations.
2863 /// </summary>
2864 /// <param name="value">Value used for bit-rotation.</param>
2865 /// <param name="rotations">Number of rotations to perform.</param>
2866 /// <returns>Value that has its bits rotated to the right the specified number of times.</returns>
2867 /// <remarks>
2868 /// Actual rotation direction is from a big-endian perspective - this is an artifact of the native
2869 /// .NET bit shift operators. As a result bits may actually appear to rotate left on little-endian
2870 /// architectures.
2871 /// </remarks>
2872 [CLSCompliant(false)]
2873 public static ulong BitRotR(this ulong value, int rotations)
2874 {
2875 bool loBitSet;
2876
2877 for (int x = 1; x <= (rotations % 64); x++)
2878 {
2879 loBitSet = value.CheckBits(Bits.Bit00);
2880
2881 value >>= 1;
2882
2883 if (loBitSet)
2884 value = value.SetBits(Bits.Bit63);
2885 else
2886 value = value.ClearBits(Bits.Bit63);
2887 }
2888
2889 return value;
2890 }
2891
2892 #endregion
2893 }
2894}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t