/// <summary>
/// Throws an <see cref="ArgumentException"/> if the given property's value is the empty string.
/// </summary>
/// <param name="property">The parameter to test.</param>
/// <param name="propertyId">An identifier of the property to check.</param>
internal static void VerifyThrowPropertyEmptyString(string property, string propertyId)
{
ErrorUtilities.VerifyThrowArgumentNull(property, "property");
ErrorUtilities.VerifyThrowArgumentLength(propertyId, "propertyId");
if (property.Length == 0)
{
ErrorUtilities.ThrowArgument(Strings.PropertyCannotBeSetToTheEmptyString, propertyId);
}
}
/// <summary>
/// Throws an <see cref="ArgumentException"/> if the given list property has zero elements.
/// </summary>
/// <param name="listProperty"> The list parameter to test. </param>
/// <param name="propertyId"> An identifier of the property to check. </param>
internal static void VerifyThrowListPropertyEmpty(IList listProperty, string propertyId)
{
ErrorUtilities.VerifyThrowArgumentNull(listProperty, "listProperty");
ErrorUtilities.VerifyThrowArgumentLength(propertyId, "propertyId");
if (listProperty.Count == 0)
{
ErrorUtilities.ThrowArgument(Strings.ListPropertyShouldHaveAtLeastOneElement, propertyId);
}
}
/// <summary>
/// Verifies that a name is valid for the name of an item, property, or piece of metadata.
/// If it isn't, throws an ArgumentException indicating the invalid character.
/// </summary>
/// <remarks>
/// Note that our restrictions are more stringent than the XML Standard's restrictions.
/// </remarks>
/// <throws>ArgumentException</throws>
/// <param name="name">name to validate</param>
internal static void VerifyThrowArgumentValidElementName(string name)
{
ErrorUtilities.VerifyThrowArgumentLength(name, "name");
int firstInvalidCharLocation = LocateFirstInvalidElementNameCharacter(name);
if (-1 != firstInvalidCharLocation)
{
ErrorUtilities.ThrowArgument("OM_NameInvalid", name, name[firstInvalidCharLocation]);
}
}
/// <summary>
/// Validates the properties of this object. This method should be called
/// after initialization is complete.
/// </summary>
internal void Validate(this IntProperty type)
{
(type as BaseProperty).Validate();
if (null != type.MaxValue && null != type.MinValue)
{
if (type.MinValue > type.MaxValue)
{
string minValuePropertyId = GetPropertyId("MinValue", type.Name, type);
ErrorUtilities.ThrowArgument(Strings.MinValueShouldNotBeGreaterThanMaxValue, minValuePropertyId);
}
}
}
/// <summary>
/// Validates the properties of this object. This method should be called
/// after initialization is complete.
/// </summary>
private void Validate(this EnumProperty type)
{
(type as BaseProperty).Validate();
// Validate that the "Default" field is not set on this property.
string defaultPropertyId = GetPropertyId("Default", type.Name, type);
if (null != Default)
{
ErrorUtilities.ThrowArgument(Strings.CannotSetDefaultPropertyOnEnumProperty, typeof(EnumProperty).Name, typeof(EnumValue).Name);
}
// Make sure that at least one value was defined in AdmissibleValues.
string admissibleValuesId = GetPropertyId("AdmissibleValues", type.Name, type);
VerifyThrowListPropertyEmpty(type.AdmissibleValues, admissibleValuesId);
// Validate that only one of the EnumValues under AdmissibleValues is marked IsDefault.
string admissibleValuesPropertyId = GetPropertyId("AdmissibleValues", type.Name, type);
bool seen = false;
foreach (EnumValue enumValue in type.AdmissibleValues)
{
if (enumValue.IsDefault)
{
if (!seen)
{
seen = true;
}
else
{
ErrorUtilities.ThrowArgument(Strings.OnlyOneEnumValueCanBeSetAsDefault, typeof(EnumValue).Name, admissibleValuesPropertyId);
}
}
}
}
/// <summary>
/// Validates the properties of this object. This method should be called
/// after initialization is complete.
/// </summary>
internal void Validate(this Rule type)
{
// Validate "Name" property.
string namePropertyId = GetPropertyId("Name", type);
VerifyThrowPropertyNotSetOrEmptyString(type.Name, namePropertyId);
// Make sure that at least one Property was defined in this Rule.
string propertiesId = XamlErrorUtilities.GetPropertyId("Properties", Name, this);
VerifyThrowListPropertyEmpty(type.Properties, propertiesId);
// Validate the child objects
foreach (BaseProperty property in type.Properties)
{
property.Validate();
}
foreach (Category category in type.Categories)
{
category.Validate();
}
// If the DataSource property is not defined on this Rule, check that a DataSource is
// specified locally on every property.
if (null == type.DataSource)
{
foreach (BaseProperty property in type.Properties)
{
string dataSourcePropertyId = GetPropertyId("DataSource", property.Name, property);
VerifyThrowPropertyNotSet(property.DataSource, dataSourcePropertyId, Strings.DataSourceMustBeDefinedOnPropertyOrOnRule);
}
}
else
{
type.DataSource.Validate();
}
// Create a HashSet for O(1) lookup.
HashSet <string> propertyNames = new HashSet <string>();
foreach (BaseProperty property in type.Properties)
{
if (!propertyNames.Contains(property.Name))
{
propertyNames.Add(property.Name);
}
}
// Validate that every argument refers to a valid property.
foreach (BaseProperty property in type.Properties)
{
if (property.Arguments == null || property.Arguments.Count == 0)
{
continue;
}
foreach (Argument argument in property.Arguments)
{
if (!propertyNames.Contains(argument.Property))
{
ErrorUtilities.ThrowArgument(Strings.PropertyReferredToByArgumentDoesNotExist, argument.Property);
}
}
}
}