/// <summary>
/// Constructor for the sub grid retriever helper
/// </summary>
/// <param name="siteModel">The project this sub gris is being retrieved from</param>
/// <param name="gridDataType">The type of client grid data sub grids to be returned by this retriever</param>
/// <param name="storageProxy">The Ignite storage proxy to be used when requesting data from the persistent store</param>
/// <param name="filter">The TRex spatial and attribute filtering description for the request</param>
/// <param name="filterAnnex">An annex of data related to cell by cell filtering where the attributes related to that cell may change from cell to cell</param>
/// <param name="hasOverrideSpatialCellRestriction">The spatially selected cells are masked by a rectangular restriction boundary</param>
/// <param name="overrideSpatialCellRestriction"></param>
/// <param name="prepareGridForCacheStorageIfNoSieving">The cell coordinate bounding box restricting cells involved in the request</param>
/// <param name="maxNumberOfPassesToReturn">The maximum number of passes in a cell in a sub grid that will be considered when processing the request</param>
/// <param name="areaControlSet">The skip/step area control set for selection of cells with sub grids for processing. Cells not identified by the control set will return null values.</param>
/// <param name="populationControl">The delegate responsible for populating events depended on for processing the request.</param>
/// <param name="pDExistenceMap">The production data existence map for the project the request relates to</param>
/// <param name="overrides">The set of overriding machine event values to use</param>
/// <param name="liftParams">The set of layer/lift analysis parameters to use</param>
public ProgressiveVolumesSubGridRetriever(ISiteModel siteModel,
GridDataType gridDataType,
IStorageProxy storageProxy,
ICombinedFilter filter,
ICellPassAttributeFilterProcessingAnnex filterAnnex,
bool hasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
bool prepareGridForCacheStorageIfNoSieving,
int maxNumberOfPassesToReturn,
AreaControlSet areaControlSet,
IFilteredValuePopulationControl populationControl,
ISubGridTreeBitMask pDExistenceMap,
IOverrideParameters overrides,
ILiftParameters liftParams)
: base(siteModel, gridDataType, filter, filterAnnex,
hasOverrideSpatialCellRestriction, overrideSpatialCellRestriction, prepareGridForCacheStorageIfNoSieving, maxNumberOfPassesToReturn,
storageProxy, areaControlSet, populationControl, pDExistenceMap, overrides, liftParams)
{
// Clear any time element from the supplied filter. Time constraints ar derived from the startDate and endDate parameters
filter.AttributeFilter.HasTimeFilter = false;
// Clear any instruction in the filter to extract the earliest value - this has no meaning in progressive calculations
filter.AttributeFilter.ReturnEarliestFilteredCellPass = false;
// Remove any first/last/highest/lowest aspect from the filter - this has no meaning in progressive calculations
filter.AttributeFilter.HasElevationTypeFilter = false;
// Remove any machine filtering - the intent here is to examine volume progression over time, machine breakdowns don't make sense at this point
filter.AttributeFilter.HasMachineFilter = false;
}
/// <summary>
/// Removes all the event elements for all machines within the site model
/// </summary>
private void RemovalAllMachineEvents(IStorageProxy storageProxy, bool exceptOverrideEvents)
{
foreach (var machine in _siteModel.Machines)
{
_siteModel.MachinesTargetValues[machine.InternalSiteModelMachineIndex]?.RemoveMachineEventsFromPersistentStore(storageProxy, exceptOverrideEvents);
}
}
/// <summary>
/// Remove the design list for a site model from the persistent store
/// </summary>
public bool Remove(Guid siteModelId, IStorageProxy storageProxy)
{
// First remove all the existence maps associated with the designs
var designs = Load(siteModelId);
designs.ForEach(x =>
{
FileSystemErrorStatus result;
var filename = BaseExistenceMapRequest.CacheKeyString(ExistenceMaps.Interfaces.Consts.EXISTENCE_MAP_DESIGN_DESCRIPTOR, x.ID);
if ((result = storageProxy.RemoveStreamFromPersistentStore(siteModelId, FileSystemStreamType.DesignTopologyExistenceMap, filename)) != FileSystemErrorStatus.OK)
{
_log.LogWarning($"Unable to remove existence map for design {x.ID}, filename = {filename}, with result: {result}");
}
});
// Then remove the designs list stream itself
var result = storageProxy.RemoveStreamFromPersistentStore(siteModelId, FileSystemStreamType.Designs, DESIGNS_STREAM_NAME);
if (result != FileSystemErrorStatus.OK)
{
_log.LogInformation($"Removing designs list from project {siteModelId} failed with error {result}");
}
return(result == FileSystemErrorStatus.OK);
}
/// <summary>
/// Removes all sub grid directory and segment information in the site model
/// </summary>
private bool RemoveAllSpatialCellPassData(IStorageProxy storageProxy)
{
var subGridRemovalSuccessful = true;
_siteModel.ExistenceMap.ScanAllSetBitsAsSubGridAddresses(address =>
{
var filename = ServerSubGridTree.GetLeafSubGridFullFileName(address);
var leaf = new ServerSubGridTreeLeaf(_siteModel.Grid, null, SubGridTreeConsts.SubGridTreeLevels, StorageMutability.Mutable)
{
OriginX = address.X,
OriginY = address.Y
};
leaf.LoadDirectoryFromFile(storageProxy, filename);
leaf.Directory.SegmentDirectory.ForEach(segmentInfo =>
{
var segmentFilename = ServerSubGridTree.GetLeafSubGridSegmentFullFileName(leaf.OriginAsCellAddress(), segmentInfo);
if (!leaf.RemoveSegmentFromStorage(storageProxy, segmentFilename, segmentInfo))
{
_log.LogError($"Failed to remove segment {segmentFilename} sub grid: {leaf.Moniker()}");
subGridRemovalSuccessful = false;
}
});
if (!leaf.RemoveDirectoryFromStorage(storageProxy, filename))
{
_log.LogError($"Failed to remove directory for server sub grid leaf: {leaf.Moniker()}");
subGridRemovalSuccessful = false;
}
});
return(subGridRemovalSuccessful);
}
public void TestThatCreateUpdateCommandReturnsSqlCommandForUpdate(bool hasDescription)
{
Guid identifier = Guid.NewGuid();
Guid householdIdentifier = Guid.NewGuid();
IHousehold householdMock = DomainObjectMockBuilder.BuildHouseholdMock(householdIdentifier);
int sortOrder = GetLegalSortOrder();
Guid storageTypeIdentifier = Guid.NewGuid();
IStorageType storageTypeMock = DomainObjectMockBuilder.BuildStorageTypeMock(storageTypeIdentifier);
int temperature = GetLegalTemperature(storageTypeMock.TemperatureRange);
DateTime creationTime = DateTime.Now;
string description = hasDescription ? _fixture.Create <string>() : null;
IStorageProxy sut = CreateSut(identifier, householdMock, sortOrder, storageTypeMock, temperature, creationTime, description);
Assert.That(sut, Is.Not.Null);
// ReSharper disable StringLiteralTypo
new DbCommandTestBuilder("UPDATE Storages SET HouseholdIdentifier=@householdIdentifier,SortOrder=@sortOrder,StorageTypeIdentifier=@storageTypeIdentifier,Descr=@descr,Temperature=@temperature,CreationTime=@creationTime WHERE StorageIdentifier=@storageIdentifier")
// ReSharper restore StringLiteralTypo
.AddCharDataParameter("@storageIdentifier", identifier)
.AddCharDataParameter("@householdIdentifier", householdIdentifier)
.AddTinyIntDataParameter("@sortOrder", sortOrder, 4)
.AddCharDataParameter("@storageTypeIdentifier", storageTypeIdentifier)
// ReSharper disable StringLiteralTypo
.AddVarCharDataParameter("@descr", description, 2048, true)
// ReSharper restore StringLiteralTypo
.AddTinyIntDataParameter("@temperature", temperature, 4)
.AddDateTimeDataParameter("@creationTime", creationTime.ToUniversalTime())
.Build()
.Run(sut.CreateUpdateCommand());
}
public SubGridTreeIterator(IStorageProxy storageProxy,
bool subGridsInServerDiskStore)
{
// FDataStoreCache = ADataStoreCache;
_subGridsInServerDiskStore = subGridsInServerDiskStore;
_storageProxy = storageProxy;
}
/// <summary>
/// Cleaves all dirty segments requiring cleaving within the given sub grid
/// </summary>
public void PerformSegmentCleaving(IStorageProxy storageProxyForSubGridSegments, IServerLeafSubGrid subGrid, int subGridSegmentPassCountLimit = 0)
{
var iterator = new SubGridSegmentIterator(subGrid, storageProxyForSubGridSegments)
{
IterationDirection = IterationDirection.Forwards,
ReturnDirtyOnly = true,
RetrieveAllPasses = true
};
var origin = new SubGridCellAddress(subGrid.OriginX, subGrid.OriginY);
if (!iterator.MoveToFirstSubGridSegment())
{
return;
}
do
{
var segment = iterator.CurrentSubGridSegment;
var cleavedTimeRangeStart = segment.SegmentInfo.StartTime;
var cleavedTimeRangeEnd = segment.SegmentInfo.EndTime;
if (!segment.RequiresCleaving(out var totalPassCount, out var maximumPassCount))
{
continue;
}
if (subGrid.Cells.CleaveSegment(segment, NewSegmentsFromCleaving, PersistedClovenSegments, subGridSegmentPassCountLimit))
{
iterator.SegmentListExtended();
if (_segmentCleavingOperationsToLog)
{
_log.LogInformation(
$"Info: Performed cleave on segment ({cleavedTimeRangeStart}-{cleavedTimeRangeEnd}) of sub grid {ServerSubGridTree.GetLeafSubGridFullFileName(origin)}. TotalPassCount = {totalPassCount} MaximumPassCount = {maximumPassCount}");
}
}
else
{
// The segment cleave failed. While this is not a serious problem (as the sub grid will be
// cleaved at some point in the future when it is modified again via tag file processing etc)
// it will be noted in the log.
_log.LogWarning(
$"Cleave on segment ({cleavedTimeRangeStart}-{cleavedTimeRangeEnd}) of sub grid {ServerSubGridTree.GetLeafSubGridFullFileName(origin)} failed. TotalPassCount = {totalPassCount} MaximumPassCount = {maximumPassCount}");
}
if (_segmentCleavingOperationsToLog)
{
if (segment.RequiresCleaving(out totalPassCount, out maximumPassCount))
{
_log.LogWarning(
$"Cleave on segment ({cleavedTimeRangeStart}-{cleavedTimeRangeEnd}) of sub grid {subGrid.Moniker()} failed to reduce cell pass count below maximums (max passes = {totalPassCount}/{subGridSegmentPassCountLimit}, per cell = {maximumPassCount}/{_subGridMaxSegmentCellPassesLimit})");
}
}
} while (iterator.MoveToNextSubGridSegment());
}
/*
* /// <summary>
* /// The version number to stamp spatial data elements with generated by this worker.
* /// Commented out pending requirement for request based consistency requiring a sub grid version map
* /// </summary>
* //private long EpochVersion { get; } = DateTime.UtcNow.Ticks;
*/
/// <summary>
/// Constructor the initializes state ready for integration. Not that two storage proxies are provided - one to store sub grid dictionary/headers, and one to store segments
/// so that they can be committed to the persistent store safely (ie: segments first, then headers).
/// </summary>
/// <param name="source">The sub grid tree from which information is being integrated</param>
/// <param name="siteModel">The site model representing the target sub grid tree</param>
/// <param name="target">The sub grid tree into which the data from the source sub grid tree is integrated</param>
/// <param name="storageProxySubGrids">The storage proxy providing storage semantics for persisting integration results relating to sub grids (specifically the header/dictionary representation)</param>
/// <param name="storageProxySubGridSegments">The storage proxy providing storage semantics for persisting integration results relating to sub grid segments</param>
public SubGridIntegrator(IServerSubGridTree source, ISiteModel siteModel, IServerSubGridTree target,
IStorageProxy storageProxySubGrids, IStorageProxy storageProxySubGridSegments)
{
_source = source;
_siteModel = siteModel;
_target = target;
_storageProxySubGrids = storageProxySubGrids;
_storageProxySubGridSegments = storageProxySubGridSegments;
}
public void TestThatDeleteRelationsThrowsArgumentNullExceptionIfDataProviderIsNull()
{
IStorageProxy sut = CreateSut();
Assert.That(sut, Is.Not.Null);
ArgumentNullException result = Assert.Throws <ArgumentNullException>(() => sut.DeleteRelations(null));
TestHelper.AssertArgumentNullExceptionIsValid(result, "dataProvider");
}
public void TestThatMapDataThrowsArgumentNullExceptionIfDataReaderIsNull()
{
IStorageProxy sut = CreateSut();
Assert.That(sut, Is.Not.Null);
ArgumentNullException result = Assert.Throws <ArgumentNullException>(() => sut.MapData(null, CreateFoodWasteDataProvider()));
TestHelper.AssertArgumentNullExceptionIsValid(result, "dataReader");
}
public void TestThatCreateThrowsArgumentNullExceptionIfColumnNameCollectionIsNull()
{
IStorageProxy sut = CreateSut();
Assert.That(sut, Is.Not.Null);
ArgumentNullException result = Assert.Throws <ArgumentNullException>(() => sut.Create(CreateMySqlDataReader(), CreateFoodWasteDataProvider(), null));
TestHelper.AssertArgumentNullExceptionIsValid(result, "columnNameCollection");
}
public void TestThatCreateThrowsArgumentNullExceptionIfDataProviderIsNull()
{
IStorageProxy sut = CreateSut();
Assert.That(sut, Is.Not.Null);
ArgumentNullException result = Assert.Throws <ArgumentNullException>(() => sut.Create(CreateMySqlDataReader(), null, _fixture.Create <string>(), _fixture.Create <string>(), _fixture.Create <string>()));
TestHelper.AssertArgumentNullExceptionIsValid(result, "dataProvider");
}
/// <summary>
/// Remove the alignments list for a site model from the persistent store
/// </summary>
public bool Remove(Guid siteModelId, IStorageProxy storageProxy)
{
var result = storageProxy.RemoveStreamFromPersistentStore(siteModelId, FileSystemStreamType.Designs, ALIGNMENTS_STREAM_NAME);
if (result != FileSystemErrorStatus.OK)
{
_log.LogInformation($"Removing alignments list from project {siteModelId} failed with error {result}");
}
return(result == FileSystemErrorStatus.OK);
}
public bool SaveToFile(IStorageProxy storage,
string FileName,
out FileSystemErrorStatus FSError)
{
bool Result;
FSError = FileSystemErrorStatus.OK;
CalculateElevationRangeOfPasses();
if (_segmentCleavingOperationsToLog || _itemsPersistedViaDataPersistorToLog)
{
PassesData.CalculateTotalPasses(out int TotalPasses, out _, out int MaxPasses);
if (_segmentCleavingOperationsToLog && TotalPasses > _subGridSegmentPassCountLimit)
{
Log.LogDebug($"Saving segment {FileName} with {TotalPasses} cell passes (max:{MaxPasses}) which violates the maximum number of cell passes within a segment ({_subGridSegmentPassCountLimit})");
}
if (_itemsPersistedViaDataPersistorToLog)
{
Log.LogDebug($"Saving segment {FileName} with {TotalPasses} cell passes (max:{MaxPasses})");
}
}
using (var stream = RecyclableMemoryStreamManagerHelper.Manager.GetStream())
{
using (var writer = new BinaryWriter(stream, Encoding.UTF8, true))
{
Result = Write(writer);
}
// Log.LogInformation($"Segment persistence stream (uncompressed) for segment {FileName} containing {PassesData.SegmentPassCount} cell passes using storage proxy {storage.Mutability} is {MStream.Length} bytes (average = {MStream.Length / (1.0 * PassesData.SegmentPassCount)})");
if (Result)
{
FSError = storage.WriteSpatialStreamToPersistentStore(
Owner.Owner.ID,
FileName,
Owner.OriginX, Owner.OriginY,
SegmentInfo.StartTime.Ticks,
SegmentInfo.EndTime.Ticks,
SegmentInfo.Version,
FileSystemStreamType.SubGridSegment,
stream,
this);
Result = FSError == FileSystemErrorStatus.OK;
}
}
return(Result);
}
public void TestThatMapRelationsDoesNotCloneDataProvider()
{
IStorageProxy sut = CreateSut();
Assert.That(sut, Is.Not.Null);
IFoodWasteDataProvider dataProvider = CreateFoodWasteDataProvider();
sut.MapRelations(dataProvider);
dataProvider.AssertWasNotCalled(m => m.Clone());
}
public void TestThatDeleteRelationsThrowsIntranetRepositoryExceptionWhenIdentifierIsNull()
{
IStorageProxy sut = CreateSut();
Assert.That(sut, Is.Not.Null);
Assert.That(sut.Identifier, Is.Null);
Assert.That(sut.Identifier.HasValue, Is.False);
IntranetRepositoryException result = Assert.Throws <IntranetRepositoryException>(() => sut.DeleteRelations(CreateFoodWasteDataProvider()));
TestHelper.AssertIntranetRepositoryExceptionIsValid(result, ExceptionMessage.IllegalValue, sut.Identifier, "Identifier");
}
/// <summary>
/// Loads the content of the machines list from the persistent store. If there is no item in the persistent store containing
/// machines for this site model them return an empty list.
/// </summary>
public void LoadFromPersistentStore(IStorageProxy storageProxy)
{
storageProxy.ReadStreamFromPersistentStore(DataModelID, MACHINES_LIST_STREAM_NAME, FileSystemStreamType.Machines, out MemoryStream MS);
if (MS == null)
{
return;
}
using (MS)
{
this.FromStream(MS);
}
}
/// <summary>
/// Loads the content of the proofing run list from the persistent store. If there is no item in the persistent store containing
/// proofing runs for this site model them return an empty list.
/// </summary>
public void LoadFromPersistentStore(Guid projectUid, IStorageProxy storageProxy)
{
storageProxy.ReadStreamFromPersistentStore(projectUid, LIST_STREAM_NAME, FileSystemStreamType.MachineDesigns, out var ms);
if (ms == null)
{
return;
}
using (ms)
{
this.FromStream(ms);
}
}
/// <summary>
/// Loads the content of the proofing run list from the persistent store. If there is no item in the persistent store containing
/// proofing runs for this site model them return an empty list.
/// </summary>
public void LoadFromPersistentStore(IStorageProxy storageProxy)
{
storageProxy.ReadStreamFromPersistentStore(DataModelID, PROOFING_RUN_LIST_STREAM_NAME, FileSystemStreamType.ProofingRuns, out MemoryStream ms);
if (ms == null)
{
return;
}
using (ms)
{
this.FromStream(ms);
}
}
public void TestThatConstructorInitializeStorageProxy()
{
IStorageProxy sut = CreateSut();
Assert.That(sut, Is.Not.Null);
Assert.That(sut.Identifier, Is.Null);
Assert.That(sut.Identifier.HasValue, Is.False);
Assert.That(sut.Household, Is.Null);
Assert.That(sut.SortOrder, Is.EqualTo(default(int)));
Assert.That(sut.StorageType, Is.Null);
Assert.That(sut.Description, Is.Null);
Assert.That(sut.Temperature, Is.EqualTo(default(int)));
Assert.That(sut.CreationTime, Is.EqualTo(default(DateTime)));
}
public void TestThatCreateGetCommandReturnsSqlQueryForId()
{
Guid identifier = Guid.NewGuid();
IStorageProxy sut = CreateSut(identifier);
Assert.That(sut, Is.Not.Null);
// ReSharper disable StringLiteralTypo
new DbCommandTestBuilder("SELECT s.StorageIdentifier,s.HouseholdIdentifier,s.SortOrder,s.StorageTypeIdentifier,s.Descr,s.Temperature,s.CreationTime,h.Name AS HouseholdName,h.Descr AS HouseholdDescr,h.CreationTime AS HouseholdCreationTime,st.SortOrder AS StorageTypeSortOrder,st.Temperature AS StorageTypeTemperature,st.TemperatureRangeStartValue AS StorageTypeTemperatureRangeStartValue,st.TemperatureRangeEndValue AS StorageTypeTemperatureRangeEndValue,st.Creatable AS StorageTypeCreatable,st.Editable AS StorageTypeEditable,st.Deletable AS StorageTypeDeletable FROM Storages AS s INNER JOIN Households AS h ON h.HouseholdIdentifier=s.HouseholdIdentifier INNER JOIN StorageTypes AS st ON st.StorageTypeIdentifier=s.StorageTypeIdentifier WHERE s.StorageIdentifier=@storageIdentifier")
// ReSharper restore StringLiteralTypo
.AddCharDataParameter("@storageIdentifier", identifier)
.Build()
.Run(sut.CreateGetCommand());
}
public void TestThatUniqueIdGetterThrowsIntranetRepositoryExceptionWhenStorageHasNoIdentifier()
{
IStorageProxy sut = CreateSut();
Assert.That(sut, Is.Not.Null);
Assert.That(sut.Identifier, Is.Null);
Assert.That(sut.Identifier.HasValue, Is.False);
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
IntranetRepositoryException result = Assert.Throws <IntranetRepositoryException>(() => sut.UniqueId.ToUpper());
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
TestHelper.AssertIntranetRepositoryExceptionIsValid(result, ExceptionMessage.IllegalValue, sut.Identifier, "Identifier");
}
public void TestThatUniqueIdGetterGetsUniqueIdentificationForStorageProxy()
{
Guid identifier = Guid.NewGuid();
IStorageProxy sut = CreateSut(identifier);
Assert.That(sut, Is.Not.Null);
Assert.That(sut.Identifier, Is.Not.Null);
string uniqueId = sut.UniqueId;
Assert.That(uniqueId, Is.Not.Null);
Assert.That(uniqueId, Is.Not.Empty);
Assert.That(uniqueId, Is.EqualTo(identifier.ToString("D").ToUpper()));
}
public void TestThatCreateDeleteCommandReturnsSqlCommandForDelete()
{
Guid identifier = Guid.NewGuid();
IStorageProxy sut = CreateSut(identifier);
Assert.That(sut, Is.Not.Null);
// ReSharper disable StringLiteralTypo
new DbCommandTestBuilder("DELETE FROM Storages WHERE StorageIdentifier=@storageIdentifier")
// ReSharper restore StringLiteralTypo
.AddCharDataParameter("@storageIdentifier", identifier)
.Build()
.Run(sut.CreateDeleteCommand());
}
/// <summary>
/// Constructor for the sub grid retriever helper
/// </summary>
/// <param name="siteModel">The project this sub gris is being retrieved from</param>
/// <param name="gridDataType">The type of client grid data sub grids to be returned by this retriever</param>
/// <param name="storageProxy">The Ignite storage proxy to be used when requesting data from the persistent store</param>
/// <param name="filter">The TRex spatial and attribute filtering description for the request</param>
/// <param name="filterAnnex">An annex of data related to cell by cell filtering where the attributes related to that cell may change from cell to cell</param>
/// <param name="hasOverrideSpatialCellRestriction">The spatially selected cells are masked by a rectangular restriction boundary</param>
/// <param name="overrideSpatialCellRestriction"></param>
/// <param name="prepareGridForCacheStorageIfNoSieving">The cell coordinate bounding box restricting cells involved in the request</param>
/// <param name="maxNumberOfPassesToReturn">The maximum number of passes in a cell in a sub grid that will be considered when processing the request</param>
/// <param name="areaControlSet">The skip/step area control set for selection of cells with sub grids for processing. Cells not identified by the control set will return null values.</param>
/// <param name="populationControl">The delegate responsible for populating events depended on for processing the request.</param>
/// <param name="pDExistenceMap">The production data existence map for the project the request relates to</param>
/// <param name="overrides">The set of overriding machine event values to use</param>
/// <param name="liftParams">The set of layer/lift analysis parameters to use</param>
public SubGridRetriever(ISiteModel siteModel,
GridDataType gridDataType,
IStorageProxy storageProxy,
ICombinedFilter filter,
ICellPassAttributeFilterProcessingAnnex filterAnnex,
bool hasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
bool prepareGridForCacheStorageIfNoSieving,
int maxNumberOfPassesToReturn,
AreaControlSet areaControlSet,
IFilteredValuePopulationControl populationControl,
ISubGridTreeBitMask pDExistenceMap,
IOverrideParameters overrides,
ILiftParameters liftParams)
: base(siteModel, gridDataType, filter, filterAnnex,
hasOverrideSpatialCellRestriction, overrideSpatialCellRestriction, prepareGridForCacheStorageIfNoSieving, maxNumberOfPassesToReturn,
storageProxy, areaControlSet, populationControl, pDExistenceMap, overrides, liftParams)
{
}
protected SubGridRetrieverBase(ISiteModel siteModel,
GridDataType gridDataType,
ICombinedFilter filter,
ICellPassAttributeFilterProcessingAnnex filterAnnex,
bool hasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
bool prepareGridForCacheStorageIfNoSieving,
int maxNumberOfPassesToReturn,
IStorageProxy storageProxy,
AreaControlSet areaControlSet,
IFilteredValuePopulationControl populationControl,
ISubGridTreeBitMask pDExistenceMap,
IOverrideParameters overrides,
ILiftParameters liftParams)
{
_segmentIterator = null;
_cellPassIterator = null;
_siteModel = siteModel;
_gridDataType = gridDataType;
_filter = filter;
_filterAnnex = filterAnnex;
_hasOverrideSpatialCellRestriction = hasOverrideSpatialCellRestriction;
_overrideSpatialCellRestriction = overrideSpatialCellRestriction;
_prepareGridForCacheStorageIfNoSieving = prepareGridForCacheStorageIfNoSieving;
_maxNumberOfPassesToReturn = maxNumberOfPassesToReturn;
_storageProxy = storageProxy;
_populationControl = populationControl;
_areaControlSet = areaControlSet;
_pdExistenceMap = pDExistenceMap;
_overrides = overrides;
_liftParams = liftParams;
// Create and configure the assignment context which is used to contain a filtered pass and
// its attendant machine events and target values prior to assignment to the client sub grid.
_assignmentContext = new FilteredValueAssignmentContext {
Overrides = overrides, LiftParams = liftParams
};
_filter.AttributeFilter.SiteModel = siteModel;
_canUseGlobalLatestCells = _filter.AttributeFilter.LastRecordedCellPassSatisfiesFilter;
}
/// <summary>
/// Sets a reference to a storage proxy that proxies the immutable data store for this mutable data store
/// </summary>
/// <param name="immutableProxy"></param>
public void SetImmutableStorageProxy(IStorageProxy immutableProxy)
{
if (Mutability != StorageMutability.Mutable)
{
throw new ArgumentException("Non-mutable storage proxy may not accept an immutable storage proxy reference");
}
if (immutableProxy == null)
{
throw new ArgumentException("Null immutable storage proxy reference supplied to SetImmutableStorageProxy()");
}
if (immutableProxy.Mutability != StorageMutability.Immutable)
{
throw new ArgumentException("Immutable storage proxy reference is not marked with Immutable mutability");
}
ImmutableProxy = immutableProxy;
}
/// <summary>
/// Remove the surveyed surface list for a site model from the persistent store
/// </summary>
public bool Remove(Guid siteModelUid, IStorageProxy storageProxy)
{
// First remove all the existence maps associated with the surveyed surfaces
foreach (var surveyedSurface in Load(siteModelUid))
{
FileSystemErrorStatus fsResult;
var filename = BaseExistenceMapRequest.CacheKeyString(ExistenceMaps.Interfaces.Consts.EXISTENCE_SURVEYED_SURFACE_DESCRIPTOR, surveyedSurface.ID);
if ((fsResult = storageProxy.RemoveStreamFromPersistentStore(siteModelUid, FileSystemStreamType.DesignTopologyExistenceMap, filename)) != FileSystemErrorStatus.OK)
{
_log.LogWarning($"Unable to remove existence map for surveyed surface {surveyedSurface.ID}, filename = {filename}, in project {siteModelUid} with result: {fsResult}");
}
}
// Then remove the surveyed surface list stream itself
var result = storageProxy.RemoveStreamFromPersistentStore(siteModelUid, FileSystemStreamType.Designs, SURVEYED_SURFACE_STREAM_NAME);
if (result != FileSystemErrorStatus.OK)
{
_log.LogInformation($"Removing surveyed surfaces list from project {siteModelUid} failed with error {result}");
}
return(result == FileSystemErrorStatus.OK);
}
public BestPerformerUpdater(IStorageProxy proxy)
{
_proxy = proxy;
}
public ISubGridRetriever Instance(ISubGridsRequestArgument subGridsRequestArgument,
ISiteModel siteModel,
GridDataType gridDataType,
IStorageProxy storageProxy,
ICombinedFilter filter,
ICellPassAttributeFilterProcessingAnnex filterAnnex,
bool hasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
int maxNumberOfPassesToReturn,
AreaControlSet areaControlSet,
IFilteredValuePopulationControl populationControl,
ISubGridTreeBitMask pdExistenceMap,
ITRexSpatialMemoryCacheContext[] subGridCacheContexts,
IOverrideParameters overrides,
ILiftParameters liftParams)
{
if (gridDataType == GridDataType.ProgressiveVolumes)
{
var retriever = new ProgressiveVolumesSubGridRetriever(siteModel,
gridDataType,
storageProxy,
filter,
filterAnnex,
hasOverrideSpatialCellRestriction,
overrideSpatialCellRestriction,
subGridCacheContexts != null,
maxNumberOfPassesToReturn,
areaControlSet,
populationControl,
pdExistenceMap,
overrides,
liftParams);
if (subGridsRequestArgument is IProgressiveVolumesSubGridsRequestArgument argument)
{
retriever.StartDate = argument.StartDate;
retriever.EndDate = argument.EndDate;
retriever.Interval = argument.Interval;
}
else
{
throw new ArgumentException($"Argument passed to sub grid retriever factory for progressive volumes retriever construction is not an expected type: {subGridsRequestArgument.GetType()}");
}
return(retriever);
}
else
{
var retriever = new SubGridRetriever(siteModel,
gridDataType,
storageProxy,
filter,
filterAnnex,
hasOverrideSpatialCellRestriction,
overrideSpatialCellRestriction,
subGridCacheContexts != null,
maxNumberOfPassesToReturn,
areaControlSet,
populationControl,
pdExistenceMap,
overrides,
liftParams);
return(retriever);
}
}
public BestPerformerUpdater(IStorageProxy proxy)
{
_proxy = proxy;
}
