protected override ISourceClass CreateSourceClassCore(
GdbTableIdentity identity,
IAttributeReader attributeReader,
WorkListStatusSchema statusSchema)
{
return(new SelectionSourceClass(identity));
}
private void ProcessInserts(GdbTableIdentity tableId, List <long> oids,
ICollection <long> invalidItems)
{
var filter = new QueryFilter {
ObjectIDs = oids
};
foreach (IWorkItem item in Repository.GetItems(tableId, filter).ToList())
{
if (_rowMap.ContainsKey(item.Proxy))
{
// todo daro: warn
}
_items.Add(item);
_rowMap.Add(item.Proxy, item);
if (!HasCurrentItem)
{
SetCurrentItem(item);
// todo daro: WorkListChanged > invalidate map
}
UpdateExtent(item.Extent);
invalidItems.Add(item.OID);
}
}
// todo daro: rafactor SelectionItemRepository(Dictionary<IWorkspaceContext, GdbTableIdentity>, Dictionary<GdbTableIdentity, List<long>>)
public SelectionItemRepository(Dictionary <Geodatabase, List <Table> > tablesByGeodatabase,
Dictionary <Table, List <long> > selection,
IRepository stateRepository) : base(tablesByGeodatabase, stateRepository)
{
foreach (var pair in selection)
{
var id = new GdbTableIdentity(pair.Key);
ISourceClass sourceClass = GeodatabaseBySourceClasses.Keys.FirstOrDefault(s => s.Uses(id));
if (sourceClass == null)
{
// todo daro: assert?
continue;
}
if (_oidsBySource.TryGetValue(sourceClass, out List <long> ids))
{
// todo daro: assert?
// should never be the case because values of SourceClassesByGeodatabase should be distinct
ids.AddRange(ids);
}
else
{
_oidsBySource.Add(sourceClass, pair.Value);
}
}
}
public void Update([NotNull] IWorkItem item)
{
TState state = Lookup(item);
if (state == null)
{
// todo daro: revise
// create new state if it doesn't exist
state = CreateState(item);
_states.Add(state);
}
GdbTableIdentity table = item.Proxy.Table;
GdbWorkspaceIdentity workspace = table.Workspace;
if (_workspaces.TryGetValue(workspace, out SimpleSet <GdbTableIdentity> tables))
{
tables.TryAdd(table);
}
else
{
_workspaces.Add(workspace, new SimpleSet <GdbTableIdentity> {
table
});
}
state.Visited = item.Visited;
UpdateCore(state, item);
}
public static Dictionary <Table, List <long> > GetDistinctSelectionByTable(
[NotNull] IEnumerable <BasicFeatureLayer> layers)
{
var result = new Dictionary <Table, SimpleSet <long> >();
var distinctTableIds = new Dictionary <GdbTableIdentity, Table>();
foreach (BasicFeatureLayer layer in layers.Where(HasSelection))
{
IReadOnlyList <long> selection = layer.GetSelection().GetObjectIDs();
Table table = layer.GetTable();
var tableId = new GdbTableIdentity(table);
if (!distinctTableIds.ContainsKey(tableId))
{
distinctTableIds.Add(tableId, table);
result.Add(table, new SimpleSet <long>(selection));
}
else
{
Table distinctTable = distinctTableIds[tableId];
SimpleSet <long> ids = result[distinctTable];
foreach (long id in selection)
{
ids.TryAdd(id);
}
}
}
return(result.ToDictionary(pair => pair.Key, pair => pair.Value.ToList()));
}
protected override ISourceClass CreateSourceClassCore(
GdbTableIdentity identity,
IAttributeReader attributeReader,
WorkListStatusSchema statusSchema)
{
Assert.ArgumentNotNull(attributeReader, nameof(attributeReader));
Assert.ArgumentNotNull(statusSchema, nameof(statusSchema));
return(new DatabaseSourceClass(identity, statusSchema, attributeReader));
}
public DatabaseSourceClass(GdbTableIdentity identity,
[NotNull] WorkListStatusSchema statusSchema,
[NotNull] IAttributeReader attributeReader) : base(identity)
{
Assert.ArgumentNotNull(statusSchema, nameof(statusSchema));
Assert.ArgumentNotNull(attributeReader, nameof(attributeReader));
_statusSchema = statusSchema;
AttributeReader = attributeReader;
}
//[CanBeNull]
//protected Table OpenFeatureClass2([NotNull] ISourceClass sourceClass)
//{
// return GeodatabaseBySourceClasses.TryGetValue(sourceClass, out Geodatabase gdb)
// ? sourceClass.OpenFeatureClass(gdb)
// : null;
//}
private ISourceClass CreateSourceClass(GdbTableIdentity identity, FeatureClassDefinition definition)
{
IAttributeReader attributeReader = CreateAttributeReaderCore(definition);
WorkListStatusSchema statusSchema = CreateStatusSchemaCore(definition);
ISourceClass sourceClass = CreateSourceClassCore(identity, attributeReader, statusSchema);
return(sourceClass);
}
public async Task SetStatus(IWorkItem item, WorkItemStatus status)
{
GdbTableIdentity tableId = item.Proxy.Table;
ISourceClass source = GeodatabaseBySourceClasses.Keys.FirstOrDefault(s => s.Uses(tableId));
Assert.NotNull(source);
// todo daro: read / restore item again from db? restore pattern in case of failure?
await SetStatusCoreAsync(item, source);
}
private static List <Table> GetDistinctTables(XmlWorkListWorkspace workspace, Geodatabase geodatabase)
{
var distinctTables = new Dictionary <GdbTableIdentity, Table>();
foreach (XmlTableReference tableReference in workspace.Tables)
{
var table = geodatabase.OpenDataset <Table>(tableReference.Name);
var id = new GdbTableIdentity(table);
if (!distinctTables.ContainsKey(id))
{
distinctTables.Add(id, table);
}
}
return(distinctTables.Values.ToList());
}
private void ProcessUpdates(GdbTableIdentity tableId, IEnumerable <long> oids,
ICollection <long> invalidItems)
{
foreach (long oid in oids)
{
var rowId = new GdbRowIdentity(oid, tableId);
if (_rowMap.TryGetValue(rowId, out IWorkItem item))
{
Refresh(item);
_invalidRows.Add(rowId);
invalidItems.Add(item.OID);
}
}
}
public bool Equals(BasicFeatureLayer x, BasicFeatureLayer y)
{
if (ReferenceEquals(x, y))
{
// both null or reference equal
return(true);
}
if (x == null || y == null)
{
return(false);
}
var left = new GdbTableIdentity(x.GetTable());
var right = new GdbTableIdentity(y.GetTable());
return(Equals(left, right));
}
public bool Equals(Table x, Table y)
{
if (ReferenceEquals(x, y))
{
// both null or reference equal
return(true);
}
if (x == null || y == null)
{
return(false);
}
var left = new GdbTableIdentity(x);
var right = new GdbTableIdentity(y);
return(Equals(left, right));
}
private void RegisterDatasets(Dictionary <Geodatabase, List <Table> > tablesByGeodatabase)
{
foreach (var pair in tablesByGeodatabase)
{
Geodatabase geodatabase = pair.Key;
var definitions = geodatabase.GetDefinitions <FeatureClassDefinition>().ToLookup(d => d.GetName());
foreach (Table table in pair.Value)
{
var identity = new GdbTableIdentity(table);
FeatureClassDefinition definition = definitions[identity.Name].FirstOrDefault();
ISourceClass sourceClass = CreateSourceClass(identity, definition);
GeodatabaseBySourceClasses.Add(sourceClass, geodatabase);
}
}
}
public IEnumerable <IWorkItem> GetItems(GdbTableIdentity tableId, QueryFilter filter, bool recycle = true)
{
foreach (ISourceClass sourceClass in GeodatabaseBySourceClasses.Keys.Where(source => source.Uses(tableId)))
{
int count = 0;
Stopwatch watch = _msg.DebugStartTiming();
foreach (Row row in GetRowsCore(sourceClass, filter, recycle))
{
count += 1;
yield return(CreateWorkItemCore(row, sourceClass));
}
_msg.DebugStopTiming(watch, $"{nameof(GetItems)}() {sourceClass.Name}: {count} items");
}
// return GeodatabaseBySourceClasses.Keys.Where(source => source.Uses(table)).SelectMany(sourceClass => GetItemsCore(sourceClass, filter, recycle));
}
public void Refresh(IWorkItem item)
{
GdbTableIdentity tableId = item.Proxy.Table;
// todo daro: log message
ISourceClass source = GeodatabaseBySourceClasses.Keys.FirstOrDefault(sc => sc.Uses(tableId));
Assert.NotNull(source);
Row row = GetRow(source, item.Proxy.ObjectId);
Assert.NotNull(row);
if (row is Feature feature)
{
((WorkItem)item).SetGeometryFromFeature(feature);
}
RefreshCore(item, source, row);
}
// todo daro: Is SDK type Table the right type?
public void ProcessChanges(Dictionary <Table, List <long> > inserts,
Dictionary <Table, List <long> > deletes,
Dictionary <Table, List <long> > updates)
{
int capacity = inserts.Values.Sum(list => list.Count) +
deletes.Values.Sum(list => list.Count) +
updates.Values.Sum(list => list.Count);
var invalidItems = new List <long>(capacity);
foreach (var insert in inserts)
{
var tableId = new GdbTableIdentity(insert.Key);
List <long> oids = insert.Value;
ProcessInserts(tableId, oids, invalidItems);
}
foreach (var delete in deletes)
{
var tableId = new GdbTableIdentity(delete.Key);
List <long> oids = delete.Value;
ProcessDeletes(tableId, oids, invalidItems);
}
foreach (var update in updates)
{
var tableId = new GdbTableIdentity(update.Key);
List <long> oids = update.Value;
ProcessUpdates(tableId, oids, invalidItems);
// does not work because ObjectIDs = (IReadOnlyList<long>) modify.Value (oids) are the
// ObjectIds of source feature not the work item OIDs.
//IEnumerable<IWorkItem> workItems = GetItems(filter);
}
OnWorkListChanged(null, invalidItems);
}
private void ProcessDeletes(GdbTableIdentity tableId, List <long> oids,
ICollection <long> invalidItems)
{
foreach (long oid in oids)
{
// todo daro: refactor, simplify
var rowId = new GdbRowIdentity(oid, tableId);
if (HasCurrentItem && Current != null && Current.Proxy.Equals(rowId))
{
ClearCurrentItem(Current);
}
if (_rowMap.TryGetValue(rowId, out IWorkItem item))
{
RemoveWorkItem(item);
invalidItems.Add(item.OID);
}
}
// todo daro: update work list extent?
Extent = GetExtentFromItems(_items);
}
public IEnumerable <IWorkItem> GetItems(GdbTableIdentity tableId, QueryFilter filter,
bool recycle = true)
{
throw new NotImplementedException();
}
public SelectionSourceClass(GdbTableIdentity identity) : base(identity)
{
}
protected SourceClass(GdbTableIdentity identity)
{
_identity = identity;
}
public bool Contains(GdbTableIdentity proxy)
{
return(Equals(proxy.Workspace, Workspace));
}
protected abstract ISourceClass CreateSourceClassCore(GdbTableIdentity identity,
[CanBeNull] IAttributeReader attributeReader,
[CanBeNull] WorkListStatusSchema statusSchema);
public bool Uses(GdbTableIdentity table)
{
return(_identity.Equals(table));
}