public void Before()
{
var pool = Helper.CreatePool();
var group = pool.GetGroup(Matcher.AllOf(new [] { CP.ComponentA }));
_collector = group.CreateCollector();
}
/**
* SE:I --> satisfy by orders PuOP
*/
public EntityCollector Satisfy(Demand demand, Quantity demandedQuantity)
{
EntityCollector entityCollector = new EntityCollector();
M_Article article = demand.GetArticle();
DueTime dueTime = demand.GetStartTimeBackward();
if (article.ToBuild)
{
throw new MrpRunException(
"You try to create a purchaseOrderPart for a articleToBuild.");
}
// currently only one businessPartner per article TODO: This could be changing
M_ArticleToBusinessPartner articleToBusinessPartner =
_dbMasterDataCache.M_ArticleToBusinessPartnerGetAllByArticleId(article.GetId())[0];
M_BusinessPartner businessPartner =
_dbMasterDataCache.M_BusinessPartnerGetById(new Id(articleToBusinessPartner
.BusinessPartnerId));
T_PurchaseOrder purchaseOrder = new T_PurchaseOrder();
// [Name],[DueTime],[BusinessPartnerId]
purchaseOrder.DueTime = dueTime.GetValue();
purchaseOrder.BusinessPartner = businessPartner;
purchaseOrder.Name = $"PurchaseOrder{article.Name} for " +
$"businessPartner {purchaseOrder.BusinessPartner.Id}";
// init a new purchaseOderPart
T_PurchaseOrderPart tPurchaseOrderPart = new T_PurchaseOrderPart();
// [PurchaseOrderId],[ArticleId],[Quantity],[State],[ProviderId]
tPurchaseOrderPart.PurchaseOrder = purchaseOrder;
tPurchaseOrderPart.PurchaseOrderId = purchaseOrder.Id;
tPurchaseOrderPart.Article = article;
tPurchaseOrderPart.ArticleId = article.Id;
tPurchaseOrderPart.Quantity =
CalculateQuantity(articleToBusinessPartner, demandedQuantity) *
articleToBusinessPartner
.PackSize;
if (tPurchaseOrderPart.Quantity < demandedQuantity.GetValue())
{
throw new MrpRunException("You cannot purchase less than you need!");
}
tPurchaseOrderPart.State = State.Created;
PurchaseOrderPart purchaseOrderPart =
new PurchaseOrderPart(tPurchaseOrderPart, null);
T_DemandToProvider demandToProvider = new T_DemandToProvider()
{
DemandId = demand.GetId().GetValue(),
ProviderId = purchaseOrderPart.GetId().GetValue(),
Quantity = demandedQuantity.GetValue()
};
entityCollector.Add(purchaseOrderPart);
entityCollector.Add(demandToProvider);
return(entityCollector);
}
public void Before()
{
var pool = Helper.CreatePool();
var group = pool.GetGroup(Matcher.AllOf(new [] { CP.ComponentA }));
_collector = group.CreateCollector();
for (int i = 0; i < 1000; i++)
{
var e = pool.CreateEntity();
e.AddComponent(CP.ComponentA, new ComponentA());
}
}
public EntityCollector CreateDependingDemands(Provider provider)
{
EntityCollector entityCollector = new EntityCollector();
Demands dependingDemands = CreateProductionOrderBoms(provider.GetArticle(), provider,
provider.GetQuantity());
entityCollector.AddAll(dependingDemands);
foreach (var dependingDemand in dependingDemands)
{
T_ProviderToDemand providerToDemand = new T_ProviderToDemand(provider.GetId(),
dependingDemand.GetId(), dependingDemand.GetQuantity());
entityCollector.Add(providerToDemand);
}
return(entityCollector);
}
public EntityCollectorTest()
{
Cursor = new Mock <ICursor>();
Cursor
.Setup(x => x.Get(Name))
.ReturnsAsync(LastCursor);
Processor = new Mock <IEntityCollectorProcessor>();
Processor
.Setup(x => x.Name)
.Returns(Name);
Collector = new EntityCollector(
Cursor.Object,
Processor.Object);
}
/**
* COP or PrOB --> satisfy by SE:W
*/
public EntityCollector Satisfy(Demand demand, Quantity demandedQuantity)
{
EntityCollector entityCollector = new EntityCollector();
Provider stockProvider = CreateStockExchangeProvider(demand.GetArticle(),
demand.GetStartTimeBackward(), demandedQuantity);
entityCollector.Add(stockProvider);
T_DemandToProvider demandToProvider =
new T_DemandToProvider(demand.GetId(), stockProvider.GetId(), demandedQuantity);
entityCollector.Add(demandToProvider);
return(entityCollector);
}
private EntityCollector MaterialRequirementsPlanningForOneDemand(Demand demand,
IProviderManager providerManager)
{
EntityCollector entityCollector = new EntityCollector();
EntityCollector response = providerManager.Satisfy(demand, demand.GetQuantity());
entityCollector.AddAll(response);
response = providerManager.CreateDependingDemands(entityCollector.GetProviders());
entityCollector.AddAll(response);
if (entityCollector.IsSatisfied(demand) == false)
{
throw new MrpRunException($"'{demand}' was NOT satisfied: remaining is " +
$"{entityCollector.GetRemainingQuantity(demand)}");
}
return(entityCollector);
}
public EntityCollector CreateDependingDemands(Providers providers)
{
EntityCollector entityCollector = new EntityCollector();
foreach (var provider in providers)
{
EntityCollector response;
if (provider.GetType() == typeof(ProductionOrder))
{
response = _productionManager.CreateDependingDemands(provider);
entityCollector.AddAll(response);
}
else if (provider.GetType() == typeof(StockExchangeProvider))
{
response = _stockManager.CreateDependingDemands(provider);
entityCollector.AddAll(response);
}
}
return(entityCollector);
}
public void AddAllFrom(EntityCollector otherEntityCollector)
{
if (otherEntityCollector.GetDemands().Any())
{
DemandsAddAll(otherEntityCollector.GetDemands());
}
if (otherEntityCollector.GetProviders().Any())
{
ProvidersAddAll(otherEntityCollector.GetProviders());
}
if (otherEntityCollector.GetDemandToProviderTable().Any())
{
_demandToProviderTable.AddAll(otherEntityCollector.GetDemandToProviderTable());
}
if (otherEntityCollector.GetLinkDemandAndProviderTable().Any())
{
_providerToDemandTable.AddAll(otherEntityCollector.GetLinkDemandAndProviderTable());
}
}
public void StartMrp1()
{
// init
int MAX_DEMANDS_IN_QUEUE = 100000;
FastPriorityQueue <DemandQueueNode> demandQueue =
new FastPriorityQueue <DemandQueueNode>(MAX_DEMANDS_IN_QUEUE);
IProviderManager providerManager = new ProviderManager();
foreach (var demand in dbDemands)
{
demandQueue.Enqueue(new DemandQueueNode(demand), demand.GetStartTimeBackward().GetValue());
}
EntityCollector allCreatedEntities = new EntityCollector();
while (demandQueue.Count != 0)
{
DemandQueueNode firstDemandInQueue = demandQueue.Dequeue();
EntityCollector response =
MaterialRequirementsPlanningForOneDemand(firstDemandInQueue.GetDemand(), providerManager);
allCreatedEntities.AddAll(response);
foreach (var demand in response.GetDemands())
{
demandQueue.Enqueue(new DemandQueueNode(demand),
demand.GetStartTimeBackward().GetValue());
}
}
// write data to _dbTransactionData
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.GetDbTransactionData();
dbTransactionData.AddAllFrom(allCreatedEntities);
// End of MaterialRequirementsPlanning
}
/**
* SE:I --> satisfy by orders PrOBom
*/
public EntityCollector Satisfy(Demand demand, Quantity demandedQuantity)
{
if (demand.GetArticle().ToBuild == false)
{
throw new MrpRunException("Must be a build article.");
}
EntityCollector entityCollector = CreateProductionOrder(demand, demandedQuantity);
foreach (var provider in entityCollector.GetProviders())
{
T_DemandToProvider demandToProvider = new T_DemandToProvider()
{
DemandId = demand.GetId().GetValue(),
ProviderId = provider.GetId().GetValue(),
Quantity = provider.GetQuantity().GetValue()
};
entityCollector.Add(demandToProvider);
}
return(entityCollector);
}
public EntityCollector CreateProductionOrder(Demand demand, Quantity quantity)
{
if (quantity == null || quantity.GetValue() == null)
{
throw new MrpRunException("Quantity is not set.");
}
T_ProductionOrder tProductionOrder = new T_ProductionOrder();
// [ArticleId],[Quantity],[Name],[DueTime],[ProviderId]
tProductionOrder.DueTime = demand.GetStartTimeBackward().GetValue();
tProductionOrder.Article = demand.GetArticle();
tProductionOrder.ArticleId = demand.GetArticle().Id;
tProductionOrder.Name = $"ProductionOrder for Demand {demand.GetArticle()}";
tProductionOrder.Quantity = quantity.GetValue().GetValueOrDefault();
ProductionOrder productionOrder =
new ProductionOrder(tProductionOrder);
EntityCollector entityCollector = new EntityCollector();
entityCollector.Add(productionOrder);
return(entityCollector);
}
public EntityCollectorSubSystemSpy(EntityCollector collector)
{
_collector = collector;
}
void when_created()
{
ReactiveSystem reactiveSystem = null;
ReactiveSubSystemSpy subSystem = null;
before = () => {
_pool = new Pool(CID.TotalComponents);
};
context["OnEntityAdded"] = () => {
before = () => {
subSystem = new ReactiveSubSystemSpy(_matcherAB, GroupEventType.OnEntityAdded);
reactiveSystem = new ReactiveSystem(_pool, subSystem);
};
it["does not execute its subsystem when no entities were collected"] = () => {
reactiveSystem.Execute();
assertEntities(subSystem, null);
};
it["executes when triggered"] = () => {
var e = createEntityAB();
reactiveSystem.Execute();
assertEntities(subSystem, e);
};
it["executes only once when triggered"] = () => {
var e = createEntityAB();
reactiveSystem.Execute();
reactiveSystem.Execute();
assertEntities(subSystem, e);
};
it["retains and releases collected entities"] = () => {
var e = createEntityAB();
var retainCount = e.retainCount;
reactiveSystem.Execute();
retainCount.should_be(3); // retained by pool, group and entity collector
e.retainCount.should_be(2); // retained by pool and group
};
it["collects changed entities in execute"] = () => {
var e = createEntityAB();
subSystem.executeAction = entities => {
entities[0].ReplaceComponentA(Component.A);
};
reactiveSystem.Execute();
reactiveSystem.Execute();
assertEntities(subSystem, e, 2);
};
it["collects created entities in execute"] = () => {
var e1 = createEntityAB();
Entity e2 = null;
subSystem.executeAction = entities => {
if (e2 == null)
{
e2 = createEntityAB();
}
};
reactiveSystem.Execute();
assertEntities(subSystem, e1);
reactiveSystem.Execute();
assertEntities(subSystem, e2, 2);
};
it["doesn't execute when not triggered"] = () => {
_pool.CreateEntity().AddComponentA();
reactiveSystem.Execute();
assertEntities(subSystem, null);
};
it["deactivates and will not trigger"] = () => {
reactiveSystem.Deactivate();
createEntityAB();
reactiveSystem.Execute();
assertEntities(subSystem, null);
};
it["activates and will trigger again"] = () => {
reactiveSystem.Deactivate();
reactiveSystem.Activate();
var e = createEntityAB();
reactiveSystem.Execute();
assertEntities(subSystem, e);
};
it["clears"] = () => {
createEntityAB();
reactiveSystem.Clear();
reactiveSystem.Execute();
assertEntities(subSystem, null);
};
it["can ToString"] = () => {
reactiveSystem.ToString().should_be("ReactiveSystem(ReactiveSubSystemSpy)");
};
};
context["OnEntityRemoved"] = () => {
before = () => {
subSystem = new ReactiveSubSystemSpy(_matcherAB, GroupEventType.OnEntityRemoved);
reactiveSystem = new ReactiveSystem(_pool, subSystem);
};
it["executes when triggered"] = () => {
var e = createEntityAB()
.RemoveComponentA();
reactiveSystem.Execute();
assertEntities(subSystem, e);
};
it["executes only once when triggered"] = () => {
var e = createEntityAB()
.RemoveComponentA();
reactiveSystem.Execute();
reactiveSystem.Execute();
assertEntities(subSystem, e);
};
it["doesn't execute when not triggered"] = () => {
createEntityAB()
.AddComponentC()
.RemoveComponentC();
reactiveSystem.Execute();
assertEntities(subSystem, null);
};
it["retains entities until execute completed"] = () => {
var e = createEntityAB();
var didExecute = 0;
subSystem.executeAction = entities => {
didExecute += 1;
entities[0].retainCount.should_be(1);
};
_pool.DestroyEntity(e);
reactiveSystem.Execute();
didExecute.should_be(1);
e.retainCount.should_be(0);
};
};
context["OnEntityAddedOrRemoved"] = () => {
before = () => {
subSystem = new ReactiveSubSystemSpy(_matcherAB, GroupEventType.OnEntityAddedOrRemoved);
reactiveSystem = new ReactiveSystem(_pool, subSystem);
};
it["executes when added"] = () => {
var e = createEntityAB();
reactiveSystem.Execute();
assertEntities(subSystem, e);
};
it["executes when removed"] = () => {
var e = createEntityAB();
reactiveSystem.Execute();
e.RemoveComponentA();
reactiveSystem.Execute();
assertEntities(subSystem, e, 2);
};
};
context["MultiReactiveSystem"] = () => {
MultiReactiveSubSystemSpy multiSubSystem = null;
before = () => {
var triggers = new [] {
Matcher.AllOf(CID.ComponentA).OnEntityAdded(),
Matcher.AllOf(CID.ComponentB).OnEntityRemoved()
};
multiSubSystem = new MultiReactiveSubSystemSpy(triggers);
reactiveSystem = new ReactiveSystem(_pool, multiSubSystem);
};
it["executes when any trigger is triggered"] = () => {
var eA = _pool.CreateEntity().AddComponentA();
var eB = _pool.CreateEntity().AddComponentB();
reactiveSystem.Execute();
assertEntities(multiSubSystem, eA);
eB.RemoveComponentB();
reactiveSystem.Execute();
assertEntities(multiSubSystem, eB, 2);
};
};
context["EntityCollectorSystem"] = () => {
EntityCollectorSubSystemSpy entityCollectorSubSystem = null;
Pool pool1 = null;
Pool pool2 = null;
before = () => {
pool1 = new Pool(CID.TotalComponents);
pool2 = new Pool(CID.TotalComponents);
var groupA = pool1.GetGroup(Matcher.AllOf(CID.ComponentA));
var groupB = pool2.GetGroup(Matcher.AllOf(CID.ComponentB));
var groups = new [] { groupA, groupB };
var eventTypes = new [] {
GroupEventType.OnEntityAdded,
GroupEventType.OnEntityRemoved
};
var entityCollector = new EntityCollector(groups, eventTypes);
entityCollectorSubSystem = new EntityCollectorSubSystemSpy(entityCollector);
reactiveSystem = new ReactiveSystem(entityCollectorSubSystem);
};
it["executes when a triggered by entityCollector"] = () => {
var eA1 = pool1.CreateEntity().AddComponentA();
pool2.CreateEntity().AddComponentA();
var eB1 = pool1.CreateEntity().AddComponentB();
var eB2 = pool2.CreateEntity().AddComponentB();
reactiveSystem.Execute();
assertEntities(entityCollectorSubSystem, eA1);
eB1.RemoveComponentB();
eB2.RemoveComponentB();
reactiveSystem.Execute();
assertEntities(entityCollectorSubSystem, eB2, 2);
};
};
context["ensure / exlude"] = () => {
Entity eAB = null;
Entity eAC = null;
Entity eABC = null;
context["ensure components"] = () => {
context["reactive system"] = () => {
ReactiveEnsureSubSystemSpy ensureSubSystem = null;
before = () => {
ensureSubSystem = new ReactiveEnsureSubSystemSpy(_matcherAB, GroupEventType.OnEntityAdded, Matcher.AllOf(
CID.ComponentA,
CID.ComponentB,
CID.ComponentC
));
reactiveSystem = new ReactiveSystem(_pool, ensureSubSystem);
eAB = createEntityAB();
eABC = createEntityABC();
};
it["only passes in entities matching required matcher"] = () => {
reactiveSystem.Execute();
assertEntities(ensureSubSystem, eABC);
};
it["retains included entities until execute completed"] = () => {
var retainCount = eABC.retainCount;
var didExecute = 0;
ensureSubSystem.executeAction = entities => {
didExecute += 1;
eABC.retainCount.should_be(3);
};
reactiveSystem.Execute();
didExecute.should_be(1);
retainCount.should_be(3); // retained by pool, group and entity collector
eABC.retainCount.should_be(2); // retained by pool and group
};
it["doesn't retain not included entities until execute completed"] = () => {
var retainCount = eAB.retainCount;
var didExecute = 0;
ensureSubSystem.executeAction = entity => {
didExecute += 1;
eAB.retainCount.should_be(2);
};
reactiveSystem.Execute();
didExecute.should_be(1);
retainCount.should_be(3); // retained by pool, group and entity collector
eAB.retainCount.should_be(2); // retained by pool and group
eABC.retainCount.should_be(2); // retained by pool and group
};
it["doesn't call execute when no entities left after filtering"] = () => {
ensureSubSystem = new ReactiveEnsureSubSystemSpy(_matcherAB, GroupEventType.OnEntityAdded, Matcher.AllOf(
CID.ComponentA,
CID.ComponentB,
CID.ComponentC,
CID.ComponentD
));
reactiveSystem = new ReactiveSystem(_pool, ensureSubSystem);
createEntityAB();
createEntityABC();
reactiveSystem.Execute();
assertEntities(ensureSubSystem, null);
};
};
context["multi reactive system"] = () => {
it["only passes in entities matching required matcher"] = () => {
var triggers = new [] {
Matcher.AllOf(CID.ComponentA).OnEntityAdded(),
Matcher.AllOf(CID.ComponentB).OnEntityAdded()
};
var ensure = Matcher.AllOf(
CID.ComponentA,
CID.ComponentB,
CID.ComponentC
);
var ensureSubSystem = new MultiReactiveEnsureSubSystemSpy(triggers, ensure);
reactiveSystem = new ReactiveSystem(_pool, ensureSubSystem);
createEntityAB();
eABC = createEntityABC();
reactiveSystem.Execute();
assertEntities(ensureSubSystem, eABC);
};
};
};
context["exlude components"] = () => {
context["reactive system"] = () => {
ReactiveExcludeSubSystemSpy excludeSubSystem = null;
before = () => {
excludeSubSystem = new ReactiveExcludeSubSystemSpy(_matcherAB,
GroupEventType.OnEntityAdded,
Matcher.AllOf(CID.ComponentC)
);
reactiveSystem = new ReactiveSystem(_pool, excludeSubSystem);
eAB = createEntityAB();
eABC = createEntityABC();
};
it["only passes in entities not matching matcher"] = () => {
reactiveSystem.Execute();
assertEntities(excludeSubSystem, eAB);
};
it["retains included entities until execute completed"] = () => {
var didExecute = 0;
excludeSubSystem.executeAction = entities => {
didExecute += 1;
eAB.retainCount.should_be(3);
};
reactiveSystem.Execute();
didExecute.should_be(1);
};
it["doesn't retain not included entities until execute completed"] = () => {
var didExecute = 0;
excludeSubSystem.executeAction = entities => {
didExecute += 1;
eABC.retainCount.should_be(2);
};
reactiveSystem.Execute();
didExecute.should_be(1);
};
};
context["multi reactive system"] = () => {
it["only passes in entities not matching required matcher"] = () => {
var triggers = new [] {
Matcher.AllOf(CID.ComponentA).OnEntityAdded(),
Matcher.AllOf(CID.ComponentB).OnEntityAdded()
};
var exclude = Matcher.AllOf(CID.ComponentC);
var excludeSubSystem = new MultiReactiveExcludeSubSystemSpy(triggers, exclude);
reactiveSystem = new ReactiveSystem(_pool, excludeSubSystem);
eAB = createEntityAB();
createEntityABC();
reactiveSystem.Execute();
assertEntities(excludeSubSystem, eAB);
};
};
};
context["ensure and exlude mix"] = () => {
ReactiveEnsureExcludeSubSystemSpy ensureExcludeSystem = null;
before = () => {
ensureExcludeSystem = new ReactiveEnsureExcludeSubSystemSpy(_matcherAB, GroupEventType.OnEntityAdded,
Matcher.AllOf(CID.ComponentA, CID.ComponentB),
Matcher.AllOf(CID.ComponentC)
);
reactiveSystem = new ReactiveSystem(_pool, ensureExcludeSystem);
eAB = createEntityAB();
eAC = createEntityAC();
eABC = createEntityABC();
};
it["only passes in correct entities"] = () => {
reactiveSystem.Execute();
assertEntities(ensureExcludeSystem, eAB);
};
it["retains included entities until execute completed"] = () => {
var didExecute = 0;
ensureExcludeSystem.executeAction = entities => {
didExecute += 1;
eAB.retainCount.should_be(3);
};
reactiveSystem.Execute();
didExecute.should_be(1);
};
it["doesn't retain not included entities until execute completed"] = () => {
var didExecute = 0;
ensureExcludeSystem.executeAction = entities => {
didExecute += 1;
eAC.retainCount.should_be(1);
eABC.retainCount.should_be(2);
};
reactiveSystem.Execute();
didExecute.should_be(1);
};
};
};
context["IClearReactiveSystem"] = () => {
ClearReactiveSubSystemSpy clearSubSystem = null;
before = () => {
clearSubSystem = new ClearReactiveSubSystemSpy(_matcherAB, GroupEventType.OnEntityAdded);
reactiveSystem = new ReactiveSystem(_pool, clearSubSystem);
};
it["clears reactive system after execute when implementing IClearReactiveSystem"] = () => {
subSystem.executeAction = entities => {
entities[0].ReplaceComponentA(Component.A);
};
var e = createEntityAB();
reactiveSystem.Execute();
reactiveSystem.Execute();
assertEntities(clearSubSystem, e);
};
};
}
public void SetPools(Pools pools)
{
_groupObserver = new [] { pools.core, pools.bullets }
.CreateEntityCollector(Matcher.AllOf(CoreMatcher.View, CoreMatcher.Destroy));
}
public void SetPools(Pools pools)
{
_pools = new [] { pools.core, pools.bullets };
_groupObserver = _pools.CreateEntityCollector(Matcher.AnyOf(CoreMatcher.Destroy, CoreMatcher.OutOfScreen));
}
public void SetPools(Pools pools)
{
_groupObserver = new [] { pools.core, pools.bullets }
.CreateEntityCollector(CoreMatcher.Health);
}
void when_created()
{
Group groupA = null;
EntityCollector collectorA = null;
IMatcher matcherA = Matcher.AllOf(CID.ComponentA);
before = () => {
_pool = new Pool(CID.TotalComponents);
groupA = _pool.GetGroup(matcherA);
};
context["when observing with eventType OnEntityAdded"] = () => {
before = () => {
collectorA = new EntityCollector(groupA, GroupEventType.OnEntityAdded);
};
it["is empty when nothing happend"] = () => {
collectorA.collectedEntities.should_be_empty();
};
context["when entity collected"] = () => {
Entity e = null;
before = () => {
e = createEA();
};
it["returns collected entities"] = () => {
var entities = collectorA.collectedEntities;
entities.Count.should_be(1);
entities.should_contain(e);
};
it["only collects matching entities"] = () => {
createEB();
var entities = collectorA.collectedEntities;
entities.Count.should_be(1);
entities.should_contain(e);
};
it["collects entities only once"] = () => {
e.RemoveComponentA();
e.AddComponentA();
var entities = collectorA.collectedEntities;
entities.Count.should_be(1);
entities.should_contain(e);
};
it["clears collected entities on deactivation"] = () => {
collectorA.Deactivate();
collectorA.collectedEntities.should_be_empty();
};
it["doesn't collect entities when deactivated"] = () => {
collectorA.Deactivate();
createEA();
collectorA.collectedEntities.should_be_empty();
};
it["continues collecting when activated"] = () => {
collectorA.Deactivate();
createEA();
collectorA.Activate();
var e2 = createEA();
var entities = collectorA.collectedEntities;
entities.Count.should_be(1);
entities.should_contain(e2);
};
it["clears collected entities"] = () => {
collectorA.ClearCollectedEntities();
collectorA.collectedEntities.should_be_empty();
};
it["can ToString"] = () => {
collectorA.ToString().should_be("Collector(Group(AllOf(1)))");
};
};
context["reference counting"] = () => {
Entity e = null;
before = () => {
e = createEA();
};
it["retains entity even after destroy"] = () => {
var didExecute = 0;
e.OnEntityReleased += delegate { didExecute += 1; };
_pool.DestroyEntity(e);
e.retainCount.should_be(1);
didExecute.should_be(0);
};
it["releases entity when clearing collected entities"] = () => {
_pool.DestroyEntity(e);
collectorA.ClearCollectedEntities();
e.retainCount.should_be(0);
};
it["retains entities only once"] = () => {
e.ReplaceComponentA(new ComponentA());
_pool.DestroyEntity(e);
e.retainCount.should_be(1);
};
};
};
context["when observing with eventType OnEntityRemoved"] = () => {
before = () => {
collectorA = new EntityCollector(groupA, GroupEventType.OnEntityRemoved);
};
it["returns collected entities"] = () => {
var e = createEA();
collectorA.collectedEntities.should_be_empty();
e.RemoveComponentA();
var entities = collectorA.collectedEntities;
entities.Count.should_be(1);
entities.should_contain(e);
};
};
context["when observing with eventType OnEntityAddedOrRemoved"] = () => {
before = () => {
collectorA = new EntityCollector(groupA, GroupEventType.OnEntityAddedOrRemoved);
};
it["returns collected entities"] = () => {
var e = createEA();
var entities = collectorA.collectedEntities;
entities.Count.should_be(1);
entities.should_contain(e);
collectorA.ClearCollectedEntities();
e.RemoveComponentA();
entities = collectorA.collectedEntities;
entities.Count.should_be(1);
entities.should_contain(e);
};
};
context["when observing multiple groups"] = () => {
Group groupB = null;
before = () => {
groupB = _pool.GetGroup(Matcher.AllOf(CID.ComponentB));
};
it["throws when group count != eventType count"] = expect <EntityCollectorException>(() => {
collectorA = new EntityCollector(
new [] { groupA },
new [] {
GroupEventType.OnEntityAdded,
GroupEventType.OnEntityAdded
}
);
});
context["when observing with eventType OnEntityAdded"] = () => {
before = () => {
collectorA = new EntityCollector(
new [] { groupA, groupB },
new [] {
GroupEventType.OnEntityAdded,
GroupEventType.OnEntityAdded
}
);
};
it["returns collected entities"] = () => {
var eA = createEA();
var eB = createEB();
var entities = collectorA.collectedEntities;
entities.Count.should_be(2);
entities.should_contain(eA);
entities.should_contain(eB);
};
it["can ToString"] = () => {
collectorA.ToString().should_be("Collector(Group(AllOf(1)), Group(AllOf(2)))");
};
};
context["when observing with eventType OnEntityRemoved"] = () => {
before = () => {
collectorA = new EntityCollector(
new [] { groupA, groupB },
new [] {
GroupEventType.OnEntityRemoved,
GroupEventType.OnEntityRemoved
}
);
};
it["returns collected entities"] = () => {
var eA = createEA();
var eB = createEB();
collectorA.collectedEntities.should_be_empty();
eA.RemoveComponentA();
eB.RemoveComponentB();
var entities = collectorA.collectedEntities;
entities.Count.should_be(2);
entities.should_contain(eA);
entities.should_contain(eB);
};
};
context["when observing with eventType OnEntityAddedOrRemoved"] = () => {
before = () => {
collectorA = new EntityCollector(
new [] { groupA, groupB },
new [] {
GroupEventType.OnEntityAddedOrRemoved,
GroupEventType.OnEntityAddedOrRemoved
}
);
};
it["returns collected entities"] = () => {
var eA = createEA();
var eB = createEB();
var entities = collectorA.collectedEntities;
entities.Count.should_be(2);
entities.should_contain(eA);
entities.should_contain(eB);
collectorA.ClearCollectedEntities();
eA.RemoveComponentA();
eB.RemoveComponentB();
entities = collectorA.collectedEntities;
entities.Count.should_be(2);
entities.should_contain(eA);
entities.should_contain(eB);
};
};
context["when observing with mixed eventTypes"] = () => {
before = () => {
collectorA = new EntityCollector(
new [] { groupA, groupB },
new [] {
GroupEventType.OnEntityAdded,
GroupEventType.OnEntityRemoved
}
);
};
it["returns collected entities"] = () => {
var eA = createEA();
var eB = createEB();
var entities = collectorA.collectedEntities;
entities.Count.should_be(1);
entities.should_contain(eA);
collectorA.ClearCollectedEntities();
eA.RemoveComponentA();
eB.RemoveComponentB();
entities = collectorA.collectedEntities;
entities.Count.should_be(1);
entities.should_contain(eB);
};
};
};
}
public EntityCollector CreateDependingDemands(Provider provider)
{
if (provider.GetQuantity().IsNull())
{
return(null);
}
if (provider.GetType() != typeof(StockExchangeProvider))
{
throw new MrpRunException("This can only be called for StockExchangeProviders");
}
// try to provide by existing demand
// collects stockExchangeDemands, providerToDemands
EntityCollector entityCollector =
_openDemandManager.SatisfyProviderByOpenDemand(provider, provider.GetQuantity());
if (entityCollector == null)
{
entityCollector = new EntityCollector();
}
Quantity remainingQuantity = entityCollector.GetRemainingQuantity(provider);
if (remainingQuantity.IsGreaterThan(Quantity.Zero()))
{
LotSize.Impl.LotSize lotSizes =
new LotSize.Impl.LotSize(remainingQuantity, provider.GetArticleId());
bool isLastIteration = false;
foreach (var lotSize in lotSizes.GetLotSizes())
{
if (isLastIteration || remainingQuantity.IsNegative() ||
remainingQuantity.IsNull())
{
throw new MrpRunException("This is one iteration too many.");
}
Demand stockExchangeDemand =
StockExchangeDemand.CreateStockExchangeStockDemand(provider.GetArticleId(),
provider.GetStartTimeBackward(), lotSize);
entityCollector.Add(stockExchangeDemand);
// 3 cases
Quantity quantityOfNewCreatedDemandToReserve;
if (remainingQuantity.IsGreaterThan(lotSize))
{
quantityOfNewCreatedDemandToReserve = lotSize;
}
else if (remainingQuantity.Equals(lotSize))
{
// last iteration
isLastIteration = true;
quantityOfNewCreatedDemandToReserve = lotSize;
}
else
{
// last iteration, remaining < lotsize
isLastIteration = true;
quantityOfNewCreatedDemandToReserve = new Quantity(remainingQuantity);
// remember created demand as openDemand
_openDemandManager.AddDemand(stockExchangeDemand,
quantityOfNewCreatedDemandToReserve);
}
remainingQuantity.DecrementBy(lotSize);
if (quantityOfNewCreatedDemandToReserve.IsNegative() ||
quantityOfNewCreatedDemandToReserve.IsNull())
{
throw new MrpRunException(
$"quantityOfNewCreatedDemandToReserve cannot be negative or null: " +
$"{quantityOfNewCreatedDemandToReserve}");
}
T_ProviderToDemand providerToDemand = new T_ProviderToDemand(provider.GetId(),
stockExchangeDemand.GetId(), quantityOfNewCreatedDemandToReserve);
entityCollector.Add(providerToDemand);
}
}
return(entityCollector);
}
/**
* aka ReserveQuantityOfExistingDemand or satisfyByAlreadyExistingDemand
*/
public EntityCollector SatisfyProviderByOpenDemand(Provider provider,
Quantity demandedQuantity)
{
if (_openDemands.AnyOpenProvider(provider.GetArticle()))
{
EntityCollector entityCollector = new EntityCollector();
// ths is needed, because openDemands will be removed once they are consumed
List <OpenNode <Demand> > copyOfOpenDemands = new List <OpenNode <Demand> >();
copyOfOpenDemands.AddRange(_openDemands.GetOpenProvider(provider.GetArticle()));
Quantity remainingQuantity = new Quantity(demandedQuantity);
bool isLastIteration = false;
foreach (var openDemand in copyOfOpenDemands)
{
if (isLastIteration || remainingQuantity.IsNegative() ||
remainingQuantity.IsNull())
{
throw new MrpRunException("This is one iteration too many.");
}
if (openDemand != null && provider.GetStartTimeBackward()
.IsGreaterThanOrEqualTo(openDemand.GetOpenNode().GetStartTimeBackward()))
{
// 3 cases
Quantity quantityOfOpenDemandToReserve;
if (remainingQuantity.IsGreaterThan(openDemand.GetOpenQuantity()))
{
quantityOfOpenDemandToReserve = openDemand.GetOpenQuantity();
_openDemands.Remove(openDemand);
}
else if (remainingQuantity.Equals(openDemand.GetOpenQuantity()))
{
// last iteration
isLastIteration = true;
quantityOfOpenDemandToReserve = openDemand.GetOpenQuantity();
_openDemands.Remove(openDemand);
}
else
{
// last iteration, remaining < openQuantity
isLastIteration = true;
quantityOfOpenDemandToReserve = new Quantity(remainingQuantity);
// adapt openDemand
openDemand.GetOpenQuantity().DecrementBy(remainingQuantity);
}
remainingQuantity.DecrementBy(quantityOfOpenDemandToReserve);
T_ProviderToDemand providerToDemand = new T_ProviderToDemand()
{
ProviderId = provider.GetId().GetValue(),
DemandId = openDemand.GetOpenNode().GetId().GetValue(),
Quantity = quantityOfOpenDemandToReserve.GetValue()
};
entityCollector.Add(providerToDemand);
if (remainingQuantity.IsNull() || remainingQuantity.IsNegative())
{
break;
}
}
}
return(entityCollector);
}
else
{
return(null);
}
}
