/// <summary> /// Throws an <see cref="InvalidEnumArgumentException"/> if the value is invalid for the enum type. /// </summary> /// <param name="value">The value to validate.</param> /// <exception cref="InvalidEnumArgumentException">If the value is invalid for the enum type.</exception> public void ThrowIfInvalidEnumValue(TEnum value) { if (!this.IsValidEnumValue(value)) { throw InvalidEnumArgument.CreateException(nameof(value), value); } }
public static RangeClusivity Combine(Clusivity min, Clusivity max) { switch (min) { case Clusivity.Exclusive: switch (max) { case Clusivity.Exclusive: return(RangeClusivity.Exclusive); case Clusivity.Inclusive: return(RangeClusivity.InclusiveMax); default: throw InvalidEnumArgument.CreateException(nameof(max), max); } case Clusivity.Inclusive: switch (max) { case Clusivity.Exclusive: return(RangeClusivity.InclusiveMin); case Clusivity.Inclusive: return(RangeClusivity.Inclusive); default: throw InvalidEnumArgument.CreateException(nameof(max), max); } default: throw InvalidEnumArgument.CreateException(nameof(min), min); } }
public static void AddFlatQuad <TVertex>( this IMutableDivisibleMesh <TVertex> builder, TVertex topLeft, TVertex topRight, TVertex bottomLeft, TVertex bottomRight, QuadDiagonal diagonal) where TVertex : struct { Contracts.Requires.That(builder != null); using (var group = builder.AddTriangleGroup(new TriangleGroup(triangles: 2, vertices: 4))) { byte offTL = group.AddVertex(topLeft); byte offTR = group.AddVertex(topRight); byte offBL = group.AddVertex(bottomLeft); byte offBR = group.AddVertex(bottomRight); // vertices are added in clockwise winding order switch (diagonal) { case QuadDiagonal.Ascending: group.AddTriangleOffsets(offTL, offTR, offBL).AddTriangleOffsets(offBL, offTR, offBR); return; case QuadDiagonal.Descending: group.AddTriangleOffsets(offTL, offBR, offBL).AddTriangleOffsets(offTL, offTR, offBR); return; default: throw InvalidEnumArgument.CreateException(nameof(diagonal), diagonal); } } }
/// <summary> /// Initializes a new instance of the <see cref="BoundedIndexableEnumerable{TIndex, TValue}"/> class. /// </summary> /// <param name="bounds">The bounds used to limit the enumeration.</param> /// <param name="enumerable">The enumerable that determines the order in which the indices are enumerated.</param> /// <param name="revisitPolicy">The policy for whether or not to re-yield previously enumerated indices again.</param> public BoundedIndexableEnumerable( IBoundedIndexable <TIndex, TValue> bounds, IEnumerable <TIndex> enumerable, Revisits revisitPolicy = Revisits.Yield) { Contracts.Requires.That(bounds != null); Contracts.Requires.That(enumerable != null); this.bounds = bounds; this.enumerable = enumerable; this.maxCount = this.bounds.LowerBounds.CalculateVolume(this.bounds.UpperBounds); switch (revisitPolicy) { case Revisits.Yield: this.yieldRevisits = true; this.cacheRevisits = false; break; case Revisits.YieldCached: this.yieldRevisits = true; this.cacheRevisits = true; break; case Revisits.DontYield: this.yieldRevisits = false; this.cacheRevisits = false; break; default: throw InvalidEnumArgument.CreateException(nameof(revisitPolicy), revisitPolicy); } }
public static Endian ToEndian(this Endianness endianness) { switch (endianness) { case Endianness.BigEndian: return(Endian.Big); case Endianness.LittleEndian: return(Endian.Little); default: throw InvalidEnumArgument.CreateException(nameof(endianness), endianness); } }
/// <summary> /// Gets the axis of the specified axis direction combination. /// </summary> /// <param name="axisDirection">The axis direction.</param> /// <returns>The axis.</returns> public static Axis1D GetAxis(this AxisDirection1D axisDirection) { switch (axisDirection) { case AxisDirection1D.PositiveX: return(Axis1D.X); case AxisDirection1D.NegativeX: return(Axis1D.X); default: throw InvalidEnumArgument.CreateException(nameof(axisDirection), axisDirection); } }
public static int ConvertToInt(this ComparisonResult comparison) { switch (comparison) { case ComparisonResult.Equal: return(0); case ComparisonResult.Less: return(-1); case ComparisonResult.Greater: return(1); default: throw InvalidEnumArgument.CreateException(nameof(comparison), comparison); } }
public static IEnumerable <Index2D> OscillateRange( Index2D startIndex, Index2D dimensions, OscillationOrder2D order = OscillationOrder2D.XY) { Contracts.Requires.That(dimensions.IsAllPositiveOrZero()); switch (order) { case OscillationOrder2D.XY: return(OscillateRangeXY(startIndex, dimensions)); case OscillationOrder2D.YX: return(OscillateRangeYX(startIndex, dimensions)); default: throw InvalidEnumArgument.CreateException(nameof(order), order); } }
/// <inheritdoc /> public T this[Endian endianness] { get { switch (endianness) { case Endian.Big: return(this.BigEndian); case Endian.Little: return(this.LittleEndian); default: throw InvalidEnumArgument.CreateException(nameof(endianness), endianness); } } }
public static Clusivity GetMinClusivity(this RangeClusivity clusivity) { switch (clusivity) { case RangeClusivity.Inclusive: return(Clusivity.Inclusive); case RangeClusivity.Exclusive: return(Clusivity.Exclusive); case RangeClusivity.InclusiveMin: return(Clusivity.Inclusive); case RangeClusivity.InclusiveMax: return(Clusivity.Exclusive); default: throw InvalidEnumArgument.CreateException(nameof(clusivity), clusivity); } }
/// <inheritdoc /> public override string ToString() { switch (this.Bounds) { case RangeClusivity.Inclusive: return($"[{this.Min}, {this.Max}]"); case RangeClusivity.Exclusive: return($"({this.Min}, {this.Max})"); case RangeClusivity.InclusiveMin: return($"[{this.Min}, {this.Max})"); case RangeClusivity.InclusiveMax: return($"({this.Min}, {this.Max}]"); default: throw InvalidEnumArgument.CreateException(nameof(this.Bounds), this.Bounds); } }
/// <summary> /// Gets the number of bytes needed to represent a primitive type. /// </summary> /// <param name="primitiveType">Type of the primitive.</param> /// <returns>The number of bytes needed to represent the primitive type.</returns> public static int NumberOfBytes(this PrimitiveType primitiveType) { switch (primitiveType) { case PrimitiveType.Byte: return(PrimitiveTypeSizes.ByteNumberOfBytes); case PrimitiveType.SByte: return(PrimitiveTypeSizes.SByteNumberOfBytes); case PrimitiveType.Short: return(PrimitiveTypeSizes.ShortNumberOfBytes); case PrimitiveType.UShort: return(PrimitiveTypeSizes.UShortNumberOfBytes); case PrimitiveType.Int: return(PrimitiveTypeSizes.IntNumberOfBytes); case PrimitiveType.UInt: return(PrimitiveTypeSizes.UIntNumberOfBytes); case PrimitiveType.Long: return(PrimitiveTypeSizes.LongNumberOfBytes); case PrimitiveType.ULong: return(PrimitiveTypeSizes.ULongNumberOfBytes); case PrimitiveType.Float: return(PrimitiveTypeSizes.FloatNumberOfBytes); case PrimitiveType.Double: return(PrimitiveTypeSizes.DoubleNumberOfBytes); case PrimitiveType.Decimal: return(PrimitiveTypeSizes.DecimalNumberOfBytes); case PrimitiveType.Char: return(PrimitiveTypeSizes.CharNumberOfBytes); case PrimitiveType.Bool: return(PrimitiveTypeSizes.BoolNumberOfBytes); default: throw InvalidEnumArgument.CreateException(nameof(primitiveType), primitiveType); } }
/// <summary> /// Gets the <see cref="Type"/> the primitive type enumeration represents. /// </summary> /// <param name="primitiveType">Type of the primitive.</param> /// <returns>The type.</returns> public static Type ToType(this PrimitiveType primitiveType) { switch (primitiveType) { case PrimitiveType.Byte: return(typeof(byte)); case PrimitiveType.SByte: return(typeof(sbyte)); case PrimitiveType.Short: return(typeof(short)); case PrimitiveType.UShort: return(typeof(ushort)); case PrimitiveType.Int: return(typeof(int)); case PrimitiveType.UInt: return(typeof(uint)); case PrimitiveType.Long: return(typeof(long)); case PrimitiveType.ULong: return(typeof(ulong)); case PrimitiveType.Float: return(typeof(float)); case PrimitiveType.Double: return(typeof(double)); case PrimitiveType.Decimal: return(typeof(decimal)); case PrimitiveType.Char: return(typeof(char)); case PrimitiveType.Bool: return(typeof(bool)); default: throw InvalidEnumArgument.CreateException(nameof(primitiveType), primitiveType); } }
public static int GetLength(this Range <int> range) { int length = range.Max - range.Min; switch (range.Bounds) { case RangeClusivity.Inclusive: return(length == int.MaxValue ? int.MaxValue : length + 1); case RangeClusivity.Exclusive: return(length == 0 ? 0 : length - 1); case RangeClusivity.InclusiveMin: return(length); case RangeClusivity.InclusiveMax: return(length); default: throw InvalidEnumArgument.CreateException(nameof(range.Bounds), range.Bounds); } }
public static ITargetBlock <T> Create <T>( Func <IReadOnlyList <T>, Task> action, int maxBatchSize, Batching batching, DataflowBlockOptions options) { Contracts.Requires.That(action != null); Contracts.Requires.That(options != null); switch (batching) { case Batching.Dynamic: options = options.CreateCopy(); options.BoundedCapacity = maxBatchSize; return(new DynamicBatchActionBlock <T>(action, options)); case Batching.Static: return(new StaticBatchActionBlock <T>(action, maxBatchSize, options)); default: throw InvalidEnumArgument.CreateException(nameof(batching), batching); } }
public bool Contains(T value) { Contracts.Requires.That(value != null); switch (this.Bounds) { case RangeClusivity.Exclusive: return(value.IsGreaterThan(this.Min) && value.IsLessThan(this.Max)); case RangeClusivity.InclusiveMin: return(value.IsGreaterThanOrEqual(this.Min) && value.IsLessThan(this.Max)); case RangeClusivity.InclusiveMax: return(value.IsGreaterThan(this.Min) && value.IsLessThanOrEqual(this.Max)); case RangeClusivity.Inclusive: return(value.IsGreaterThanOrEqual(this.Min) && value.IsLessThanOrEqual(this.Max)); default: throw InvalidEnumArgument.CreateException(nameof(this.Bounds), this.Bounds); } }
/// <summary> /// Calculates the distance as a long between two long values. /// </summary> /// <param name="a">The first value.</param> /// <param name="b">The second value.</param> /// <param name="rangeOptions">The range options.</param> /// <returns>The distance as a long between the two long values.</returns> private static long CalculateLongDistance(long a, long b, RangeClusivity rangeOptions) { long result = Math.Abs(a - b); switch (rangeOptions) { case RangeClusivity.Exclusive: return((result - 1).ClampLower(0)); case RangeClusivity.InclusiveMin: return(result); case RangeClusivity.InclusiveMax: return(result); case RangeClusivity.Inclusive: return(result + 1); default: throw InvalidEnumArgument.CreateException(nameof(rangeOptions), rangeOptions); } }
/// <summary> /// Gets the maximum value for the primitive type. /// </summary> /// <param name="primitiveType">The primitive type.</param> /// <returns>The maximum value of the primitive type.</returns> /// <remarks> /// The return type of decimal is used because it is the only type larger enough to encompass the values of all the primitive /// types accurately, with the exception of float and double. The range of values represented by a float or double can not be /// accurately represented as a decimal, nor can a float or double accurately represent the range of values of the other /// integral types. Therefor, this method is incompatible with floats and doubles. /// </remarks> public static decimal MaxValue(this PrimitiveType primitiveType) { Contracts.Requires.That(primitiveType.IsIntegral() || primitiveType == PrimitiveType.Decimal); switch (primitiveType) { case PrimitiveType.Byte: return(byte.MaxValue); case PrimitiveType.SByte: return(sbyte.MaxValue); case PrimitiveType.Short: return(short.MaxValue); case PrimitiveType.UShort: return(ushort.MaxValue); case PrimitiveType.Int: return(int.MaxValue); case PrimitiveType.UInt: return(uint.MaxValue); case PrimitiveType.Long: return(long.MaxValue); case PrimitiveType.ULong: return(ulong.MaxValue); case PrimitiveType.Decimal: return(decimal.MaxValue); default: throw InvalidEnumArgument.CreateException(nameof(primitiveType), primitiveType); } }
public static IEnumerable <int> EnumerateTriangles <TVertex>( this IDivisibleMesh <TVertex> mesh, VertexWindingOrder winding) where TVertex : struct { Contracts.Requires.That(mesh != null); Contracts.Requires.That(winding.IsValidEnumValue()); var offsets = mesh.Offsets.GetEnumerator(); int globalOffset = 0; switch (winding) { case VertexWindingOrder.Clockwise: foreach (var group in mesh.Groups) { for (int count = 0; count < group.Offsets; count++) { var success = offsets.MoveNext(); Contracts.Assert.That(success); yield return(globalOffset + offsets.Current); } globalOffset += group.Vertices; } yield break; case VertexWindingOrder.Counterclockwise: foreach (var group in mesh.Groups) { // IDivisibleMesh<TVertex> is always stored in clockwise winding order // so the last 2 offsets of each triangle need to be swapped to become counterclockwise for (int count = 0; count < group.Triangles; count++) { // return the first offset as normal var success = offsets.MoveNext(); Contracts.Assert.That(success); yield return(globalOffset + offsets.Current); // temporarily store the second offset success = offsets.MoveNext(); Contracts.Assert.That(success); var tempOffset = offsets.Current; // return the third offset as though it were the second offset success = offsets.MoveNext(); Contracts.Assert.That(success); yield return(globalOffset + offsets.Current); // return the second offset (stored) as though it were the third offset yield return(globalOffset + tempOffset); } globalOffset += group.Vertices; } yield break; default: throw InvalidEnumArgument.CreateException(nameof(winding), winding); } }
public void GenerateValues( IVoxelProjection <TVoxel, TSurfaceData> projection, out TValue topLeftValue, out TValue topRightValue, out TValue bottomLeftValue, out TValue bottomRightValue) { switch (projection.AxisDirection) { case AxisDirection3D.PositiveX: this.positiveXAxisGenerator.GenerateValues( projection, out topLeftValue, out topRightValue, out bottomLeftValue, out bottomRightValue); break; case AxisDirection3D.NegativeX: this.negativeXAxisGenerator.GenerateValues( projection, out topLeftValue, out topRightValue, out bottomLeftValue, out bottomRightValue); break; case AxisDirection3D.PositiveY: this.positiveYAxisGenerator.GenerateValues( projection, out topLeftValue, out topRightValue, out bottomLeftValue, out bottomRightValue); break; case AxisDirection3D.NegativeY: this.negativeYAxisGenerator.GenerateValues( projection, out topLeftValue, out topRightValue, out bottomLeftValue, out bottomRightValue); break; case AxisDirection3D.PositiveZ: this.positiveZAxisGenerator.GenerateValues( projection, out topLeftValue, out topRightValue, out bottomLeftValue, out bottomRightValue); break; case AxisDirection3D.NegativeZ: this.negativeZAxisGenerator.GenerateValues( projection, out topLeftValue, out topRightValue, out bottomLeftValue, out bottomRightValue); break; default: throw InvalidEnumArgument.CreateException(nameof(projection.AxisDirection), projection.AxisDirection); } }