/// <summary> /// Get the bytes of this IBitWindow as though the bits in the window were a single N-bit integer with a layout that matches /// that of the current processor. /// Currently restricted to 1,2,4, and 8 byte sized integers. /// Currently restricted to unsigned or 2's complement format. /// </summary> /// <param name="this"></param> /// <param name="integerSize">The byte width of the resulting integer.</param> /// <param name="signed">Whether or not the resulting integer is signed.</param> /// <returns></returns> public static Byte[] Crystalize(this IBitWindow @this, IntegerFormat format) { if (@this == null) { throw new ArgumentNullException(nameof(@this)); } if (!SupportedIntegerFormats.Contains(format)) { throw new NotSupportedException(); } if (format.BitWidth / 8 < (@this.Length + 7) / 8) { throw new InvalidOperationException(); } Byte[] integerBuffer = new Byte[format.BitWidth / 8]; BitWindow integerView = new BitWindow(integerBuffer, new EndianBitIndexer(format.ByteOrder, format.BitOrder)); @this.WriteTo(integerView, 0, 0, @this.Length); if (format.Signed) { if (@this[@this.Length - 1]) { for (int bitPow = @this.Length; bitPow < integerView.Length; bitPow++) { integerView[bitPow] = true; } } } return(integerBuffer); }
public static AttributeMetadata CreateWholeNumber(IntegerFormat? format = IntegerFormat.None, int? minValue = IntegerAttributeMetadata.MinSupportedValue, int? maxValue = IntegerAttributeMetadata.MaxSupportedValue, string formulaDefinition = null) { return new IntegerAttributeMetadata { Format = format, MaxValue = maxValue, MinValue = minValue, FormulaDefinition = formulaDefinition }; }
public IntegerAttributeMetadata Create(AttributeMetadata baseMetadata, IntegerFormat integetFormat, int?maxvalue, int?minvalue) { var integerAttribute = new IntegerAttributeMetadata { // Set base properties SchemaName = baseMetadata.SchemaName, DisplayName = baseMetadata.DisplayName, RequiredLevel = baseMetadata.RequiredLevel, Description = baseMetadata.Description, // Set extended properties Format = IntegerFormat.None, MaxValue = 100, MinValue = 0 }; return(integerAttribute); }
public Object Eva(String str, CalcMode calcMode, IntegerFormat fmt, IntegerBits numBits, bool updateAnswer) { Int64 result = 0; if (str.Length < 1) return false; try { m_numFmt = fmt; switch (fmt) { case IntegerFormat.DEC: Object obj = m_calcEngine.Evaluate(str, calcMode, numBits, fmt); if (obj != null && updateAnswer) { if (m_calcEngine.Variables.ContainsKey("ans")) UpdateVariable("ans", obj); else AddVariable("ans", obj); } return obj; case IntegerFormat.HEX: return Int64.Parse(str, System.Globalization.NumberStyles.HexNumber); case IntegerFormat.BIN: if (ParseBinStr(str, ref result)) return result; else throw new ArgumentException(); default: return null; } } catch (Exception _ex) { throw _ex; } }
private ExpTool() { m_numFmt = IntegerFormat.DEC; m_calcEngine = new CalcEngine.CalcEngine(); m_varList = new Dictionary<string, object>(); }
/// <summary> /// Creates a view into an existing view. /// </summary> /// <param name="this">The existing view.</param> /// <param name="offset">The bit offset relative to the start of the existing view.</param> /// <param name="format">A format to follow.</param> /// <returns></returns> public static IBitWindow Crack(this IBitWindow @this, Int32 offset, IntegerFormat format) { return(@this.Crack(offset, format.BitWidth, format.GetIndexer())); }
public object Evaluate(string expression, CalcMode calMode, IntegerBits intBits, IntegerFormat intFmt) { Expression.CurCalcMode = calMode; Expression.CurIntBits = intBits; Expression.CurIntFmt = intFmt; var x = _cache != null ? _cache[expression] : Parse(expression); return Token.FormatValue(x.Evaluate(), calMode, intBits, intFmt); }
public EntityAttributeMetadataBuilder IntAttribute(string schemaName, string displayName, string description, AttributeRequiredLevel requiredLevel, IntegerFormat format, int min, int max) { // Define the primary attribute for the entity // Create a integer attribute int languageCode = 1033; var integerAttribute = new IntegerAttributeMetadata { // Set base properties SchemaName = schemaName, DisplayName = new Label(schemaName, languageCode), RequiredLevel = new AttributeRequiredLevelManagedProperty(requiredLevel), Description = new Label(description, languageCode), // Set extended properties Format = format, MaxValue = max, MinValue = min }; this.Attributes.Add(integerAttribute); return(this); }
public IntegerAttribute(int maxValue, int minValue, Metadata.IntegerFormat format) { MaxValue = maxValue; MinValue = minValue; Format = format.ToSimilarEnum <IntegerFormat>(); }
/// <summary> /// Gets a bit indexer for this integer format. /// </summary> /// <param name="fmt">The existing format</param> /// <returns>An indexer for reading an integer in the specified format</returns> public static IBitIndexer GetIndexer(this IntegerFormat fmt) { return(EndianBitIndexer.GetStandard(fmt.BitOrder, fmt.ByteOrder)); }
public static object FormatValue(object val, CalcMode calcMode, IntegerBits intBits, IntegerFormat intFmt) { double v; if (val is string) return val; if (val is double) { v = (double)val; } // handle booleans if (val is bool) { v = 1.0; } // handle nulls if (val == null) { v = 0; } // handle everything else v = (double)Convert.ChangeType(val, typeof(double)); if (calcMode == CalcMode.FLOAT) { return (double)v; } else if (calcMode == CalcMode.INTEGER_SIGNED) { if (intBits == IntegerBits.BITS_64) { return (Int64)v; } else if (intBits == IntegerBits.BITS_32) { return (Int32)v; } else if (intBits == IntegerBits.BITS_16) { return (Int16)v; } else if (intBits == IntegerBits.BITS_8) { return (SByte)v; } else { throw new Exception("Invalid Integer Bits"); } } else if (calcMode == CalcMode.INTEGER_UNSIGNED) { if (intBits == IntegerBits.BITS_64) { return (UInt64)v; } else if (intBits == IntegerBits.BITS_32) { return (UInt32)v; } else if (intBits == IntegerBits.BITS_16) { return (UInt16)v; } else if (intBits == IntegerBits.BITS_8) { return (Byte)v; } else { throw new Exception("Invalid Integer Bits"); } } else { throw new Exception("Invalid Calculate Mode"); } }