public static VariantValue Create(FieldType fieldType,
[CanBeNull] object value)
{
VariantValueType valueType = GetValueType(fieldType);
return(new VariantValue(value, valueType));
}
private static Type GetType(VariantValueType valueType)
{
switch (valueType)
{
case VariantValueType.Null:
return(null);
case VariantValueType.Boolean:
return(typeof(bool));
case VariantValueType.DateTime:
return(typeof(DateTime));
case VariantValueType.Double:
return(typeof(double));
case VariantValueType.Integer:
return(typeof(int));
case VariantValueType.String:
return(typeof(string));
default:
throw new ArgumentException(
string.Format("Unknown value type: {0}", valueType));
}
}
public ObjectSubtype AddObjectSubType([NotNull] string name,
[NotNull] ObjectAttribute attribute,
[CanBeNull] object attributeValue,
VariantValueType valueType =
VariantValueType.Null)
{
Assert.ArgumentNotNullOrEmpty(name, nameof(name));
Assert.ArgumentNotNull(attribute, nameof(attribute));
ObjectSubtype objectSubtype = AddObjectSubType(name);
objectSubtype.AddCriterion(attribute, attributeValue, valueType);
return(objectSubtype);
}
public ObjectSubtype AddObjectSubType([NotNull] string name,
[NotNull] string attributeName,
[CanBeNull] object attributeValue,
VariantValueType valueType =
VariantValueType.Null)
{
Assert.ArgumentNotNullOrEmpty(name, nameof(name));
Assert.ArgumentNotNullOrEmpty(attributeName, nameof(attributeName));
ObjectAttribute attribute = ObjectDataset.GetAttribute(attributeName);
Assert.NotNull(attribute, "attribute '{0}' not found in '{1}' ",
attributeName, ObjectDataset.Name);
return(AddObjectSubType(name, attribute, attributeValue, valueType));
}
public ObjectSubtypeCriterion AddCriterion([NotNull] string attributeName,
object attributeValue,
VariantValueType valueType =
VariantValueType.Null)
{
Assert.ArgumentNotNullOrEmpty(attributeName, nameof(attributeName));
ObjectAttribute attribute =
_objectType.ObjectDataset.GetAttribute(attributeName);
Assert.NotNull(attribute, "Attribute {0} not found for {1}",
attributeName,
_objectType.ObjectDataset.Name);
return(AddCriterion(attribute, attributeValue, valueType));
}
public bool CanChangeTo(VariantValueType type)
{
if (_stringValue == null)
{
return(true);
}
if (type == VariantValueType.Null)
{
return(true);
}
object result;
return(ConversionUtils.TryParseTo(GetType(type),
_stringValue, _culture, out result));
}
private static bool TryGetValueType(object value, out VariantValueType variantType)
{
bool ok = true;
if (value == null)
{
variantType = VariantValueType.Null;
}
else
{
Type type = value.GetType();
if (type == typeof(double))
{
variantType = VariantValueType.Double;
}
else if (type == typeof(int))
{
variantType = VariantValueType.Integer;
}
else if (type == typeof(bool))
{
variantType = VariantValueType.Boolean;
}
else if (type == typeof(string))
{
variantType = VariantValueType.String;
}
else if (type == typeof(DateTime))
{
variantType = VariantValueType.DateTime;
}
else if (type.IsEnum)
{
variantType = VariantValueType.Integer;
}
else
{
variantType = VariantValueType.Null;
ok = false;
}
}
return(ok);
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectSubtypeCriterion"/> class.
/// </summary>
/// <param name="attribute">The attribute that the criterion is based on.</param>
/// <param name="attributeValue">The attribute value.</param>
/// <param name="valueType">Type of the value.</param>
public ObjectSubtypeCriterion([NotNull] ObjectAttribute attribute,
[CanBeNull] object attributeValue,
VariantValueType valueType = VariantValueType.Null)
{
Assert.ArgumentNotNull(attribute, nameof(attribute));
_attribute = attribute;
if (valueType == VariantValueType.Null)
{
// attributeValue = null; // "" can not be cast to numeric
_attributeValue = VariantValueFactory.Create(attribute, attributeValue);
}
else
{
_attributeValue = new VariantValue(attributeValue, valueType);
}
}
private static bool TryGetValueType(FieldType fieldType,
out VariantValueType valueType)
{
switch (fieldType)
{
case FieldType.ShortInteger:
case FieldType.LongInteger:
valueType = VariantValueType.Integer;
return(true);
case FieldType.Float:
case FieldType.Double:
valueType = VariantValueType.Double;
return(true);
case FieldType.Text:
valueType = VariantValueType.String;
return(true);
case FieldType.Date:
valueType = VariantValueType.DateTime;
return(true);
case FieldType.ObjectID:
case FieldType.Geometry:
case FieldType.Blob:
case FieldType.Raster:
case FieldType.Guid:
case FieldType.GlobalID:
case FieldType.Xml:
valueType = VariantValueType.Null;
return(false);
default:
throw new ArgumentOutOfRangeException(
nameof(fieldType), fieldType,
string.Format("Unknown field type: {0}", fieldType));
}
}
public ObjectSubtypeCriterion AddCriterion([NotNull] ObjectAttribute attribute,
object attributeValue,
VariantValueType variantValueType =
VariantValueType.Null)
{
Assert.ArgumentNotNull(attribute, nameof(attribute));
var criterion = new ObjectSubtypeCriterion(attribute, attributeValue,
variantValueType);
if (_criteria.Contains(criterion))
{
throw new ArgumentException(
string.Format(
"Criterion already exists in collection. Attribue={0}, Value={1}",
attribute.Name, attributeValue ?? "<null>"));
}
_criteria.Add(criterion);
return(criterion);
}
/// <summary>
/// Initializes a new instance of the <see cref="VariantValue"/> class.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="type">The type.</param>
public VariantValue([CanBeNull] object value, VariantValueType type)
{
_type = type;
Value = value;
}
