public GridEventManager(ISetting setting, IGrid grid, IGroupFactory groupFactory)
{
_grid = grid;
_groupFactory = groupFactory;
_setting = setting;
}
public void Initialize(ISetting setting, IGroupFactory groupFactory)
{
_setting = setting;
_groupFactory = groupFactory;
SetState(GridStates.GameOver);
if (_setting.GetGameText(GameTextType.GameMessageCenter) == null)
{
_gameTextCenter = NullGameText.Instance;
}
else
{
_gameTextCenter = _setting.GetGameText(GameTextType.GameMessageCenter);
}
_cpuManager = new CPUManager(this, _setting);
// initialize highscore if it is a player game.
if (_setting.IsPlayer)
{
_highScoreManager = new HighScoreManager();
}
if (_highScoreManager != null)
{
DisplayStartMessageAndHighScore();
}
}
public ReadyForNextGroupState(ISetting setting, IGrid grid, IGroupFactory groupFactory, OnDeleteEndEventHandler onDeleteEndEvent)
{
_setting = setting;
_grid = grid;
_groupFactory = groupFactory;
_onDeleteEndEvent = onDeleteEndEvent;
}
public GridEventManager(ISetting setting, IGrid grid, IGroupFactory groupFactory)
{
_grid = grid;
_groupFactory = groupFactory;
_setting = setting;
}
public ReadyForNextGroupState(ISetting setting, IGrid grid, IGroupFactory groupFactory, OnDeleteEndEventHandler onDeleteEndEvent)
{
_setting = setting;
_grid = grid;
_groupFactory = groupFactory;
_onDeleteEndEvent = onDeleteEndEvent;
}
public GroupService(IGroupFactory groupFactory, IEfRepository <Group> groupRepository,
IUnitOfWork unitOfWork, IUserService userService)
{
this.groupFactory = groupFactory;
this.groupRepository = groupRepository;
this.unitOfWork = unitOfWork;
}
public void InitializeFactoriesAndSetting()
{
//blockViewSpawner = Substitute.For<IBlockViewSpawner>();
blockFactory = new BlockFactory(blockViewSpawner);
groupFactory = new GroupFactory(blockFactory);
setting = TestSetting.Get();
}
public void InitializeFactoriesAndSetting()
{
//blockViewSpawner = Substitute.For<IBlockViewSpawner>();
blockFactory = new BlockFactory(blockViewSpawner);
groupFactory = new GroupFactory(blockFactory);
setting = TestSetting.Get();
}
public Engine(IData data, IInputReader reader, IOutputWriter writer, IWarEffectFactory warFactory, IAttackTypeFactory attackFactory, IGroupFactory groupFactory)
{
this.data = data;
this.reader = reader;
this.writer = writer;
this.warFactory = warFactory;
this.attackTypeFectory = attackFactory;
this.groupFactory = groupFactory;
}
public CreateGroupViewModel(IGroupService groupService,
IGroupFactory groupFactory,
IFrameNavigationService navigationService,
IUserService userService) : base(navigationService)
{
_groupService = groupService;
_groupFactory = groupFactory;
_userService = userService;
}
public virtual GroupCollection <T> Perform(
IReadOnlyCollection <T> items,
int level,
Group <T> parent)
{
GroupDescriptorCollection groupDescriptors = this.index.CollectionView.GroupDescriptors;
if (level >= groupDescriptors.Count)
{
return(GroupCollection <T> .Empty);
}
IGroupFactory <T> groupFactory = this.index.CollectionView.GroupFactory;
GroupCollection <T> cachedGroups = this.GetCachedGroups(items, level);
if (!GroupBuilder <T> .IsValid(level, groupDescriptors))
{
cachedGroups?.Dispose();
return(groupFactory.CreateCollection((IList <Group <T> >)GroupBuilder <T> .Empty));
}
IComparer <Group <T> > comparer = Activator.CreateInstance(this.Comparer.GetType()) as IComparer <Group <T> > ?? this.Comparer;
if (comparer is GroupComparer <T> )
{
((GroupComparer <T>)comparer).Directions = this.GetComparerDirections(level);
}
AvlTree <Group <T> > avlTree1 = new AvlTree <Group <T> >(comparer);
AvlTree <Group <T> > avlTree2 = new AvlTree <Group <T> >((IComparer <Group <T> >) new GroupComparer <T>(this.GetComparerDirections(level)));
foreach (T key1 in !this.CollectionView.CanPage || level != 0 || !this.CollectionView.PagingBeforeGrouping ? (IEnumerable <T>)items : (IEnumerable <T>) this.index.GetItemsOnPage(this.CollectionView.PageIndex))
{
object key2 = this.GroupPredicate(key1, level);
Group <T> group1 = (Group <T>) new DataItemGroup <T>(key2);
Group <T> group2 = avlTree2.Find(group1);
if (group2 == null)
{
group2 = this.GetGroup(cachedGroups, group1, parent, key2, level);
avlTree2.Add(group2);
}
group2.Items.Add(key1);
if (this.itemGroupsCache.ContainsKey(key1))
{
this.itemGroupsCache[key1] = group2;
}
else
{
this.itemGroupsCache.Add(key1, group2);
}
}
for (int index = 0; index < avlTree2.Count; ++index)
{
avlTree1.Add(avlTree2[index]);
}
cachedGroups?.Dispose();
return(groupFactory.CreateCollection((IList <Group <T> >)avlTree1));
}
private static GroupingResults GenerateBottomLevelsFromSourceParallel(ParallelState state)
{
HashSet <object>[] uniqueFilterItems;
List <object> items;
SortAndFilterItems(state, out uniqueFilterItems, out items);
if (!state.HasDescriptions)
{
IGroupFactory groupFactory = state.ValueProvider.GetGroupFactory();
Group rowRootGroup = CreateGrandTotal(groupFactory);
rowRootGroup.SetItems(items);
Group columnRootGroup = CreateGrandTotal(groupFactory);
IDictionary <Coordinate, AggregateValue[]> aggregates = new Dictionary <Coordinate, AggregateValue[]>();
return(new GroupingResults(rowRootGroup, columnRootGroup, groupFactory)
{
Aggregates = aggregates, UniqueFilterItems = uniqueFilterItems
});
}
int maxDegreeOfParallelism = Math.Max(1, state.MaxDegreeOfParallelism);
int itemCount = state.ItemCount;
int remainder = itemCount % maxDegreeOfParallelism;
int multiplier = (itemCount / maxDegreeOfParallelism) + (remainder > 0 ? 1 : 0);
List <Task <GroupingResults> > tasks = new List <Task <GroupingResults> >(maxDegreeOfParallelism);
for (int i = 0; i < maxDegreeOfParallelism; i++)
{
int start = i * multiplier;
int end = Math.Min((i + 1) * multiplier, itemCount);
BottomLevelGroupingTaskState taskState = new BottomLevelGroupingTaskState()
{
ParallelState = state, Start = start, End = end
};
var task = Task.Factory.StartNew <GroupingResults>(ProcessItems, taskState, state.CancellationToken, TaskCreationOptions.LongRunning | TaskCreationOptions.AttachedToParent, state.TaskScheduler);
tasks.Add(task);
}
Task.WaitAll(tasks.ToArray());
GroupingResults result = tasks[0].Result;
for (int i = 1; i < tasks.Count; i++)
{
result.Merge(tasks[i].Result);
}
result.UniqueFilterItems = uniqueFilterItems;
return(result);
}
private void InitializeFields()
{
this.filter = (Predicate <TDataItem>)null;
this.filterExpression = string.Empty;
this.filterContext = new StringCollection();
this.sortDescriptorCollectionFactory = (ISortDescriptorCollectionFactory) new DefaultSortDescriptorCollectionFactory();
this.sortDescriptors = this.SortDescriptorCollectionFactory.CreateCollection();
this.sortDescriptors.CollectionChanged += new NotifyCollectionChangedEventHandler(this.sortDescriptors_CollectionChanged);
this.groupFactory = (IGroupFactory <TDataItem>) new DefaultGroupFactory <TDataItem>();
this.groupDescriptorCollectionFactory = (IGroupDescriptorCollectionFactory) new DefaultGroupDescriptorCollectionFactory();
this.groupDescriptors = this.GroupDescriptorCollectionFactory.CreateCollection();
this.groupDescriptors.CollectionChanged += new NotifyCollectionChangedEventHandler(this.groupDescriptors_CollectionChanged);
}
public void Init()
{
testSetting = TestSetting.Get();
game = new Game(testSetting);
cameraManager = Substitute.For<ICameraManager>();
backgroundFactory = Substitute.For<IBackgroundFactory>();
gridFactory = Substitute.For<IGridFactory>();
groupFactory = Substitute.For<IGroupFactory>();
game.CameraManager = cameraManager;
game.BackgroundFactory = backgroundFactory;
game.GridFactory = gridFactory;
game.GroupFactory = groupFactory;
}
public Engine(
IInputReader reader,
IOutputWriter writer,
ICommandDispatcher commandDispatcher,
IGroupFactory groupFactory,
IWarEffectFactory warEffectFactory,
IAttackFactory attackFactory,
IDatabase db)
{
this.writer = writer;
this.reader = reader;
this.commandDispatcher = commandDispatcher;
this.commandDispatcher.Engine = this;
this.GroupFactory = groupFactory;
this.WarEffectFactory = warEffectFactory;
this.AttackFactory = attackFactory;
this.Db = db;
}
public MessageHub(
IUnitOfWork unitOfWork,
IMapper mapper,
IMessageFactory messageFactory,
IGroupFactory groupFactory,
IConnectionFactory connectionFactory,
PresenceTracker presenceTracker,
IHubContext <PresenceHub> presenceHub
)
{
this.unitOfWork = unitOfWork;
this.mapper = mapper;
this.messageFactory = messageFactory;
this.groupFactory = groupFactory;
this.connectionFactory = connectionFactory;
this.presenceTracker = presenceTracker;
this.presenceHub = presenceHub;
}
internal Group CreateGroupByName(object groupName, IGroupFactory groupFactor)
{
if (groupName == null)
{
groupName = NullValue.Instance;
}
Group group;
if (!this.GroupsByName.TryGetValue(groupName, out group))
{
group = groupFactor.CreateGroup(groupName);
group.InternalParent = this;
this.GroupsByName.Add(groupName, group);
this.InsertItem(-1, group, null);
}
return(group);
}
/// <summary>
/// This method should be used only after TryGetGroup returns false.
/// </summary>
/// <param name="groupName">The groupName.</param>
/// <param name="groupFactory">The factory that will create new groups.</param>
/// <param name="sortComparer">The groupName comparer.</param>
/// <returns>Returns the index of the newly added group.</returns>
internal int AddGroupByName(object groupName, IGroupFactory groupFactory, IComparer <object> sortComparer)
{
if (groupName == null)
{
groupName = NullValue.Instance;
}
System.Diagnostics.Debug.Assert(!this.GroupsByName.ContainsKey(groupName), "This method should not be called for existing groupName!");
Group group;
if (!this.GroupsByName.TryGetValue(groupName, out group))
{
group = groupFactory.CreateGroup(groupName);
group.InternalParent = this;
this.GroupsByName.Add(groupName, group);
return(this.InsertItem(-1, group, sortComparer));
}
else
{
return(this.itemsList.IndexOf(group));
}
}
public void Init()
{
groupFactory = Substitute.For<IGroupFactory>();
groupStock = new GroupStock(groupFactory);
groupStock.StockDisplayConfig = stockPositions;
}
public GridFactory(ISetting setting, IGroupFactory groupFactory)
{
_setting = setting;
_groupFactory = groupFactory;
}
public void Initialize(ISetting setting, IGroupFactory groupFactory)
{
_setting = setting;
_groupFactory = groupFactory;
SetState(GridStates.GameOver);
if (_setting.GetGameText(GameTextType.GameMessageCenter) == null)
{
_gameTextCenter = NullGameText.Instance;
}
else
{
_gameTextCenter = _setting.GetGameText(GameTextType.GameMessageCenter);
}
_cpuManager = new CPUManager(this, _setting);
// initialize highscore if it is a player game.
if (_setting.IsPlayer)
{
_highScoreManager = new HighScoreManager();
}
if(_highScoreManager != null)
{
DisplayStartMessageAndHighScore();
}
}
public void Init()
{
groupFactory = Substitute.For <IGroupFactory>();
groupStock = new GroupStock(groupFactory);
groupStock.StockDisplayConfig = stockPositions;
}
/// <summary>
/// Performs the grouping operation for specified items.
/// </summary>
/// <param name="items">The items.</param>
/// <param name="level">The level.</param>
/// <param name="parent">The parent.</param>
/// <returns></returns>
public virtual GroupCollection <T> Perform(IReadOnlyCollection <T> items, int level, Group <T> parent)
{
GroupDescriptorCollection groupDescriptors = this.index.CollectionView.GroupDescriptors;
if (level >= groupDescriptors.Count)
{
return(GroupCollection <T> .Empty);
}
IGroupFactory <T> groupFactory = this.index.CollectionView.GroupFactory;
GroupCollection <T> cache = GetCachedGroups(items, level);
if (!IsValid(level, groupDescriptors))
{
if (cache != null)
{
cache.Dispose();
}
return(this.index.CollectionView.GroupFactory.CreateCollection(GroupBuilder <T> .Empty));
}
IComparer <Group <T> > newComparer = Activator.CreateInstance(this.Comparer.GetType()) as IComparer <Group <T> >;
if (newComparer == null)
{
newComparer = this.Comparer;
}
if (newComparer is GroupComparer <T> )
{
((GroupComparer <T>)newComparer).Directions = this.GetComparerDirections(level);
}
AvlTree <Group <T> > groupList = new AvlTree <Group <T> >(newComparer);
AvlTree <Group <T> > list = new AvlTree <Group <T> >(new GroupComparer <T>(this.GetComparerDirections(level)));
foreach (T item in items)
{
object key = this.GroupPredicate(item, level);
Group <T> group, newGroup = new DataItemGroup <T>(key);
group = list.Find(newGroup); groupList.Find(newGroup);
if (group == null)
{
group = GroupBuilder <T> .GetCachedGroup(cache, newGroup);
if (group == null)
{
group = groupFactory.CreateGroup(key, parent);
DataItemGroup <T> dataGroup = group as DataItemGroup <T>;
dataGroup.GroupBuilder = this;
}
list.Add(group);// groupList.Add(group);
}
group.Items.Add(item);
}
for (int i = 0; i < list.Count; i++)
{
groupList.Add(list[i]);
}
if (cache != null)
{
cache.Dispose();
}
return(groupFactory.CreateCollection(groupList));
}
public void Init()
{
gridMock = Substitute.For<IGrid>();
groupFactoryMock = Substitute.For<IGroupFactory>();
}
public void Init()
{
gridMock = Substitute.For <IGrid>();
groupFactoryMock = Substitute.For <IGroupFactory>();
}
public GroupStock(IGroupFactory groupFactory)
{
_groupFactory = groupFactory;
_groupStocks = new List<IGroup>();
}
public GroupService(IGroupRepository repository, IGroupFactory factory)
{
this.Repository = repository;
this.Factory = factory;
}
public World(IInpputReader reader, IOutputWriter writer, IGroupFactory groupFactory)
{
this.Reader = reader;
this.Writer = writer;
this.GroupFactory = groupFactory;
}
public GroupStock(IGroupFactory groupFactory)
{
_groupFactory = groupFactory;
_groupStocks = new List <IGroup>();
}
public GridFactory(ISetting setting, IGroupFactory groupFactory)
{
_setting = setting;
_groupFactory = groupFactory;
}
