public static IList <GdbWorkspace> CreateSchema(
[NotNull] IEnumerable <ObjectClassMsg> objectClassMessages,
[CanBeNull] ICollection <ObjectClassMsg> relClassMessages = null,
Func <DataVerificationResponse, DataVerificationRequest> moreDataRequest = null)
{
var result = new List <GdbWorkspace>();
foreach (IGrouping <int, ObjectClassMsg> classGroup in objectClassMessages.GroupBy(
c => c.WorkspaceHandle))
{
GdbTableContainer gdbTableContainer =
CreateGdbTableContainer(classGroup, moreDataRequest,
out GdbWorkspace gdbWorkspace);
result.Add(gdbWorkspace);
if (relClassMessages == null)
{
continue;
}
foreach (ObjectClassMsg relTableMsg
in relClassMessages.Where(
r => r.WorkspaceHandle == gdbWorkspace.WorkspaceHandle))
{
GdbTable relClassTable = FromObjectClassMsg(relTableMsg, gdbWorkspace);
gdbTableContainer.TryAddRelationshipClass(relClassTable);
}
}
return(result);
}
public static IList <IFeature> FromGdbObjectMsgList(
[NotNull] ICollection <GdbObjectMsg> gdbObjectMessages,
[NotNull] ICollection <ObjectClassMsg> objectClassMessages)
{
GdbTableContainer container = CreateGdbTableContainer(objectClassMessages, null, out _);
return(FromGdbObjectMsgList(gdbObjectMessages, container));
}
public static GdbTableContainer CreateGdbTableContainer(
[NotNull] IEnumerable <ObjectClassMsg> objectClassMessages,
[CanBeNull] Func <DataVerificationResponse, DataVerificationRequest> getRemoteDataFunc,
out GdbWorkspace workspace)
{
GdbTableContainer container = null;
int?workspaceHandle = null;
workspace = null;
foreach (ObjectClassMsg objectClassMsg in objectClassMessages)
{
if (workspaceHandle == null)
{
workspaceHandle = objectClassMsg.WorkspaceHandle;
container = new GdbTableContainer();
workspace = new GdbWorkspace(container)
{
WorkspaceHandle = objectClassMsg.WorkspaceHandle
};
}
else
{
Assert.AreEqual(workspaceHandle, objectClassMsg.WorkspaceHandle,
"Not all features are from the same workspace");
}
if (objectClassMsg.WorkspaceHandle == -1)
{
workspace = null;
}
Func <ITable, BackingDataset> createBackingDataset = null;
if (getRemoteDataFunc != null)
{
createBackingDataset = (t) =>
new RemoteDataset(t, getRemoteDataFunc,
new ClassDef
{
ClassHandle = objectClassMsg.ClassHandle,
WorkspaceHandle = objectClassMsg.WorkspaceHandle
});
}
GdbTable gdbTable =
FromObjectClassMsg(objectClassMsg, workspace, createBackingDataset);
container.TryAdd(gdbTable);
}
return(container);
}
public static GdbFeature FromGdbFeatureMsg(
[NotNull] GdbObjectMsg gdbObjectMsg,
[NotNull] GdbTableContainer tableContainer)
{
var featureClass =
(IFeatureClass)tableContainer.GetByClassId(gdbObjectMsg.ClassHandle);
GdbFeature result = CreateGdbFeature(gdbObjectMsg, featureClass);
return(result);
}
public static IList <IFeature> FromGdbObjectMsgList(
[NotNull] ICollection <GdbObjectMsg> gdbObjectMessages,
[NotNull] GdbTableContainer container)
{
var result = new List <IFeature>(gdbObjectMessages.Count);
Assert.NotNull(container, "No object class provided");
foreach (GdbObjectMsg gdbObjectMsg in gdbObjectMessages)
{
GdbFeature remoteFeature = FromGdbFeatureMsg(gdbObjectMsg, container);
result.Add(remoteFeature);
}
return(result);
}
private static IList <IFeature> GetFeaturesToReshape(
[NotNull] AdvancedReshapeRequest request,
out GdbTableContainer container)
{
container = ProtobufConversionUtils.CreateGdbTableContainer(
request.ClassDefinitions, null, out _);
foreach (IDataset dataset in container.GetDatasets(esriDatasetType.esriDTAny))
{
if (dataset is IObjectClass objectClass)
{
objectClass.AddField(FieldUtils.CreateOIDField());
}
}
IList <IFeature> featuresToReshape =
ProtobufConversionUtils.FromGdbObjectMsgList(request.Features, container);
return(featuresToReshape);
}
public static RemoveOverlapsResponse RemoveOverlaps(
[NotNull] RemoveOverlapsRequest request,
[CanBeNull] ITrackCancel trackCancel = null)
{
// Unpack request
bool explodeMultiparts = request.ExplodeMultipartResults;
bool storeOverlapsAsNewFeatures = request.StoreOverlapsAsNewFeatures;
GdbTableContainer container = ProtobufConversionUtils.CreateGdbTableContainer(
request.ClassDefinitions, null, out _);
IList <IFeature> selectedFeatureList =
ProtobufConversionUtils.FromGdbObjectMsgList(
request.SourceFeatures, container);
IList <IFeature> targetFeaturesForVertexInsertion =
ProtobufConversionUtils.FromGdbObjectMsgList(
request.UpdatableTargetFeatures, container);
Overlaps overlaps = new Overlaps();
foreach (OverlapMsg overlapMsg in request.Overlaps)
{
GdbObjectReference gdbRef = new GdbObjectReference(
overlapMsg.OriginalFeatureRef.ClassHandle,
overlapMsg.OriginalFeatureRef.ObjectId);
IFeatureClass fClass = (IFeatureClass)container.GetByClassId(gdbRef.ClassId);
List <IGeometry> overlapGeometries =
ProtobufGeometryUtils.FromShapeMsgList <IGeometry>(
overlapMsg.Overlaps,
DatasetUtils.GetSpatialReference(fClass));
overlaps.AddGeometries(gdbRef, overlapGeometries);
}
// Remove overlaps
OverlapsRemover overlapsRemover = RemoveOverlaps(
selectedFeatureList, overlaps, targetFeaturesForVertexInsertion, explodeMultiparts,
storeOverlapsAsNewFeatures, trackCancel);
// Pack response
var result = overlapsRemover.Result;
var response = new RemoveOverlapsResponse();
PackResultGeometries(result.ResultsByFeature,
response.ResultsByFeature);
response.NonStorableMessages.AddRange(result.NonStorableMessages);
if (result.TargetFeaturesToUpdate != null)
{
foreach (var keyValuePair in result.TargetFeaturesToUpdate)
{
IFeature feature = keyValuePair.Key;
IGeometry newGeometry = keyValuePair.Value;
GdbObjectMsg targetFeatureMsg =
ProtobufGdbUtils.ToGdbObjectMsg(
feature, newGeometry, feature.Class.ObjectClassID);
response.TargetFeaturesToUpdate.Add(targetFeatureMsg);
}
}
response.ResultHasMultiparts = result.ResultHasMultiparts;
return(response);
}
public void CanCreateGdbRowFromRealData()
{
IWorkspace ws = TestUtils.OpenUserWorkspaceOracle();
const string tlmStrasse = "TOPGIS_TLM.TLM_STRASSE";
IFeatureClass realFeatureClass = DatasetUtils.OpenFeatureClass(ws, tlmStrasse);
var objectClassMsg = ProtobufGdbUtils.ToObjectClassMsg(realFeatureClass, true);
GdbTableContainer gdbTableContainer =
ProtobufConversionUtils.CreateGdbTableContainer(
new[] { objectClassMsg }, null, out GdbWorkspace _);
var virtualFeatureClass = (IFeatureClass)gdbTableContainer.OpenTable(tlmStrasse);
Assert.AreEqual(realFeatureClass.ObjectClassID, virtualFeatureClass.ObjectClassID);
Assert.AreEqual(DatasetUtils.GetName(realFeatureClass),
DatasetUtils.GetName(virtualFeatureClass));
Assert.AreEqual(realFeatureClass.AliasName, virtualFeatureClass.AliasName);
Assert.AreEqual(realFeatureClass.ShapeFieldName, virtualFeatureClass.ShapeFieldName);
Assert.AreEqual(realFeatureClass.OIDFieldName, virtualFeatureClass.OIDFieldName);
Assert.AreEqual(realFeatureClass.FeatureClassID, virtualFeatureClass.FeatureClassID);
Assert.AreEqual(realFeatureClass.FeatureType, virtualFeatureClass.FeatureType);
Assert.AreEqual(realFeatureClass.HasOID, virtualFeatureClass.HasOID);
Assert.AreEqual(realFeatureClass.ShapeType, virtualFeatureClass.ShapeType);
Assert.AreEqual(realFeatureClass.ShapeFieldName, virtualFeatureClass.ShapeFieldName);
Assert.IsTrue(SpatialReferenceUtils.AreEqual(
DatasetUtils.GetSpatialReference(realFeatureClass),
DatasetUtils.GetSpatialReference(virtualFeatureClass), true, true));
Assert.AreEqual(realFeatureClass.Fields.FieldCount,
virtualFeatureClass.Fields.FieldCount);
int featureCount = 0;
foreach (var feature in GdbQueryUtils.GetFeatures(realFeatureClass, true))
{
// TODO: Move all this to separate project referenced by both client and server
GdbObjectMsg gdbObjectMsg =
ProtobufGdbUtils.ToGdbObjectMsg(feature, false, true);
GdbRow gdbRow =
ProtobufConversionUtils.FromGdbObjectMsg(
gdbObjectMsg, (ITable)realFeatureClass);
for (int i = 0; i < feature.Fields.FieldCount; i++)
{
object expected = feature.get_Value(i);
object actual = gdbRow.get_Value(i);
if (expected is IGeometry shape)
{
Assert.IsTrue(
GeometryUtils.AreEqual(shape, (IGeometry)actual));
}
else
{
Assert.AreEqual(expected, actual);
}
}
featureCount++;
if (featureCount > 250)
{
return;
}
}
}
