private object ParseBoolValue() { object val = null; //If ValueType is bool, we must be serialize mode as in DeserializeMode we would have shortcut out of ParseValue //immediately due to PropertyType and ValueType both being bool if (ValueType == typeof(bool)) { Type = TypeCategory.Boolean; val = Convert.ToInt32((bool)OriginalValue); } else { bool boolVal; //OriginalValue is implicitly not null because if it were ProcessNonNullable would have escaped //to ValueConversionWithNullCheck if (TryParseBool(OriginalValue.ToString(), out boolVal)) { Type = TypeCategory.Boolean; if (Mode == SerializationMode.Deserialize) { val = boolVal; } else { val = Convert.ToInt32(boolVal); } } } return(val); }
public override string ToString() { return(string.Format(CultureInfo.InvariantCulture, "error: {0}, value: {1}, process: {2}", Message, OriginalValue != null ? OriginalValue + " (" + OriginalValue.GetType().GetFriendlyTypeName() + ")" : "NULL", Process?.Name ?? "unknown process").Replace("\n", @"\n", StringComparison.InvariantCultureIgnoreCase)); }
private void CalculateCoefficentValues() { DiceCoefficentValue = OriginalValue.DiceCoefficient(ActualValue); var LevenshteinDistanceValue = OriginalValue.LevenshteinDistance(ActualValue); LevenshteinDistanceCoefficentValue = 1.0 / (1.0 * (LevenshteinDistanceValue + 0.2)); LevenshteinDistanceCoefficentValue = LevenshteinDistanceCoefficentValue > .99 ? .99 : LevenshteinDistanceCoefficentValue; LongestCommonSubsequenceCoefficentValue = OriginalValue.LongestCommonSubsequence(ActualValue).Item2; LongestCommonSubsequenceCoefficentValue = LongestCommonSubsequenceCoefficentValue > .99 ? .99 : LongestCommonSubsequenceCoefficentValue; string originalValueDoubleMetaphone = OriginalValue.ToDoubleMetaphone(); string ActualValueDoubleMetaphone = ActualValue.ToDoubleMetaphone(); int matchCount = 0; if (originalValueDoubleMetaphone.Length == 4 && ActualValueDoubleMetaphone.Length == 4) { for (int i = 0; i < originalValueDoubleMetaphone.Length; i++) { if (originalValueDoubleMetaphone[i] == ActualValueDoubleMetaphone[i]) { matchCount++; } } } DoubleMetaphoneCoefficentValue = matchCount == 0 ? 0.0 : matchCount / 4.0; DoubleMetaphoneCoefficentValue = DoubleMetaphoneCoefficentValue == 1.0 ? .90 : DoubleMetaphoneCoefficentValue; AverageCoefficentValue = (DiceCoefficentValue + LongestCommonSubsequenceCoefficentValue + LevenshteinDistanceCoefficentValue + DoubleMetaphoneCoefficentValue) / 4.0; }
private void Print() { Console.WriteLine(Formatter.GetString(OriginalValue.ToString(), ORIGINAL_TYPE, nameof(Kilograms), Kilograms.ToString("#.######"))); Console.WriteLine(Formatter.GetString(OriginalValue.ToString(), ORIGINAL_TYPE, nameof(Ounces), Ounces.ToString("#.######"))); Console.WriteLine(Formatter.GetString(OriginalValue.ToString(), ORIGINAL_TYPE, nameof(Stone), Stone.ToString("#.######"))); Console.WriteLine(); }
private void Print() { Console.WriteLine(Formatter.GetString(OriginalValue.ToString(), ORIGINAL_TYPE, nameof(Feet), Feet.ToString("#.######"))); Console.WriteLine(Formatter.GetString(OriginalValue.ToString(), ORIGINAL_TYPE, nameof(Meters), Meters.ToString("#.######"))); Console.WriteLine(Formatter.GetString(OriginalValue.ToString(), ORIGINAL_TYPE, nameof(Miles), Miles.ToString("#.######"))); Console.WriteLine(Formatter.GetString(OriginalValue.ToString(), ORIGINAL_TYPE, nameof(Kilometers), Kilometers)); Console.WriteLine(); }
public override int GetHashCode() { var hashCode = 33288; hashCode = hashCode * OriginalValue.GetHashCode(); hashCode = hashCode * StartIndex; hashCode = hashCode * EndIndex; return(hashCode); }
private object ParseNumericValue() { object val = null; //If the value is convertable to a double, it is either an int or a double if (!string.IsNullOrEmpty(OriginalValue?.ToString())) { double doubleResult; //If the value is a double. Implicitly not null due to !string.IsNullOrEmpty check above if (double.TryParse(OriginalValue.ToString(), out doubleResult)) { //If we're actually looking for an int, see if this double is actually an integer if (PropertyType == typeof(int)) { if (Convert.ToInt32(doubleResult) == doubleResult) { //If so, that's cool. When we ToString, we'll get an integer value anyway Type = TypeCategory.Number; if (Mode == SerializationMode.Deserialize) { val = (int)doubleResult; } else { val = doubleResult.ToString(CultureInfo.CurrentCulture); } } //Else: someone tried to assign an actual double to our integer. An exception will be thrown below } else { Type = TypeCategory.Number; if (Mode == SerializationMode.Deserialize) { val = doubleResult; } else { val = doubleResult.ToString(CultureInfo.CurrentCulture); } } } //If we still don't have a value, since we already verified our value is not null or empty we must have a value of an invalid type if (val == null) { throw GetInvalidTypeException(); } } return(val); }
public override int GetHashCode() { unchecked { var hashCode = (Value != null ? Value.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (OriginalValue != null ? OriginalValue.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (Language != null ? Language.GetHashCode() : 0); return(hashCode); } }
/// <summary> /// Возвращает значение фильтра в виде целого числа. /// </summary> /// <returns>Число</returns> public int?GetValue() { int?v = null; if (OriginalValue != null) { int value = 0; Int32.TryParse(OriginalValue.ToString(), out value); v = value; } return(v); }
private void InitModeItems() { ModeItems = new Caliburn.Micro.BindableCollection <LookupItem>(); ModeItems.Add(new LookupItem() { Text = "Auto", Value = ModeOptions.Auto }); ModeItems.Add(new LookupItem() { Text = "Manual", Value = ModeOptions.Manual }); SelectedMode = OriginalValue.IsNullOrEmpty() ? ModeItems.Last() : ModeItems.First(); }
public override bool Equals(Object obj) { if ((obj == null) || !this.GetType().Equals(obj.GetType())) { return(false); } else { DateResult dr = (DateResult)obj; return(OriginalValue.Equals(dr.OriginalValue) && StartIndex == dr.StartIndex && EndIndex == dr.EndIndex); } }
public void SanitizePropertiesTrimsLeadingAndTraliningSpacesFromValues() { const string OriginalKey = "test"; const string OriginalValue = " name with spaces "; var original = new Dictionary <string, string> { { OriginalKey, OriginalValue } }; original.SanitizeProperties(); string sanitizedValue = OriginalValue.Trim(); Assert.Equal(new[] { new KeyValuePair <string, string>(OriginalKey, sanitizedValue) }, original); }
private object ParseEnumValue <T>() where T : XmlEnumAttribute { object val = null; //If our value type was an enum, get its XmlEnumAttribute immediately if (PropertyType == ValueType) { //We must be serializing as if we were deserializing we would have fast-pathed out of ParseValue val = ((Enum)OriginalValue).GetEnumAttribute <T>(true).Name; } else { //Otherwise, our value may have been a string. See if any enum members are named after the specified value if (Enum.GetNames(PropertyType).Any(x => x.ToLower() == OriginalValue.ToString().ToLower())) { var enumValue = ((Enum)Enum.Parse(PropertyType, OriginalValue.ToString(), true)); if (Mode == SerializationMode.Deserialize) { val = enumValue; } else { val = enumValue.GetEnumAttribute <T>(true).Name; } } else { //If the enum represents a set of numeric values and our value was an integer, int result; if (PropertyType.GetTypeCache().GetAttribute <NumericEnumAttribute>() != null && int.TryParse(OriginalValue.ToString(), out result)) { var enumVal = Enum.Parse(PropertyType, OriginalValue.ToString()); if (Mode == SerializationMode.Deserialize) { val = enumVal; } else { val = ((Enum)enumVal).GetEnumAttribute <T>(true).Name; } } } } return(val); }
public string ToXML(string rootName) { XmlDocument xmlDocument = new XmlDocument(); var rootElement = xmlDocument.CreateElement(rootName); //var typeElement = xmlDocument.CreateElement("Type"); //typeElement.InnerText = Type.ToString(); //var originalValueElement = xmlDocument.CreateElement("OriginalValue"); //originalValueElement.InnerText = OriginalValue; //var newValueElement = xmlDocument.CreateElement("NewValue"); //newValueElement.InnerText = NewValue; //rootElement.AppendChild(typeElement); //rootElement.AppendChild(originalValueElement); //rootElement.AppendChild(newValueElement); if (Type == ChangeType.None) { rootElement.InnerText = OriginalValue; } else if (Type == ChangeType.Add) { rootElement.InnerText = "<div style='background:#00FF00'>" + NewValue + "<div style='background:#00FF00'>"; } else if (Type == ChangeType.Delete) { rootElement.InnerText = "<s><div style='background:#FF0000'>" + OriginalValue + "</div></s>"; } else { if (OriginalValue.Contains('\r') || NewValue.Contains('\r') || OriginalValue.Contains('\n') || NewValue.Contains('\n')) { rootElement.InnerText = "<div>" + new LineDiff().CreateDiffHtml(OriginalValue, NewValue) + "</div>"; } else { rootElement.InnerText = "<div style='background:#DBDB70'>" + OriginalValue + "<br/> ==><br/>" + NewValue + "</div>"; } } return(rootElement.OuterXml); }
private ConversionState ProcessNullable() { //String, Int and Double can be used as is if (PropertyType == typeof(string)) { Type = TypeCategory.String; NewValue = OriginalValue?.ToString(); return(ValueConversionWithMaybeNullCheck); } else if (PropertyType == typeof(double) || PropertyType == typeof(int)) { NewValue = ParseNumericValue(); return(ValueConversionWithMaybeNullCheck); } return(MoveNext()); }
public override string GetStepParameters() { var parameters = new List <string>(); parameters.Add(GlobalId != null ? GlobalId.ToStepValue() : "$"); parameters.Add(OwnerHistory != null ? OwnerHistory.ToStepValue() : "$"); parameters.Add(Name != null ? Name.ToStepValue() : "$"); parameters.Add(Description != null ? Description.ToStepValue() : "$"); parameters.Add(ObjectType != null ? ObjectType.ToStepValue() : "$"); parameters.Add(Identification != null ? Identification.ToStepValue() : "$"); parameters.Add(OriginalValue != null ? OriginalValue.ToStepValue() : "$"); parameters.Add(CurrentValue != null ? CurrentValue.ToStepValue() : "$"); parameters.Add(TotalReplacementCost != null ? TotalReplacementCost.ToStepValue() : "$"); parameters.Add(Owner != null ? Owner.ToStepValue() : "$"); parameters.Add(User != null ? User.ToStepValue() : "$"); parameters.Add(ResponsiblePerson != null ? ResponsiblePerson.ToStepValue() : "$"); parameters.Add(IncorporationDate != null ? IncorporationDate.ToStepValue() : "$"); parameters.Add(DepreciatedValue != null ? DepreciatedValue.ToStepValue() : "$"); return(string.Join(", ", parameters.ToArray())); }
private ConversionState DeserializeIEnumerable() { if (PropertyType.IsArray) { //If Value was string[] we would have shortcut out due to PropertyType == ValueType in ProcessCorrectType() if (OriginalValue == null) { NewValue = null; return(ConversionState.ValueConversion); } if (OriginalValue.IsIEnumerable()) { NewValue = OriginalValue.ToIEnumerable().Where(v => v != null).Select(v => v.ToString()).ToArray(); return(ConversionState.ValueConversion); } var characters = Cache.GetAttribute <SplittableStringAttribute>(true)?.Characters; if (characters != null) { NewValue = OriginalValue.ToString().Split(characters); return(ConversionState.ValueConversion); } NewValue = new[] { OriginalValue.ToString() }; return(ConversionState.ValueConversion); } return(MoveNext()); }
private void Print() { Console.WriteLine(Formatter.GetString(OriginalValue.ToString(), ORIGINAL_TYPE, nameof(Celsius), Celsius.ToString("#.##"))); Console.WriteLine(Formatter.GetString(OriginalValue.ToString(), ORIGINAL_TYPE, nameof(Kelvin), Kelvin.ToString("#.##"))); Console.WriteLine(); }
private ConversionState SerializeIEnumerable() { var supportedArrayTypes = new[] { typeof(object), typeof(string) }; //We would like for our Value to be some type of IEnumerable so that we may serialize it //as a splittable string if (PropertyType.IsArray) { if (ValueType?.IsArray == true) { var elementType = ValueType.GetElementType(); if (!supportedArrayTypes.Contains(elementType)) { throw GetNotSupportedCollectionException(elementType); } } //The serialized form of null is null. The serialized form of any list is a string if (OriginalValue == null || OriginalValue is string) { NewValue = OriginalValue as string; return(ConversionState.ValueConversion); } if (OriginalValue.IsIEnumerable()) { foreach (var @interface in ValueType.GetInterfaces()) { if (@interface.IsGenericType && @interface.GetGenericTypeDefinition() == typeof(IEnumerable <>)) { var genericTypeArg = @interface.GetGenericArguments()[0]; if (!supportedArrayTypes.Contains(genericTypeArg)) { throw GetNotSupportedCollectionException(genericTypeArg); } break; } } var enumerable = OriginalValue.ToIEnumerable().ToArray(); if (enumerable.Length == 0) { NewValue = null; return(ConversionState.ValueConversion); } var illegalTypes = enumerable.Where(v => !(v is string)).ToList(); if (illegalTypes.Count > 0) { throw GetNotSupportedCollectionException(illegalTypes[0].GetType()); } //The first character is considered canon. All subsequent characters are for alternate characters that //could somehow get thrown into the mix var splittableStringChar = Cache.GetAttribute <SplittableStringAttribute>(true)?.Characters[0].ToString(); if (splittableStringChar == null) { throw new NotSupportedException($"Cannot serialize value for array property {Property} as the property is missing a {nameof(SplittableStringAttribute)}."); } NewValue = string.Join(splittableStringChar, enumerable); return(ConversionState.ValueConversion); } throw GetInvalidTypeException(); } return(MoveNext()); }
public FilePath Replace(string oldValue, string newValue) { return(new FilePath(OriginalValue.Replace(oldValue, newValue))); }
public FilePath SubPath(int start, int end) { var filePath = new FilePath(OriginalValue.Substring(start, end)); return(filePath); }
public FilePath SubPath(int index) { var filePath = new FilePath(OriginalValue.Substring(index)); return(filePath); }
public T GetResultOrThrow() { if (Error == null) { return(ConvertedValue); } if (OriginalValue == null) { throw new InvalidCastException($"Failed to convert null to {TargetType.Type}.", Error); } else { throw new InvalidCastException($"Failed to convert {OriginalValue} from {OriginalValue.GetType()} to {TargetType.Type}.", Error); } }
public bool Fail(string format, params object[] args) { if (args != null && args.Length > 0) { Message = String.Format("{0}.{1}: {3} ('{2}')", Field.Category, Field.DisplayName, OriginalValue.Truncate(30), string.Format(format, args)); } else { Message = String.Format("{0}.{1}: {3} ('{2}')", Field.Category, Field.DisplayName, OriginalValue.Truncate(30), format); } IsValid = false; ConvertedValue = null; return(false); }