protected virtual bool PushQueueItem(Stack <OrderIterationType> generationOrder,
                                             Type type, long newItemsCount)
        {
            if (newItemsCount < 1)
            {
                return(false);
            }

            EntityContext entityContext = _entityContexts[type];

            entityContext.EntityProgress.NextIterationCount =
                entityContext.EntityProgress.CurrentCount + newItemsCount;

            OrderIterationType order = generationOrder
                                       .FirstOrDefault(x => x.EntityType == type);

            if (order == null)
            {
                generationOrder.Push(new OrderIterationType
                {
                    EntityType    = type,
                    GenerateCount = newItemsCount
                });
                return(true);
            }

            if (order.GenerateCount < newItemsCount)
            {
                order.GenerateCount = newItemsCount;
                return(true);
            }

            return(false);
        }
        //Update counters
        public virtual void UpdateCounters(
            EntityContext entityContext, IList generatedEntities, bool isFlushRequired)
        {
            OrderIterationType next = _queue.Peek();

            if (entityContext.Type != next.EntityType)
            {
                throw new ArgumentException($"Type {entityContext.Type.Name} provided in {nameof(UpdateCounters)} does not match the latest action Type {next.EntityType}");
            }

            next.GenerateCount -= generatedEntities.Count;

            if (entityContext.Description.InsertToPersistentStorageBeforeUse)
            {
                //for entities that generate Id on database, will generate as much as possible before flushing.
                //the number to generate will be determined by IFlushTrigger.
                EntityProgress progress    = entityContext.EntityProgress;
                bool           isCompleted = progress.CurrentCount >= progress.TargetCount;
                if (isFlushRequired || isCompleted)
                {
                    _queue.Pop();
                }
                return;
            }

            if (next.GenerateCount <= 0)
            {
                _queue.Pop();
            }
        }
        //Get next action from queue
        public virtual ICommand GetNextCommand()
        {
            if (_queue == null ||
                _queue.Count == 0)
            {
                EntityContext nextNode = _nextNodeFinder.FindNextNode();
                if (nextNode == null)
                {
                    return(new FinishCommand(_generatorSetup, _entityContexts));
                }

                _queue = CreateNextQueue(nextNode);
            }

            OrderIterationType next = _queue.Peek();

            return(new GenerateEntitiesCommand(_entityContexts[next.EntityType], _generatorSetup, _entityContexts));
        }