/// <summary> /// Converts the value of this instance to an equivalent EnumState value. /// </summary> /// <returns>A valid EnumState, assuming the source value can be correctly converted.</returns> public EnumState ToEnumState(EnumPairCollection enumPairs) { if (_value == null) return new EnumState(enumPairs.EnumIds); else return EnumState.FromWireValue(enumPairs, ToString(CultureInfo.InvariantCulture)); }
/// <summary> /// Converts the value of this instance to an equivalent EnumState value. /// </summary> /// <returns>A valid EnumState, assuming the source value can be correctly converted.</returns> public EnumState ToEnumState(EnumPairCollection enumPairs) { if (_value == null) { return(new EnumState(enumPairs.EnumIds)); } else { return(EnumState.FromWireValue(enumPairs, ToString(null))); } }
/// <summary> /// Converts the value of this instance to an equivalent EnumState value. /// </summary> /// <returns>A valid EnumState, assuming the source value can be correctly converted.</returns> /// <remarks>This method converts the enum value to a string, looks up the EnumID from the supplied /// EnumPairCollection and then returns a new EnumState. This method may be a little slow for /// very large enumerations.</remarks> public EnumState ToEnumState(EnumPairCollection enumPairs) { EnumState state = new EnumState(enumPairs.EnumIds); string enumId; string wireValue = ToString(null); if (enumPairs.TryParseWireValue(wireValue, out enumId)) { state[enumId] = true; } return(state); }
/// <summary> /// Converts the value of this instance to an equivalent string value using the specified culture-specific formatting information. /// </summary> /// <param name="targetParameter">Target parameter for this conversion.</param> /// <returns>A string value equivalent to the value of this instance. May be null.</returns> public override string ToString(IParameter targetParameter) { if (_value != null && HasEnumeratedState) { EnumPairCollection enumPairs = targetParameter.EnumPairs; string value = (bool)_value ? enumPairs.GetWireValueFromEnumId(CheckedEnumRef) : enumPairs.GetWireValueFromEnumId(UncheckedEnumRef); // It is possible for '{NULL}' to be provided as one of the enum wire values, so we have to act accordingly return(value != Atdl.NullValue ? value : null); } else { return(_value != null?_value.ToString().ToLower() : null); } }
/// <summary> /// Provides the state of this EnumState in a format ready to be sent over FIX, e.g., "A B C E". /// </summary> /// <param name="enumPairs">The EnumPairs for this parameter, to provide the mapping from EnumID values.</param> /// <returns>A space-separated string containing zero or more EnumPair WireValues. If no EnumIDs are enabled, /// then null is returned.</returns> public string ToWireValue(EnumPairCollection enumPairs) { _log.Debug(m => m("Converting EnumState to WireValue; current state is {0}", ToString())); if (enumPairs.Count != _enumStates.Count) { throw ThrowHelper.New <InvalidOperationException>(ExceptionContext, ErrorMessages.InconsistentEnumPairsListItemsError); } // Override the values in the states collection if a non-enum value is supplied. This is used to handle // the unique case of the EditableDropDownList_t control. if (NonEnumValue != null) { return(NonEnumValue.Length > 0 ? NonEnumValue : null); } bool hasAtLeastOneValue = false; StringBuilder sb = new StringBuilder(); for (int n = 0; n < _enumStates.Length; n++) { if (_enumStates[n]) { string value = enumPairs.GetWireValueFromEnumId(_enumIds[n]); // Typically {NULL} will only be used in a mutually exclusive fashion, although nothing enforces this if (value != Atdl.NullValue) { // Only prepend a space after the first entry if (hasAtLeastOneValue) { sb.AppendFormat(" {0}", value); } else { sb.Append(value); hasAtLeastOneValue = true; } } } } _log.Debug(m => m("EnumState as WireValue is {0}", sb.ToString())); return(hasAtLeastOneValue ? sb.ToString() : null); }
/// <summary> /// Creates a new EnumState from the supplied set of EnumPairs and input FIX string. /// </summary> /// <param name="enumPairs">EnumPairs for this parameter.</param> /// <param name="multiValueString">String containing one or more FIX wire values (space-separated).</param> /// <returns></returns> public static EnumState FromWireValue(EnumPairCollection enumPairs, string multiValueString) { _log.DebugFormat("Converting WireValue '{0}' to EnumState", multiValueString); string[] inputValues = multiValueString.Split(new char[] { ';', ' ', ',' }); EnumState result = new EnumState(enumPairs.EnumIds); foreach (string inputValue in inputValues) { string enumId; if (!enumPairs.TryParseWireValue(inputValue, out enumId)) { throw ThrowHelper.New <ArgumentException>(ExceptionContext, ErrorMessages.UnrecognisedEnumIdValue, inputValue); } result[enumId] = true; } _log.Debug(m => m("Converting EnumState from WireValue; state is {0}", result.ToString())); return(result); }
/// <summary> /// Validates the supplied value in terms of the parameters constraints (e.g., MinValue, MaxValue, etc.). /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>ValidationResult indicating whether the supplied value is valid.</returns> /// <remarks>DateTime.MaxValue (a date and time at the end of the year 9999) is used to indicate an invalid date or time.</remarks> protected override ValidationResult ValidateValue(DateTime?value, bool isRequired, EnumPairCollection enumPairs) { if (value != null) { if (value == DateTime.MaxValue) { return(new ValidationResult(ValidationResult.ResultType.Invalid, ErrorMessages.InvalidDateOrTimeValueUnknown)); } if (MaxValue != null && (DateTime)value > MaxValue) { var constraintText = string.Format(ErrorMessages.ConstraintMaxValueExceeded, MaxValueString()); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.MaxValueExceeded, value, MaxValue)); } if (MinValue != null && (DateTime)value < MinValue) { var constraintText = string.Format(ErrorMessages.ConstraintMinValueExceeded, MinValueString()); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.MinValueExceeded, value, MinValue)); } } else if (isRequired) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } return(ValidationResult.ValidResult); }
/// <summary> /// Validates the supplied value in terms of the parameters constraints (e.g., MinValue, MaxValue, etc.). /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>ValidationResult indicating whether the supplied value is valid.</returns> protected override ValidationResult ValidateValue(MonthYear?value, bool isRequired, EnumPairCollection enumPairs) { if (MaxValue != null && !(value >= MaxValue)) { return(new ValidationResult(ValidationResult.ResultType.Invalid, ErrorMessages.MaxValueExceeded, value.ToString(), MaxValue)); } if (MinValue != null && !(value <= MinValue)) { return(new ValidationResult(ValidationResult.ResultType.Invalid, ErrorMessages.MinValueExceeded, value.ToString(), MinValue)); } if (isRequired && value == null) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } return(ValidationResult.ValidResult); }
/// <summary> /// Converts the value of this instance to an equivalent EnumState value. /// </summary> /// <returns>A valid EnumState, assuming the source value can be correctly converted.</returns> /// <remarks>This method converts the enum value to a string, looks up the EnumID from the supplied /// EnumPairCollection and then returns a new EnumState. This method may be a little slow for /// very large enumerations.</remarks> public EnumState ToEnumState(EnumPairCollection enumPairs) { throw ThrowHelper.New <InvalidCastException>(this, ErrorMessages.UnsupportedParameterValueConversion, _value, "Enumerated Type"); }
/// <summary> /// Validates the supplied value in terms of 'ISO 10383 correctness', i.e., MICs must be 4 characters in length. /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>ValidationResult indicating whether the supplied value is valid.</returns> protected override ValidationResult ValidateValue(string value, bool isRequired, EnumPairCollection enumPairs) { if (value != null && value.Length != 4) { return(new ValidationResult(ValidationResult.ResultType.Invalid, ErrorMessages.InvalidExchangeCode)); } if (isRequired && value == null) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } return(ValidationResult.ValidResult); }
/// <summary> /// Validates the supplied value in terms of the parameters constraints (e.g., MinValue, MaxValue, etc.). /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>ValidationResult indicating whether the supplied value is valid.</returns> protected override ValidationResult ValidateValue(uint?value, bool isRequired, EnumPairCollection enumPairs) { if (value != null && (uint)value < 1) { return(new ValidationResult(ValidationResult.ResultType.Invalid, ErrorMessages.NonZeroPositiveIntRequired, value)); } if (isRequired && value == null) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } return(ValidationResult.ValidResult); }
/// <summary> /// Validates the supplied value in terms of the parameters constraints. This method does nothing because /// is not possible for an IsoLanguageCode value to be invalid. /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>ValidationResult indicating whether the supplied value is valid.</returns> protected override ValidationResult ValidateValue(IsoLanguageCode?value, bool isRequired, EnumPairCollection enumPairs) { if (isRequired && value == null) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } return(ValidationResult.ValidResult); }
/// <summary> /// Validates the supplied value in terms of the parameters constraints (e.g., MinValue, MaxValue, etc.). /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>Value passed in is returned if it is valid; otherwise an appropriate exception is thrown.</returns> protected abstract ValidationResult ValidateValue(T?value, bool isRequired, EnumPairCollection enumPairs);
/// <summary> /// Validates the supplied value in terms of the parameters constraints (e.g., MinValue, MaxValue, etc.). /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>ValidationResult indicating whether the supplied value is valid.</returns> protected override ValidationResult ValidateValue(decimal?value, bool isRequired, EnumPairCollection enumPairs) { if (value != null) { int adjustmentFactor = (MultiplyBy100 == true) ? 1 : 100; var adjustedValue = 0 <= value && value <= 1 ? value * 100 : value; // used until we display on ui multiplied by 100 var maxValue = MaxValue * 100; // used until we display on ui multiplied by 100 var minValue = MinValue * 100; // used until we display on ui multiplied by 100 if (maxValue != null && adjustedValue > maxValue) { var constraintText = string.Format(ErrorMessages.ConstraintMaxValueExceeded, maxValue); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.MaxValueExceeded, RemoveTrailingZeroes(adjustedValue * adjustmentFactor), RemoveTrailingZeroes(maxValue * adjustmentFactor)) { DisplayValue = adjustedValue.ToString() }); } if (minValue != null && adjustedValue < minValue) { var constraintText = string.Format(ErrorMessages.ConstraintMinValueExceeded, minValue); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.MinValueExceeded, RemoveTrailingZeroes(adjustedValue * adjustmentFactor), RemoveTrailingZeroes(minValue * adjustmentFactor)) { DisplayValue = adjustedValue.ToString() }); } } else if (isRequired) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } return(ValidationResult.ValidResult); }
/// <summary> /// Validates the supplied value in terms of the parameters constraints. This method does nothing because /// is not possible for a char value to be invalid. /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>ValidationResult indicating whether the supplied value is valid.</returns> protected override ValidationResult ValidateValue(char?value, bool isRequired, EnumPairCollection enumPairs) { if (isRequired && value == null) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } if (value != null && enumPairs.HasValues && !enumPairs.TryParseWireValue(value.ToString(), out _)) { var constraintText = string.Format(ErrorMessages.UnrecognisedEnumIdValue, value); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.InvalidControlValueError)); } return(ValidationResult.ValidResult); }
/// <summary> /// Validates the supplied value in terms of the parameters constraints. /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>ValidationResult indicating whether the supplied value is valid.</returns> protected override ValidationResult ValidateValue(string value, bool isRequired, EnumPairCollection enumPairs) { if (!string.IsNullOrEmpty(value)) { if (MaxLength != null && value.Length > MaxLength) { var constraintText = string.Format(ErrorMessages.ConstraintMaxLengthExceeded, MaxLength); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.MaxLengthExceeded, value, MaxLength)); } if (MinLength != null && value.Length < MinLength) { var constraintText = string.Format(ErrorMessages.ConstraintMinLengthExceeded, MinLength); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.MinLengthExceeded, value, MinLength)); } } else if (isRequired) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } if (value != null && enumPairs.HasValues && !enumPairs.TryParseWireValue(value, out _)) { var constraintText = string.Format(ErrorMessages.UnrecognisedEnumIdValue, value); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.InvalidControlValueError)); } return(ValidationResult.ValidResult); }
/// <summary> /// Validates the supplied value in terms of the parameters constraints. /// </summary> /// <param name="value">Value to validate, may be null in which case no validation is applied.</param> /// <param name="isRequired">Set to true to check that this parameter is non-null.</param> /// <param name="enumPairs">We need to check that the value is found inside this collection</param> /// <returns>ValidationResult indicating whether the supplied value is valid.</returns> protected override ValidationResult ValidateValue(char[] value, bool isRequired, EnumPairCollection enumPairs) { if (MaxLength != null && value != null && value.Length > MaxLength) { var constraintText = string.Format(ErrorMessages.ConstraintMaxLengthExceeded, MaxLength); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.MaxLengthExceeded, value, MaxLength)); } if (MinLength != null && value != null && value.Length < MinLength) { var constraintText = string.Format(ErrorMessages.ConstraintMinLengthExceeded, MinLength); return(new ValidationResult(ValidationResult.ResultType.InvalidConstraint, constraintText, ErrorMessages.MinLengthExceeded, value, MinLength)); } if (isRequired && value == null) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } return(ValidationResult.ValidResult); }
protected override ValidationResult ValidateValue(DateTime?value, bool isRequired, EnumPairCollection enumPairs) { //AMS-231 min/max value validation no longer required if (value != null) { if (value == DateTime.MaxValue) { return(new ValidationResult(ValidationResult.ResultType.Invalid, ErrorMessages.InvalidDateOrTimeValueUnknown)); } } else if (isRequired) { return(new ValidationResult(ValidationResult.ResultType.Missing, ErrorMessages.NonOptionalParameterNotSupplied2)); } return(ValidationResult.ValidResult); }