private void ValidateGuidDefaultValue(ScalarType scalar) { if (!scalar.TryParse(_default, out _defaultObject)) { _element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultGuid(_default)); } }
private void ValidateIntegralDefaultValue(ScalarType scalar, long minValue, long maxValue) { if (!scalar.TryParse(_default, out _defaultObject)) { _element.AddError( ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultIntegral(_default, minValue, maxValue)); } }
private void ValidateGuidDefaultValue(ScalarType scalar) { if (scalar.TryParse(this._default, out this._defaultObject)) { return; } this._element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, (object)Strings.InvalidDefaultGuid((object)this._default)); }
private void ValidateDateTimeOffsetDefaultValue(ScalarType scalar) { if (scalar.TryParse(this._default, out this._defaultObject)) { return; } this._element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, (object)Strings.InvalidDefaultDateTimeOffset((object)this._default, (object)"yyyy-MM-dd HH\\:mm\\:ss.fffffffz".Replace("\\", ""))); }
private void ValidateIntegralDefaultValue(ScalarType scalar, long minValue, long maxValue) { if (scalar.TryParse(this._default, out this._defaultObject)) { return; } this._element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, (object)Strings.InvalidDefaultIntegral((object)this._default, (object)minValue, (object)maxValue)); }
private void ValidateDecimalDefaultValue(ScalarType scalar) { if (scalar.TryParse(_default, out _defaultObject)) { return; } _element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultDecimal(_default, 38, 38)); }
private void ValidateFloatingPointDefaultValue(ScalarType scalar, double minValue, double maxValue) { if (!scalar.TryParse(_default, out _defaultObject)) { _element.AddError( ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultFloatingPoint(_default, minValue, maxValue)); } }
private void ValidateDateTimeOffsetDefaultValue(ScalarType scalar) { if (!scalar.TryParse(_default, out _defaultObject)) { _element.AddError( ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultDateTimeOffset( _default, ScalarType.DateTimeOffsetFormat.Replace(@"\", ""))); } }
private void ValidateFloatingPointDefaultValue( ScalarType scalar, double minValue, double maxValue) { if (scalar.TryParse(this._default, out this._defaultObject)) { return; } this._element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, (object)Strings.InvalidDefaultFloatingPoint((object)this._default, (object)minValue, (object)maxValue)); }
internal void ValidateAndSetTypeUsage(ScalarType scalar, bool complainOnMissingFacet) { Trace.Assert(this._element != null); Trace.Assert(scalar != null); if (Helper.IsSpatialType(scalar.Type) && !this._facetValues.ContainsKey("IsStrict") && !this._element.Schema.UseStrongSpatialTypes) { this._facetValues.Add("IsStrict", (object)false); } Dictionary <string, Facet> calculatedFacets; if (this.TryGetFacets((EdmType)scalar.Type, complainOnMissingFacet, out calculatedFacets)) { switch (scalar.TypeKind) { case PrimitiveTypeKind.Binary: this.ValidateAndSetBinaryFacets((EdmType)scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.DateTime: case PrimitiveTypeKind.Time: case PrimitiveTypeKind.DateTimeOffset: this.ValidatePrecisionFacetsForDateTimeFamily((EdmType)scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.Decimal: this.ValidateAndSetDecimalFacets((EdmType)scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.String: this.ValidateAndSetStringFacets((EdmType)scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: this.ValidateSpatialFacets((EdmType)scalar.Type, calculatedFacets); break; } } this._typeUsage = TypeUsage.Create((EdmType)scalar.Type, (IEnumerable <Facet>)calculatedFacets.Values); }
private void ValidateBinaryDefaultValue(ScalarType scalar) { if (scalar.TryParse(_default, out _defaultObject)) { return; } var errorMessage = Strings.InvalidDefaultBinaryWithNoMaxLength(_default); _element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, errorMessage); }
public bool TryParse(string text, out object value) { switch (this._primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Binary: return(ScalarType.TryParseBinary(text, out value)); case PrimitiveTypeKind.Boolean: return(ScalarType.TryParseBoolean(text, out value)); case PrimitiveTypeKind.Byte: return(ScalarType.TryParseByte(text, out value)); case PrimitiveTypeKind.DateTime: return(ScalarType.TryParseDateTime(text, out value)); case PrimitiveTypeKind.Decimal: return(ScalarType.TryParseDecimal(text, out value)); case PrimitiveTypeKind.Double: return(ScalarType.TryParseDouble(text, out value)); case PrimitiveTypeKind.Guid: return(ScalarType.TryParseGuid(text, out value)); case PrimitiveTypeKind.Single: return(ScalarType.TryParseSingle(text, out value)); case PrimitiveTypeKind.SByte: return(ScalarType.TryParseSByte(text, out value)); case PrimitiveTypeKind.Int16: return(ScalarType.TryParseInt16(text, out value)); case PrimitiveTypeKind.Int32: return(ScalarType.TryParseInt32(text, out value)); case PrimitiveTypeKind.Int64: return(ScalarType.TryParseInt64(text, out value)); case PrimitiveTypeKind.String: return(ScalarType.TryParseString(text, out value)); case PrimitiveTypeKind.Time: return(ScalarType.TryParseTime(text, out value)); case PrimitiveTypeKind.DateTimeOffset: return(ScalarType.TryParseDateTimeOffset(text, out value)); default: throw new NotSupportedException(this._primitiveType.FullName); } }
private static bool TryParseBinary(string text, out object value) { if (!ScalarType._binaryValueValidator.IsMatch(text)) { value = (object)null; return(false); } string text1 = text.Substring(2); value = (object)ScalarType.ConvertToByteArray(text1); return(true); }
internal void ValidateDefaultValue(SchemaType type) { if (this._default == null) { return; } ScalarType scalar = type as ScalarType; if (scalar != null) { this.ValidateScalarMemberDefaultValue(scalar); } else { this._element.AddError(ErrorCode.DefaultNotAllowed, EdmSchemaErrorSeverity.Error, (object)Strings.DefaultNotAllowed); } }
internal override void ResolveTopLevelNames() { base.ResolveTopLevelNames(); if (this._type != null) { return; } this._type = this.ResolveType(this.UnresolvedType); this._typeUsageBuilder.ValidateDefaultValue(this._type); ScalarType type = this._type as ScalarType; if (type == null) { return; } this._typeUsageBuilder.ValidateAndSetTypeUsage(type, true); }
internal override void Validate() { base.Validate(); ScalarType enumUnderlyingType = this.UnderlyingType as ScalarType; if (enumUnderlyingType == null || !Helper.IsSupportedEnumUnderlyingType(enumUnderlyingType.TypeKind)) { this.AddError(ErrorCode.InvalidEnumUnderlyingType, EdmSchemaErrorSeverity.Error, (object)Strings.InvalidEnumUnderlyingType); } else { foreach (SchemaEnumMember schemaEnumMember in this._enumMembers.Where <SchemaEnumMember>((Func <SchemaEnumMember, bool>)(m => !Helper.IsEnumMemberValueInRange(enumUnderlyingType.TypeKind, m.Value.Value)))) { schemaEnumMember.AddError(ErrorCode.EnumMemberValueOutOfItsUnderylingTypeRange, EdmSchemaErrorSeverity.Error, (object)Strings.EnumMemberValueOutOfItsUnderylingTypeRange((object)schemaEnumMember.Value, (object)schemaEnumMember.Name, (object)this.UnderlyingType.Name)); } } if (!this._enumMembers.GroupBy <SchemaEnumMember, string>((Func <SchemaEnumMember, string>)(o => o.Name)).Where <IGrouping <string, SchemaEnumMember> >((Func <IGrouping <string, SchemaEnumMember>, bool>)(g => g.Count <SchemaEnumMember>() > 1)).Any <IGrouping <string, SchemaEnumMember> >()) { return; } this.AddError(ErrorCode.DuplicateEnumMember, EdmSchemaErrorSeverity.Error, (object)Strings.DuplicateEnumMember); }
private void ValidateIntegralDefaultValue(ScalarType scalar, long minValue, long maxValue) { if (!scalar.TryParse(_default, out _defaultObject)) { _element.AddError( ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultIntegral(_default, minValue, maxValue)); } }
/// <summary> /// effects: adds errors to _element if there are any; creates a TypeUsage instance using the /// facet values aggregated by this builder and the given scalar type /// </summary> /// <param name="scalar"> Scalar type for the type usage </param> internal void ValidateAndSetTypeUsage(ScalarType scalar, bool complainOnMissingFacet) { Trace.Assert(_element != null); Trace.Assert(scalar != null); Dictionary<string, Facet> calculatedFacets; // Forward compat FUTURE SYSTEM.SPATIAL // for now we treat all Geographic types the same, and likewise for geometry. // to allow us to later introduce the full heirarchy without breaking back compat // we require spatial types to have the IsStrict facet with a false value. // Set this facet to false if the schema has the UseStrongSpatialTypes attribute with the a false. if (Helper.IsSpatialType(scalar.Type) && !_facetValues.ContainsKey(DbProviderManifest.IsStrictFacetName) && !_element.Schema.UseStrongSpatialTypes) { _facetValues.Add(DbProviderManifest.IsStrictFacetName, false /* only possible value */); } var noErrors = TryGetFacets(scalar.Type, complainOnMissingFacet, out calculatedFacets); if (noErrors) { // Only validate the values if there are no errros encountered in the above functions. // If there are errors encountered (like for e.g. precision switch (scalar.TypeKind) { case PrimitiveTypeKind.Binary: ValidateAndSetBinaryFacets(scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.String: ValidateAndSetStringFacets(scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.Decimal: ValidateAndSetDecimalFacets(scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.DateTime: case PrimitiveTypeKind.Time: case PrimitiveTypeKind.DateTimeOffset: ValidatePrecisionFacetsForDateTimeFamily(scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.Int16: case PrimitiveTypeKind.Int32: case PrimitiveTypeKind.Int64: case PrimitiveTypeKind.Boolean: case PrimitiveTypeKind.Byte: case PrimitiveTypeKind.SByte: case PrimitiveTypeKind.Double: case PrimitiveTypeKind.Guid: case PrimitiveTypeKind.Single: break; case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: ValidateSpatialFacets(scalar.Type, calculatedFacets); break; default: Debug.Fail("Did you miss a value"); break; } } _typeUsage = TypeUsage.Create(scalar.Type, calculatedFacets.Values); }
private void ValidateScalarMemberDefaultValue(ScalarType scalar) { if (scalar == null) { return; } switch (scalar.TypeKind) { case PrimitiveTypeKind.Binary: this.ValidateBinaryDefaultValue(scalar); break; case PrimitiveTypeKind.Boolean: this.ValidateBooleanDefaultValue(scalar); break; case PrimitiveTypeKind.Byte: this.ValidateIntegralDefaultValue(scalar, 0L, (long)byte.MaxValue); break; case PrimitiveTypeKind.DateTime: this.ValidateDateTimeDefaultValue(scalar); break; case PrimitiveTypeKind.Decimal: this.ValidateDecimalDefaultValue(scalar); break; case PrimitiveTypeKind.Double: this.ValidateFloatingPointDefaultValue(scalar, double.MinValue, double.MaxValue); break; case PrimitiveTypeKind.Guid: this.ValidateGuidDefaultValue(scalar); break; case PrimitiveTypeKind.Single: this.ValidateFloatingPointDefaultValue(scalar, -3.40282346638529E+38, 3.40282346638529E+38); break; case PrimitiveTypeKind.Int16: this.ValidateIntegralDefaultValue(scalar, (long)short.MinValue, (long)short.MaxValue); break; case PrimitiveTypeKind.Int32: this.ValidateIntegralDefaultValue(scalar, (long)int.MinValue, (long)int.MaxValue); break; case PrimitiveTypeKind.Int64: this.ValidateIntegralDefaultValue(scalar, long.MinValue, long.MaxValue); break; case PrimitiveTypeKind.String: this._defaultObject = (object)this._default; break; case PrimitiveTypeKind.Time: this.ValidateTimeDefaultValue(scalar); break; case PrimitiveTypeKind.DateTimeOffset: this.ValidateDateTimeOffsetDefaultValue(scalar); break; default: this._element.AddError(ErrorCode.DefaultNotAllowed, EdmSchemaErrorSeverity.Error, (object)Strings.DefaultNotAllowed); break; } }
private void ValidateBinaryDefaultValue(ScalarType scalar) { if (scalar.TryParse(_default, out _defaultObject)) { return; } var errorMessage = Strings.InvalidDefaultBinaryWithNoMaxLength(_default); _element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, errorMessage); }
private void ValidateScalarMemberDefaultValue(ScalarType scalar) { Debug.Assert(_default != null); if (scalar != null) { switch (scalar.TypeKind) { case PrimitiveTypeKind.Binary: // required format 0xhexdegits, no more than 2*maxSize digits ValidateBinaryDefaultValue(scalar); return; case PrimitiveTypeKind.Boolean: // required true or false (case sensitive?) ValidateBooleanDefaultValue(scalar); return; case PrimitiveTypeKind.Byte: // integer between byte.MinValue and byteMaxValue; ValidateIntegralDefaultValue(scalar, byte.MinValue, byte.MaxValue); return; case PrimitiveTypeKind.DateTime: // valid datetime parsable using the format in _dateTimeFormat in the SqlDateTime range ValidateDateTimeDefaultValue(scalar); return; case PrimitiveTypeKind.Time: // valid time parsable using the format in _timeFormat in the SqlTime range ValidateTimeDefaultValue(scalar); return; case PrimitiveTypeKind.DateTimeOffset: // valid time parsable using the format in _datetimeoffsetFormat in the SqlDateTimeOffset range ValidateDateTimeOffsetDefaultValue(scalar); return; case PrimitiveTypeKind.Decimal: // valid decimal value (optionally with M) with scale and precision in range ValidateDecimalDefaultValue(scalar); return; case PrimitiveTypeKind.Double: // valid double constant ValidateFloatingPointDefaultValue(scalar, double.MinValue, double.MaxValue); return; case PrimitiveTypeKind.Guid: // valid string parsable by Guid.ctor ValidateGuidDefaultValue(scalar); return; case PrimitiveTypeKind.Int16: // integer between short.MinValue and short.MaxValue ValidateIntegralDefaultValue(scalar, short.MinValue, short.MaxValue); return; case PrimitiveTypeKind.Int32: // integer between int.MinValue and int.MaxValue ValidateIntegralDefaultValue(scalar, int.MinValue, int.MaxValue); return; case PrimitiveTypeKind.Int64: // integer between long.MinValue and long.MaxValue ValidateIntegralDefaultValue(scalar, long.MinValue, long.MaxValue); return; case PrimitiveTypeKind.Single: // valid single value ValidateFloatingPointDefaultValue(scalar, float.MinValue, float.MaxValue); return; case PrimitiveTypeKind.String: // the default is already a string, no parsing check necessary _defaultObject = _default; return; default: _element.AddError(ErrorCode.DefaultNotAllowed, EdmSchemaErrorSeverity.Error, Strings.DefaultNotAllowed); return; } } }
/// <summary> /// Get a primitive type when converting a CSDL schema /// </summary> /// <param name="scalarType"> The schema type representing the primitive type </param> /// <param name="providerManifest"> The provider manifest for retrieving the store types </param> private static PrimitiveType GetPrimitiveType( ScalarType scalarType, DbProviderManifest providerManifest) { PrimitiveType returnValue = null; var scalarTypeName = scalarType.Name; foreach (var primitiveType in providerManifest.GetStoreTypes()) { if (primitiveType.Name == scalarTypeName) { returnValue = primitiveType; break; } } Debug.Assert(scalarType != null, "Som scalar type should always resolve to a primitive type"); return returnValue; }
internal void ValidateAndSetTypeUsage(ScalarType scalar) { _typeUsageBuilder.ValidateAndSetTypeUsage(scalar, false); }
private void ValidateScalarMemberDefaultValue(ScalarType scalar) { Debug.Assert(_default != null); if (scalar != null) { switch (scalar.TypeKind) { case PrimitiveTypeKind.Binary: // required format 0xhexdegits, no more than 2*maxSize digits ValidateBinaryDefaultValue(scalar); return; case PrimitiveTypeKind.Boolean: // required true or false (case sensitive?) ValidateBooleanDefaultValue(scalar); return; case PrimitiveTypeKind.Byte: // integer between byte.MinValue and byteMaxValue; ValidateIntegralDefaultValue(scalar, byte.MinValue, byte.MaxValue); return; case PrimitiveTypeKind.DateTime: // valid datetime parsable using the format in _dateTimeFormat in the SqlDateTime range ValidateDateTimeDefaultValue(scalar); return; case PrimitiveTypeKind.Time: // valid time parsable using the format in _timeFormat in the SqlTime range ValidateTimeDefaultValue(scalar); return; case PrimitiveTypeKind.DateTimeOffset: // valid time parsable using the format in _datetimeoffsetFormat in the SqlDateTimeOffset range ValidateDateTimeOffsetDefaultValue(scalar); return; case PrimitiveTypeKind.Decimal: // valid decimal value (optionally with M) with scale and precision in range ValidateDecimalDefaultValue(scalar); return; case PrimitiveTypeKind.Double: // valid double constant ValidateFloatingPointDefaultValue(scalar, double.MinValue, double.MaxValue); return; case PrimitiveTypeKind.Guid: // valid string parsable by Guid.ctor ValidateGuidDefaultValue(scalar); return; case PrimitiveTypeKind.Int16: // integer between short.MinValue and short.MaxValue ValidateIntegralDefaultValue(scalar, short.MinValue, short.MaxValue); return; case PrimitiveTypeKind.Int32: // integer between int.MinValue and int.MaxValue ValidateIntegralDefaultValue(scalar, int.MinValue, int.MaxValue); return; case PrimitiveTypeKind.Int64: // integer between long.MinValue and long.MaxValue ValidateIntegralDefaultValue(scalar, long.MinValue, long.MaxValue); return; case PrimitiveTypeKind.Single: // valid single value ValidateFloatingPointDefaultValue(scalar, float.MinValue, float.MaxValue); return; case PrimitiveTypeKind.String: // the default is already a string, no parsing check necessary _defaultObject = _default; return; default: _element.AddError(ErrorCode.DefaultNotAllowed, EdmSchemaErrorSeverity.Error, Strings.DefaultNotAllowed); return; } } }
// <summary> // effects: adds errors to _element if there are any; creates a TypeUsage instance using the // facet values aggregated by this builder and the given scalar type // </summary> // <param name="scalar"> Scalar type for the type usage </param> internal void ValidateAndSetTypeUsage(ScalarType scalar, bool complainOnMissingFacet) { Trace.Assert(_element != null); Trace.Assert(scalar != null); Dictionary <string, Facet> calculatedFacets; // Forward compat FUTURE SYSTEM.SPATIAL // for now we treat all Geographic types the same, and likewise for geometry. // to allow us to later introduce the full heirarchy without breaking back compat // we require spatial types to have the IsStrict facet with a false value. // Set this facet to false if the schema has the UseStrongSpatialTypes attribute with the a false. if (Helper.IsSpatialType(scalar.Type) && !_facetValues.ContainsKey(DbProviderManifest.IsStrictFacetName) && !_element.Schema.UseStrongSpatialTypes) { _facetValues.Add(DbProviderManifest.IsStrictFacetName, false /* only possible value */); } var noErrors = TryGetFacets(scalar.Type, complainOnMissingFacet, out calculatedFacets); if (noErrors) { // Only validate the values if there are no errros encountered in the above functions. // If there are errors encountered (like for e.g. precision switch (scalar.TypeKind) { case PrimitiveTypeKind.Binary: ValidateAndSetBinaryFacets(scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.String: ValidateAndSetStringFacets(scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.Decimal: ValidateAndSetDecimalFacets(scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.DateTime: case PrimitiveTypeKind.Time: case PrimitiveTypeKind.DateTimeOffset: ValidatePrecisionFacetsForDateTimeFamily(scalar.Type, calculatedFacets); break; case PrimitiveTypeKind.Int16: case PrimitiveTypeKind.Int32: case PrimitiveTypeKind.Int64: case PrimitiveTypeKind.Boolean: case PrimitiveTypeKind.Byte: case PrimitiveTypeKind.SByte: case PrimitiveTypeKind.Double: case PrimitiveTypeKind.Guid: case PrimitiveTypeKind.HierarchyId: case PrimitiveTypeKind.Single: case PrimitiveTypeKind.DbId: break; case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: ValidateSpatialFacets(scalar.Type, calculatedFacets); break; default: Debug.Fail("Did you miss a value"); break; } } _typeUsage = TypeUsage.Create(scalar.Type, calculatedFacets.Values); }
private void ValidateGuidDefaultValue(ScalarType scalar) { if (!scalar.TryParse(_default, out _defaultObject)) { _element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultGuid(_default)); } }
private void ValidateFloatingPointDefaultValue(ScalarType scalar, double minValue, double maxValue) { if (!scalar.TryParse(_default, out _defaultObject)) { _element.AddError( ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultFloatingPoint(_default, minValue, maxValue)); } }
private void ValidateDecimalDefaultValue(ScalarType scalar) { if (scalar.TryParse(_default, out _defaultObject)) { return; } _element.AddError(ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultDecimal(_default, 38, 38)); }
internal void ValidateAndSetTypeUsage(ScalarType scalar) { _typeUsageBuilder.ValidateAndSetTypeUsage(scalar, false); }
private void ValidateDateTimeOffsetDefaultValue(ScalarType scalar) { if (!scalar.TryParse(_default, out _defaultObject)) { _element.AddError( ErrorCode.InvalidDefault, EdmSchemaErrorSeverity.Error, Strings.InvalidDefaultDateTimeOffset( _default, ScalarType.DateTimeOffsetFormat.Replace(@"\", ""))); } }