protected VectorObject([NotNull] IFeature feature,
[NotNull] VectorDataset dataset,
[CanBeNull] IFieldIndexCache fieldIndexCache)
: base(feature, dataset, fieldIndexCache)
{
Feature = feature;
}
public ProcessDatasetName([NotNull] VectorDataset vectorDataset,
[CanBeNull] string whereClause,
[CanBeNull] string representationClassName = null)
{
Assert.ArgumentNotNull(vectorDataset, nameof(vectorDataset));
VectorDataset = vectorDataset;
WhereClause = whereClause ?? string.Empty;
RepresentationClassName = representationClassName;
}
public void CanGetByName()
{
const string dsName1 = "ds1";
const string dsName2 = "ds2";
DdxModel m = CreateModel();
VectorDataset ds1 = m.AddDataset(CreateVectorDataset(dsName1));
VectorDataset ds2 = m.AddDataset(CreateVectorDataset(dsName2));
var uuidType = new ObjectAttributeType("uuid", AttributeRole.UUID);
ObjectAttribute pk1 =
ds1.AddAttribute(new ObjectAttribute("pk1", FieldType.Text, uuidType));
ObjectAttribute pk2 =
ds2.AddAttribute(new ObjectAttribute("pk2", FieldType.Text, uuidType));
const string asoName = "aso1";
const string fk1Name = "fk1";
const string fk2Name = "fk2";
m.AddAssociation(
new AttributedAssociation(
asoName, AssociationCardinality.ManyToMany,
fk1Name,
FieldType.Text, pk1,
fk2Name,
FieldType.Text, pk2));
CreateSchema(uuidType, m);
UnitOfWork.NewTransaction(
delegate
{
AssertUnitOfWorkHasNoChanges();
IList <Association> list = Repository.Get(asoName);
Assert.AreEqual(1, list.Count);
Association result = list[0] as AttributedAssociation;
Assert.IsNotNull(result);
Assert.AreEqual(asoName, result.Name);
Assert.AreEqual(fk1Name, result.End1.ForeignKey.Name);
Assert.AreEqual(fk2Name, result.End2.ForeignKey.Name);
Assert.AreEqual(dsName1, result.End1.ObjectDataset.Name);
Assert.AreEqual(dsName2, result.End2.ObjectDataset.Name);
});
}
public static Matrix Convert([NotNull] QualityCondition qualityCondition)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
IList <TestParameterValue> featureClassParameters =
qualityCondition.GetParameterValues(QaTopoNotNearPolyFactory.FeatureClassParamName);
Assert.AreEqual(1, featureClassParameters.Count,
$"found {featureClassParameters.Count} featureClass, expected 1");
IList <TestParameterValue> referenceParameters =
qualityCondition.GetParameterValues(QaTopoNotNearPolyFactory.ReferenceParamName);
Assert.AreEqual(1, referenceParameters.Count,
$"found {referenceParameters.Count} near, expected 1");
VectorDataset featureClassDataset = GetVectorDataset(featureClassParameters[0]);
VectorDataset referenceDataset = GetVectorDataset(referenceParameters[0]);
IList <TestParameterValue> referenceSubtypesParameters =
qualityCondition.GetParameterValues(
QaTopoNotNearPolyFactory.ReferenceSubtypesParamName);
IList <int> referenceSubtypes =
referenceSubtypesParameters.Select(x => int.Parse(x.StringValue)).ToList();
IList <TestParameterValue> featuresubtypeRulesParameters =
qualityCondition.GetParameterValues(
QaTopoNotNearPolyFactory.FeaturesubtypeRulesParamName);
IList <string> featuresubtypeRules =
featuresubtypeRulesParameters.Select(x => x.StringValue).ToList();
Matrix matrix = InitMatrix(
featureClassDataset,
((DatasetTestParameterValue)featureClassParameters[0]).FilterExpression,
referenceDataset,
((DatasetTestParameterValue)referenceParameters[0]).FilterExpression,
referenceSubtypes, featuresubtypeRules);
return(matrix);
}
public QualityCondition Convert([NotNull] Matrix matrix,
[NotNull] IList <Dataset> datasets)
{
Assert.ArgumentNotNull(matrix, nameof(matrix));
Assert.ArgumentNotNull(datasets, nameof(datasets));
var classDescriptor = new ClassDescriptor(typeof(QaTopoNotNearPolyFactory));
var testDescriptor = new TestDescriptor(
_importedTestDescriptor, classDescriptor);
var qualityCondition = new QualityCondition(
_importedQualityCondition, testDescriptor);
Dictionary <string, TestParameter> parDict = QaTopoNotNearPolyFactory
.CreateParameterList()
.ToDictionary(x => x.Name);
VectorDataset featureClassDs = GetDataset(matrix.FeatureClassName, datasets);
qualityCondition.AddParameterValue(new DatasetTestParameterValue(
parDict[
QaTopoNotNearPolyFactory
.FeatureClassParamName], featureClassDs)
{
FilterExpression = matrix.FeatureClassFilter
});
VectorDataset referenceDs = GetDataset(matrix.ReferenceName, datasets);
qualityCondition.AddParameterValue(new DatasetTestParameterValue(
parDict[
QaTopoNotNearPolyFactory.ReferenceParamName],
referenceDs)
{
FilterExpression = matrix.ReferenceFilter
});
{
GetSubtypes(featureClassDs, out string field, out IList <Subtype> subtypes);
Assert.NotNull(field);
Assert.NotNull(subtypes);
foreach (FeatureTypeProps featureTypeProps in matrix.FeatureClassTypes)
{
string subtypeName = featureTypeProps.SubType.SubtypeName.Trim();
Subtype subtype = subtypes.First(x => x.Name.Equals(subtypeName));
StringBuilder rulesBuilder = new StringBuilder();
rulesBuilder.Append($"{subtype.Code};");
rulesBuilder.Append($"{featureTypeProps.DefaultDistance};");
rulesBuilder.Append($"{featureTypeProps.RightSideDistance};");
foreach (int canOverlap in featureTypeProps.CanOverlap)
{
rulesBuilder.Append($"{canOverlap};");
}
qualityCondition.AddParameterValue(new ScalarTestParameterValue(
parDict[
QaTopoNotNearPolyFactory
.FeaturesubtypeRulesParamName],
rulesBuilder.ToString()));
}
}
{
GetSubtypes(referenceDs, out string field, out IList <Subtype> subtypes);
Assert.NotNull(field);
Assert.NotNull(subtypes);
foreach (ConnectionType refType in matrix.ReferenceTypes)
{
string subtypeName = refType.SubtypeName.Trim();
Subtype subtype = subtypes.First(x => x.Name.Equals(subtypeName));
qualityCondition.AddParameterValue(new ScalarTestParameterValue(
parDict[
QaTopoNotNearPolyFactory
.ReferenceSubtypesParamName],
subtype.Code));
}
}
return(qualityCondition);
}
private static Matrix InitMatrix(
[NotNull] VectorDataset featureClassDataset,
[CanBeNull] string featureClassFilter,
[NotNull] VectorDataset referenceDataset,
[CanBeNull] string referenceFilter,
[NotNull] IList <int> referenceSubtypes,
[NotNull] IList <string> featuresubtypeRules)
{
List <ConnectionType> refSubtypes = new List <ConnectionType>();
{
GetSubtypes(referenceDataset, out string field, out IList <Subtype> refTypes);
Assert.NotNull(refTypes);
string reference = referenceDataset.Name;
foreach (int referenceSubtype in referenceSubtypes)
{
string subtype = refTypes.First(x => x.Code == referenceSubtype).Name;
refSubtypes.Add(
new ConnectionType(reference, field, subtype, referenceSubtype)
{
FeatureClassFilter = referenceFilter
});
}
if (refSubtypes.Count == 0)
{
foreach (Subtype refType in refTypes)
{
refSubtypes.Add(
new ConnectionType(reference, field, refType.Name, refType.Code)
{
FeatureClassFilter = referenceFilter
});
}
}
}
List <FeatureTypeProps> featureClassSubtypes = new List <FeatureTypeProps>();
{
GetSubtypes(featureClassDataset, out string field, out IList <Subtype> fcTypes);
Assert.NotNull(fcTypes);
string featureclass = featureClassDataset.Name;
foreach (string rule in featuresubtypeRules)
{
IList <string> ruleParts = rule.Split(';');
int fcSubtype = int.Parse(ruleParts[0]);
string subtype = fcTypes.First(x => x.Code == fcSubtype).Name;
List <int> canOverlaps = new List <int>();
foreach (int overlapIndex in EnumOverlapIndices(
ruleParts, rule, referenceSubtypes))
{
if (!int.TryParse(ruleParts[overlapIndex], out int canOverlap))
{
throw new InvalidOperationException(
$"Invalid overlap index '{ruleParts[overlapIndex]}' in featureSubtypeRule '{rule}'");
}
canOverlaps.Add(canOverlap);
}
ConnectionType conn =
new ConnectionType(featureclass, field, subtype, fcSubtype)
{
FeatureClassFilter = featureClassFilter
};
FeatureTypeProps props =
new FeatureTypeProps
{
SubType = conn,
DefaultDistance = double.Parse(ruleParts[1]),
CanOverlap = canOverlaps
};
if (!string.IsNullOrWhiteSpace(ruleParts[2]))
{
props.RightSideDistance = double.Parse(ruleParts[2]);
}
featureClassSubtypes.Add(props);
}
if (featuresubtypeRules.Count == 0)
{
foreach (Subtype fcType in fcTypes)
{
ConnectionType conn =
new ConnectionType(featureclass, field, fcType.Name, fcType.Code)
{
FeatureClassFilter = featureClassFilter
};
featureClassSubtypes.Add(new FeatureTypeProps
{
SubType = conn, DefaultDistance = 1,
CanOverlap =
new List <int>(new int[refSubtypes.Count])
});
}
}
}
return(new Matrix(featureClassSubtypes, refSubtypes));
}
