public static IErrorObject CreateErrorObject(
[NotNull] IObject errorObject, [NotNull] IErrorDataset errorDataset,
[CanBeNull] IFieldIndexCache fieldIndexCache = null)
{
Assert.ArgumentNotNull(errorObject, nameof(errorObject));
Assert.ArgumentNotNull(errorDataset, nameof(errorDataset));
switch (errorDataset)
{
case ErrorTableDataset dataset:
return(new ErrorTableObject(errorObject, dataset, fieldIndexCache));
case ErrorLineDataset dataset:
return(new ErrorLineObject((IFeature)errorObject, dataset, fieldIndexCache));
case ErrorMultiPatchDataset dataset:
return(new ErrorMultiPatchObject((IFeature)errorObject, dataset,
fieldIndexCache));
case ErrorMultipointDataset dataset:
return(new ErrorMultipointObject((IFeature)errorObject, dataset,
fieldIndexCache));
case ErrorPolygonDataset dataset:
return(new ErrorPolygonObject((IFeature)errorObject, dataset, fieldIndexCache));
default:
throw new ArgumentOutOfRangeException(
$"Unknown IErrorDataset: {errorDataset.GetType()}");
}
}
protected VectorObject([NotNull] IFeature feature,
[NotNull] VectorDataset dataset,
[CanBeNull] IFieldIndexCache fieldIndexCache)
: base(feature, dataset, fieldIndexCache)
{
Feature = feature;
}
public static int GetRequiredFieldIndex(
[NotNull] IRow row,
[NotNull] Attribute attribute,
[CanBeNull] IFieldIndexCache fieldIndexCache = null)
{
return(GetRequiredFieldIndex(row.Table, attribute, fieldIndexCache));
}
public static int GetFieldIndex([NotNull] ITable table,
[NotNull] AssociationAttribute associationAttribute,
[CanBeNull] IFieldIndexCache fieldIndexCache = null)
{
return
(fieldIndexCache?.GetFieldIndex(table, associationAttribute.Name, null) ??
GetFieldIndex(table, associationAttribute.Name, null));
}
public static int GetFieldIndex([NotNull] ITable table,
[NotNull] ObjectAttribute objectAttribute,
[CanBeNull] IFieldIndexCache fieldIndexCache = null)
{
return
(fieldIndexCache?.GetFieldIndex(table, objectAttribute.Name, objectAttribute.Role) ??
GetFieldIndex(table, objectAttribute.Name, objectAttribute.Role));
}
protected ObjectObject([NotNull] IObject obj,
[NotNull] ObjectDataset dataset,
[CanBeNull] IFieldIndexCache fieldIndexCache)
{
_object = obj;
_dataset = dataset;
_fieldIndexCache = fieldIndexCache;
}
public static T?GetValueFor <T>([NotNull] IRow row,
[NotNull] Attribute attribute,
[CanBeNull] IFieldIndexCache fieldIndexCache)
where T : struct
{
var fieldIndex = GetRequiredFieldIndex(row, attribute, fieldIndexCache);
return(GdbObjectUtils.ConvertRowValue <T>(row, fieldIndex));
}
public static int GetFieldIndex([NotNull] ITable table,
[NotNull] Attribute attribute,
[CanBeNull] IFieldIndexCache fieldIndexCache = null)
{
AttributeRole attributeRole = (attribute as ObjectAttribute)?.Role;
return
(fieldIndexCache?.GetFieldIndex(table, attribute.Name, attributeRole) ??
GetFieldIndex(table, attribute.Name, attributeRole));
}
private int GetFieldIndex([NotNull] AttributeRole role,
[CanBeNull] IFieldIndexCache fieldIndexCache)
{
const bool roleIsOptional = false;
int? result = GetFieldIndex(role, fieldIndexCache, roleIsOptional);
if (result == null)
{
throw new InvalidOperationException("field index expected");
}
return(result.Value);
}
private static IssueDatasetWriter CreateIssueWriter(
[NotNull] IErrorDataset objectDataset,
[NotNull] IDatasetContext datasetContext,
[NotNull] IFieldIndexCache fieldIndexCache)
{
Assert.ArgumentNotNull(objectDataset, nameof(objectDataset));
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
Assert.ArgumentNotNull(fieldIndexCache, nameof(fieldIndexCache));
ITable table = datasetContext.OpenTable(objectDataset);
return(table == null
? null
: new IssueDatasetWriter(table, objectDataset, fieldIndexCache));
}
/// <summary>
/// Initializes a new instance of the <see cref="IssueDatasetWriter"/> class.
/// </summary>
/// <param name="issueTable">The error table.</param>
/// <param name="issueObjectDataset">The error object dataset.</param>
/// <param name="fieldIndexCache">The field index cache.</param>
public IssueDatasetWriter([NotNull] ITable issueTable,
[NotNull] IErrorDataset issueObjectDataset,
[NotNull] IFieldIndexCache fieldIndexCache)
{
Assert.ArgumentNotNull(issueTable, nameof(issueTable));
Assert.ArgumentNotNull(issueObjectDataset, nameof(issueObjectDataset));
Assert.ArgumentNotNull(fieldIndexCache, nameof(fieldIndexCache));
Table = issueTable;
_issueObjectDataset = issueObjectDataset;
_fieldIndexCache = fieldIndexCache;
_featureClass = Table as IFeatureClass;
HasM = _featureClass != null && DatasetUtils.HasM(_featureClass);
HasZ = _featureClass != null && DatasetUtils.HasZ(_featureClass);
}
public static int GetRequiredFieldIndex(
[NotNull] ITable table,
[NotNull] Attribute attribute,
[CanBeNull] IFieldIndexCache fieldIndexCache = null)
{
int fieldIndex = GetFieldIndex(table, attribute, fieldIndexCache);
if (fieldIndex < 0)
{
_msg.DebugFormat("Missing attribute: {0}", attribute);
throw new InvalidOperationException(
string.Format("Field {0} not found in table {1}",
attribute.Name, DatasetUtils.GetName(table)));
}
return(fieldIndex);
}
private int?GetFieldIndex([NotNull] AttributeRole role,
[CanBeNull] IFieldIndexCache fieldIndexCache,
bool roleIsOptional)
{
ObjectAttribute attribute = _dataset.GetAttribute(role);
if (attribute == null)
{
if (roleIsOptional)
{
return(null);
}
throw new ArgumentException(
string.Format("Dataset [{0}] has no attribute role [{1}]",
_dataset.Name, role), nameof(role));
}
return(AttributeUtils.GetFieldIndex(_object.Class, attribute, fieldIndexCache));
}
CreateIssueWritersByGeometryType(
[NotNull] IVerificationContext verificationContext,
[NotNull] IFieldIndexCache fieldIndexCache)
{
var result = new Dictionary <esriGeometryType, IssueDatasetWriter>();
foreach (KeyValuePair <esriGeometryType, IErrorDataset> pair in
VerificationContextUtils.GetIssueDatasetsByGeometryType(verificationContext))
{
IssueDatasetWriter issueWriter = CreateIssueWriter(pair.Value,
verificationContext,
fieldIndexCache);
if (issueWriter != null)
{
result.Add(pair.Key, issueWriter);
}
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="IssueDatasetWriter"/> class.
/// </summary>
/// <param name="issueFeatureClass">The error feature class.</param>
/// <param name="issueObjectDataset">The error object dataset.</param>
/// <param name="fieldIndexCache">The field index cache.</param>
public IssueDatasetWriter([NotNull] IFeatureClass issueFeatureClass,
[NotNull] IErrorDataset issueObjectDataset,
[NotNull] IFieldIndexCache fieldIndexCache)
: this((ITable)issueFeatureClass, issueObjectDataset, fieldIndexCache)
{
}
public static object GetValueFor([NotNull] IRow row,
[NotNull] Attribute attribute,
[CanBeNull] IFieldIndexCache fieldIndexCache)
{
return(row.Value[GetRequiredFieldIndex(row, attribute, fieldIndexCache)]);
}
internal ErrorMultipointObject([NotNull] IFeature feature,
[NotNull] ErrorMultipointDataset dataset,
[CanBeNull] IFieldIndexCache fieldIndexCache)
: base(feature, dataset, fieldIndexCache)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ErrorTableObject"/> class.
/// </summary>
/// <param name="row">The row.</param>
/// <param name="dataset">The dataset.</param>
/// <param name="fieldIndexCache">The optional field index cache.</param>
internal ErrorTableObject([NotNull] IRow row,
[NotNull] ErrorTableDataset dataset,
[CanBeNull] IFieldIndexCache fieldIndexCache)
: base(row, dataset, fieldIndexCache)
{
}
public static int GetFieldIndex([NotNull] IObjectClass objectClass,
[NotNull] ObjectAttribute objectAttribute,
[CanBeNull] IFieldIndexCache fieldIndexCache = null)
{
return(GetFieldIndex((ITable)objectClass, objectAttribute, fieldIndexCache));
}
internal ErrorPolygonObject([NotNull] IFeature feature,
[NotNull] ErrorPolygonDataset dataset,
[CanBeNull] IFieldIndexCache fieldIndexCache)
: base(feature, dataset, fieldIndexCache)
{
}
protected TableObject([NotNull] IRow obj,
[NotNull] TableDataset dataset,
[CanBeNull] IFieldIndexCache fieldIndexCache)
: base((IObject)obj, dataset, fieldIndexCache)
{
}
