public void Value_equals_Next_Value()
{
//Arrange
var domain = new RangeDomain() { LowBound = 1, HighBound = 2 };
var variable = new Variable() { Domains = new System.Collections.Generic.List<IDomain>() { domain } };
//Act
var nextValue = variable.NextValue();
//Assert
Assert.AreEqual(variable.Value(), nextValue);
}
public void Next_Value_returns_first_domains_low_bound()
{
//Arrange
var domain = new RangeDomain() { LowBound = 1, HighBound = 3 };
var variable = new Variable() { Domains = new System.Collections.Generic.List<IDomain>() { domain } };
//Act
var firstValue = variable.NextValue();
//Assert
Assert.AreEqual(firstValue, domain.LowBound);
}
public void Value_called_for_the_first_time_equals_low_bound()
{
//Arrange
var domain = new RangeDomain() { LowBound = 1, HighBound = 2 };
var variable = new Variable() { Domains = new System.Collections.Generic.List<IDomain>() { domain } };
//Act
var value = variable.Value();
//Assert
Assert.AreEqual(value, domain.LowBound);
}
public void Values_Equal_Domain_Listing()
{
//Arrange
var domain = new RangeDomain() { LowBound = 1, HighBound = 2 };
var variable = new Variable() { Domains = new System.Collections.Generic.List<IDomain>() { domain } };
//Act
var values = variable.Values();
//Assert
Assert.AreEqual(values[0], 1);
Assert.AreEqual(values[1], 2);
}
public void Next_to_value_in_domain_is_value_plus_1()
{
//Arrange
var domain = new RangeDomain {
LowBound = 2, HighBound = 6
};
//Act
var nextToValue = domain.NextValue(4);
//Assert
Assert.AreEqual(nextToValue, 5);
}
public void Next_to_lower_bound_is_lower_bound_plus_1()
{
//Arrange
var domain = new RangeDomain {
LowBound = 2, HighBound = 4
};
//Act
var nextLowerBound = domain.NextValue(domain.LowBound);
//Assert
Assert.AreEqual(nextLowerBound, 3);
}
public void Next_to_higher_than_higher_bound_is_int_max()
{
//Arrange
var domain = new RangeDomain {
LowBound = 2, HighBound = 4
};
//Act
var nextHigherBound = domain.NextValue(5);
//Assert
Assert.AreEqual(nextHigherBound, int.MaxValue);
}
public void remove_higher_bound_should_make_new_higher_bound_minus_one()
{
//Arrange
var domain = new RangeDomain {
LowBound = 1, HighBound = 3
};
//Act
domain.Remove(domain.HighBound);
//Assert
Assert.AreEqual(domain.HighBound, 2);
}
public void Next_to_less_than_lower_bound_is_lower_bound()
{
//Arrange
var domain = new RangeDomain {
LowBound = 2, HighBound = 3
};
//Act
var nextToOne = domain.NextValue(1);
//Assert
Assert.AreEqual(nextToOne, domain.LowBound);
}
public void Initialize(object parameter)
{
numMinValue.Minimum = numMinValue.Minimum = int.MinValue;
numMinValue.Maximum = numMaxValue.Maximum = int.MaxValue;
_domain = parameter as RangeDomain;
if (_domain != null)
{
numMinValue.Value = (decimal)Math.Max(_domain.MinValue, (double)numMinValue.Minimum);
numMaxValue.Value = (decimal)Math.Min(_domain.MaxValue, (double)numMaxValue.Maximum);
}
}
public void Next_Value_after_NextValue_returns_the_Value_After()
{
//Arrange
var domain = new RangeDomain() { LowBound = 1, HighBound = 3 };
var variable = new Variable() { Domains = new System.Collections.Generic.List<IDomain>() { domain } };
variable.NextValue();
//Act
var secondValue = variable.NextValue();
//Assert
Assert.AreEqual(secondValue, 2);
}
public void Removing_last_value_of_last_domain_removes_domains()
{
//Arrange
var domain = new RangeDomain() { LowBound = 1, HighBound = 2 };
var variable = new Variable() { Domains = new System.Collections.Generic.List<IDomain>() { domain } };
//Act
variable.RemoveValue(1);
variable.RemoveValue(2);
//Assert
Assert.AreEqual(variable.Domains.Count, 0);
}
public void Lower_bound_equal_to_higher_bound_returns_one_value()
{
//Arrange
var domain = new RangeDomain {
LowBound = 1, HighBound = 1
};
//Act
var domainValues = domain.Values();
//Assert
Assert.AreEqual(domainValues.Count, 1);
Assert.AreEqual(domainValues[0], 1);
}
public void Next_Value_when_adomain_ends_returns_low_bound_of_the_next_domain()
{
//Arrange
var domain1 = new RangeDomain() { LowBound = 1, HighBound = 2 };
var domain2 = new RangeDomain() { LowBound = 4, HighBound = 6 };
var variable = new Variable() { Domains = new System.Collections.Generic.List<IDomain>() { domain1, domain2 } };
variable.NextValue();
variable.NextValue();
//Act
var firstValue_SecondDomain = variable.NextValue();
//Assert
Assert.AreEqual(firstValue_SecondDomain, domain2.LowBound);
}
public void Lower_bound_lower_then_higher_bound_returns_values_count()
{
//Arrange
var domain = new RangeDomain {
LowBound = 1, HighBound = 3
};
//Act
var domainValues = domain.Values();
//Assert
Assert.AreEqual(domainValues.Count, 3);
Assert.AreEqual(domainValues[0], 1);
Assert.AreEqual(domainValues[1], 2);
Assert.AreEqual(domainValues[2], 3);
}
public void Next_Value_after_the_last_value_of_the_last_domain_is_IntMax()
{
//Arrange
var domain1 = new RangeDomain() { LowBound = 1, HighBound = 2 };
var domain2 = new RangeDomain() { LowBound = 4, HighBound = 5 };
var variable = new Variable() { Domains = new System.Collections.Generic.List<IDomain>() { domain1, domain2 } };
variable.NextValue();
variable.NextValue();
variable.NextValue();
variable.NextValue();
//Act
var afterLastValue = variable.NextValue();
//Assert
Assert.AreEqual(afterLastValue, int.MaxValue);
}
public void MainMethodCode()
{
// Opening a Non-Versioned SQL Server instance.
DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
// Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
Instance = @"testMachine\testInstance",
// Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
Database = "LocalGovernment",
// Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
User = "******",
Password = "******",
Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
using (FeatureClassDefinition featureClassDefinition = geodatabase.GetDefinition <FeatureClassDefinition>("LocalGovernment.GDB.ServiceRequestComment"))
{
int rankIndex = featureClassDefinition.FindField("RANK");
Field field = featureClassDefinition.GetFields()[rankIndex];
Domain domain = field.GetDomain();
RangeDomain rangeDomain = (RangeDomain)domain;
// Will be "ServiceRequestRanking".
string name = rangeDomain.GetName();
// Will be FieldType.Integer.
FieldType fieldType = rangeDomain.GetFieldType();
// Will be "A factor assigned to unassigned service requests indicating importance".
string description = rangeDomain.GetDescription();
// Will be 1.
int minValue = Convert.ToInt32(rangeDomain.GetMinValue());
// Will be 5.
int maxValue = Convert.ToInt32(rangeDomain.GetMaxValue());
}
}
public void Remove_Not_Bound_Value_Throws_Exception()
{
//Arrange
var domain = new RangeDomain() { LowBound = 1, HighBound = 3 };
var variable = new Variable() { Domains = new System.Collections.Generic.List<IDomain>() { domain } };
//Act
try
{
variable.RemoveValue(2);
}
catch(Exception ex)
{
//Assert
Assert.AreEqual(ex.Message, "value within the range, could not be removed");
}
}
// RangeDomain
internal static Dictionary <string, object> ToDictionary(this RangeDomain <IComparable> domain)
{
Dictionary <string, object> dictionary = new Dictionary <string, object>();
if (!string.IsNullOrEmpty(domain.Name))
{
dictionary.Add("name", domain.Name);
}
List <object> range = new List <object>();
range.Add(domain.MinimumValue);
range.Add(domain.MaximumValue);
dictionary.Add("range", range);
return(dictionary);
}
/// <summary>
/// Initializes a new instance of the <see cref="FeatureDataField<T>"/> class.
/// </summary>
/// <param name="featureDataForm">The feature data form.</param>
/// <param name="layerInfo">The feature layer info.</param>
/// <param name="field">The field.</param>
/// <param name="propertyType">Type of the property.</param>
/// <param name="propertyValue">The property value.</param>
internal FeatureDataField(FeatureDataForm featureDataForm, FeatureLayerInfo layerInfo, Field field, Type propertyType, T propertyValue)
{
this._featureDataForm = featureDataForm;
this._field = field;
this._layerInfo = layerInfo;
this._codedValueDomain = null;
Domain domain = field.Domain;
if (domain != null && !Toolkit.Utilities.FieldDomainUtils.IsDynamicDomain(_field, _layerInfo))
{
this._codedValueDomain = domain as CodedValueDomain;
if (propertyType == typeof(DateTime) || propertyType == typeof(DateTime?))
{
this._dateRangeDomain = domain as RangeDomain <DateTime>;
}
else if (propertyType == typeof(double) || propertyType == typeof(double?))
{
this._doubleRangeDomain = domain as RangeDomain <double>;
}
else if (propertyType == typeof(float) || propertyType == typeof(float?))
{
this._floatRangeDomain = domain as RangeDomain <float>;
}
else if (propertyType == typeof(int) || propertyType == typeof(int?))
{
this._intRangeDomain = domain as RangeDomain <int>;
}
else if (propertyType == typeof(short) || propertyType == typeof(short?))
{
this._shortRangeDomain = domain as RangeDomain <short>;
}
else if (propertyType == typeof(long) || propertyType == typeof(long?))
{
this._longRangeDomain = domain as RangeDomain <long>;
}
else if (propertyType == typeof(byte) || propertyType == typeof(byte?))
{
this._byteRangeDomain = domain as RangeDomain <byte>;
}
}
this._propertyType = propertyType;
this._propertyValue = propertyValue;
}
/// <summary>
/// Initializes a new instance of the <see cref="FeatureDataField<T>"/> class.
/// </summary>
/// <param name="featureDataForm">The feature data form.</param>
/// <param name="field">The field.</param>
/// <param name="propertyType">Type of the property.</param>
/// <param name="propertyValue">The property value.</param>
internal FeatureDataField(FeatureDataForm featureDataForm, Field field, Type propertyType, T propertyValue)
{
this._featureDataForm = featureDataForm;
this._codedValueDomain = null;
Domain domain = field.Domain;
if (domain != null)
{
this._codedValueDomain = domain as CodedValueDomain;
if (propertyType == typeof(DateTime) || propertyType == typeof(DateTime?))
{
this._dateRangeDomain = domain as RangeDomain <DateTime>;
}
else if (propertyType == typeof(double) || propertyType == typeof(double?))
{
this._doubleRangeDomain = domain as RangeDomain <double>;
}
else if (propertyType == typeof(float) || propertyType == typeof(float?))
{
this._floatRangeDomain = domain as RangeDomain <float>;
}
else if (propertyType == typeof(int) || propertyType == typeof(int?))
{
this._intRangeDomain = domain as RangeDomain <int>;
}
else if (propertyType == typeof(short) || propertyType == typeof(short?))
{
this._shortRangeDomain = domain as RangeDomain <short>;
}
else if (propertyType == typeof(long) || propertyType == typeof(long?))
{
this._longRangeDomain = domain as RangeDomain <long>;
}
else if (propertyType == typeof(byte) || propertyType == typeof(byte?))
{
this._byteRangeDomain = domain as RangeDomain <byte>;
}
}
this._field = field;
this._propertyType = propertyType;
this._propertyValue = propertyValue;
}
internal static IEnumerable <KeyValuePair <object, RangeDomain <T> > > BuildDynamicRangeDomain <T>(Field field, FeatureLayerInfo layerInfo) where T : System.IComparable
{
List <KeyValuePair <object, RangeDomain <T> > > dynamicRangeDomains = null;
foreach (object key in layerInfo.FeatureTypes.Keys)
{
FeatureType featureType = layerInfo.FeatureTypes[key];
if (featureType.Domains.ContainsKey(field.Name))
{
if (dynamicRangeDomains == null)
{
dynamicRangeDomains = new List <KeyValuePair <object, RangeDomain <T> > >();
}
RangeDomain <T> rangeDomain = featureType.Domains[field.Name] as RangeDomain <T>;
if (rangeDomain != null)
{
dynamicRangeDomains.Add(new KeyValuePair <object, RangeDomain <T> >(featureType.Id, rangeDomain));
}
}
}
return(dynamicRangeDomains);
}
public static FieldDomain GetDomain(Domain fs_domain)
{
FieldDomain result;
try
{
ObservableDictionary <string, FieldDomain> domains = AfaDocData.ActiveDocData.DocDataset.Domains;
string key = DocUtil.FixSymbolName(fs_domain.DomainName);
FieldDomain fieldDomain = null;
if (domains.TryGetValue(key, out fieldDomain) && FieldDomain.AreEquivalent(fieldDomain, fs_domain))
{
result = fieldDomain;
}
else
{
string domainType = "";
if (fs_domain is CodedValueDomain)
{
domainType = "CodedValueDomain";
}
else if (fs_domain is RangeDomain)
{
domainType = "RangeDomain";
}
CadField.CadFieldType cadFieldType = FieldDomain.GetCadFieldType(fs_domain.FieldType);
fieldDomain = new FieldDomain(fs_domain.DomainName, cadFieldType, domainType);
if (fs_domain is CodedValueDomain)
{
CodedValueDomain codedValueDomain = (CodedValueDomain)fs_domain;
if (codedValueDomain.CodedValues.Length <= 0)
{
goto IL_129;
}
CodedValue[] array = codedValueDomain.CodedValues.ToArray <CodedValue>();
try
{
CodedValue[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
CodedValue codedValue = array2[i];
fieldDomain.CodedValues.Add(DocUtil.FixSymbolName(codedValue.Name), new MSCCodedValue(codedValue.Name, cadFieldType, codedValue.Code));
}
goto IL_129;
}
catch (SystemException ex)
{
string arg_FC_0 = ex.Message;
goto IL_129;
}
}
if (fs_domain is RangeDomain)
{
RangeDomain rangeDomain = (RangeDomain)fs_domain;
fieldDomain.MinValue = rangeDomain.MinValue;
fieldDomain.MaxValue = rangeDomain.MaxValue;
}
IL_129:
AfaDocData.ActiveDocData.DocDataset.Domains.Add(fieldDomain.Name, fieldDomain);
result = fieldDomain;
}
}
catch
{
result = null;
}
return(result);
}
/// <summary>
/// Sets the field information in the feature layer.
/// </summary>
/// <param name="featureLayerInfo">The feature layer info.</param>
/// <param name="rangeDomainInfo">The range domain info.</param>
/// <param name="fieldProps">The properties associated with the field.</param>
/// <returns>Dictionary of field types keyed by their actual names. Also, populates range domain information and field properties if any.</returns>
internal static Dictionary <string, Type> SetFieldInfo(FeatureLayerInfo featureLayerInfo, out Dictionary <string, object[]> rangeDomainInfo, out Dictionary <string, Field> fieldProps)
{
Dictionary <string, Type> fieldInfo = null;
rangeDomainInfo = null;
fieldProps = new Dictionary <string, Field>();
if (featureLayerInfo != null)
{
fieldInfo = new Dictionary <string, Type>();
foreach (Field field in featureLayerInfo.Fields)
{
Type fieldType = typeof(object);
switch (field.Type)
{
case Field.FieldType.Date:
fieldType = typeof(DateTime?);
break;
case Field.FieldType.Double:
fieldType = typeof(double?);
break;
case Field.FieldType.Integer:
fieldType = typeof(int?);
break;
case Field.FieldType.OID:
fieldType = typeof(int);
break;
case Field.FieldType.Geometry:
case Field.FieldType.GUID:
case Field.FieldType.Blob:
case Field.FieldType.Raster:
case Field.FieldType.Unknown:
fieldType = typeof(object);
break;
case Field.FieldType.Single:
fieldType = typeof(float?);
break;
case Field.FieldType.SmallInteger:
fieldType = typeof(short?);
break;;
case Field.FieldType.GlobalID:
case Field.FieldType.String:
case Field.FieldType.XML:
fieldType = typeof(string);
break;
default:
throw new NotSupportedException(string.Format(Properties.Resources.FieldDomain_FieldTypeNotSupported, fieldType.GetType()));
}
fieldInfo.Add(field.Name, fieldType);
fieldProps.Add(field.Name, field);
// Populating the range domain info if any:
if (field.Domain != null)
{
switch (field.Type)
{
case Field.FieldType.Date:
RangeDomain <DateTime> dateTimeRangeDomain = field.Domain as RangeDomain <DateTime>;
if (dateTimeRangeDomain != null)
{
if (rangeDomainInfo == null)
{
rangeDomainInfo = new Dictionary <string, object[]>();
}
rangeDomainInfo.Add(field.Name, new object[] { dateTimeRangeDomain.MinimumValue, dateTimeRangeDomain.MaximumValue });
}
break;
case Field.FieldType.Double:
RangeDomain <double> doubleRangeDomain = field.Domain as RangeDomain <double>;
if (doubleRangeDomain != null)
{
if (rangeDomainInfo == null)
{
rangeDomainInfo = new Dictionary <string, object[]>();
}
rangeDomainInfo.Add(field.Name, new object[] { doubleRangeDomain.MinimumValue, doubleRangeDomain.MaximumValue });
}
break;
case Field.FieldType.Integer:
RangeDomain <int> intRangeDomain = field.Domain as RangeDomain <int>;
if (intRangeDomain != null)
{
if (rangeDomainInfo == null)
{
rangeDomainInfo = new Dictionary <string, object[]>();
}
rangeDomainInfo.Add(field.Name, new object[] { intRangeDomain.MinimumValue, intRangeDomain.MaximumValue });
}
break;
case Field.FieldType.Single:
RangeDomain <Single> singleRangeDomain = field.Domain as RangeDomain <Single>;
if (singleRangeDomain != null)
{
if (rangeDomainInfo == null)
{
rangeDomainInfo = new Dictionary <string, object[]>();
}
rangeDomainInfo.Add(field.Name, new object[] { singleRangeDomain.MinimumValue, singleRangeDomain.MaximumValue });
}
break;
case Field.FieldType.SmallInteger:
RangeDomain <short> shortRangeDomain = field.Domain as RangeDomain <short>;
if (shortRangeDomain != null)
{
if (rangeDomainInfo == null)
{
rangeDomainInfo = new Dictionary <string, object[]>();
}
rangeDomainInfo.Add(field.Name, new object[] { shortRangeDomain.MinimumValue, shortRangeDomain.MaximumValue });
}
break;
}
}
}
}
return(fieldInfo);
}
