/// <summary>
/// Returns true if the skin fits to component<br/>
/// The skin fits to component if it contains all the required parts (being of required types)
/// </summary>
/// <param name="skinType"></param>
/// <param name="componentType"></param>
/// <returns></returns>
public static bool SkinFitsComponent(Type skinType, Type componentType)
{
var parts = SkinPartCache.Instance.Get(componentType);
/**
* 1. Must have all the required skin parts
* */
foreach (var id in parts.Keys)
{
if (!parts[id]) // if part not required, continue
{
continue;
}
var cmpMember = GlobalMemberCache.Instance.Get(componentType, id);
if (null == cmpMember)
{
cmpMember = new MemberWrapper(componentType, id);
GlobalMemberCache.Instance.Put(componentType, id, cmpMember);
}
var skinMember = GlobalMemberCache.Instance.Get(componentType, id);
if (null == skinMember)
{
/* TODO: undirty this */
try
{
skinMember = new MemberWrapper(skinType, id);
GlobalMemberCache.Instance.Put(componentType, id, skinMember);
}
catch (MemberNotFoundException ex)
{
// ignore because the member doesn't exist
}
}
if (null == skinMember || skinMember.GetType() != cmpMember.GetType())
{
return(false);
}
}
/**
* 2. Must have the same set of states
* */
// TODO:
var skinStates = GuiReflector.GetSkinStates(componentType);
var hostComponentType = GetHostComponent(skinType);
var componentStates = GuiReflector.GetSkinStates(hostComponentType);
// in current impl. the states have to be in the same order
var sameStates = ListUtil <string> .Equals(skinStates, componentStates);
return(sameStates);
//return true;
}
public void testAnyToList_Object()
{
Int32 testItem = 9843789;
IList <Object> actual = ListUtil.AnyToList(testItem);
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(testItem, actual[0]);
}
private IEnumerable <PolygonChanged> OutGoingForPointRange(int index, int range)
{
var polygonMutations = Diagonalizes.DiagonalizeListRate(ListUtil.FromTo(index, index + range - 1).SelectList(i =>
GetPointMutationsForIndex(i % Polygon.Points.Count)), 2).ConcatUtil().Select(xs => CombinePointMutations(xs.ToLazyList()));
var changedPolygons = polygonMutations.Select(polygon => new PolygonChanged(polygon, 0));
var withoutSelfIntersections = changedPolygons.Where(changedPolygon => !changedPolygon.NewPolygon.IsSelfIntersecting());
return(withoutSelfIntersections);
}
private void InitializeDetails()
{
txtManageDepartmentsAdd.Text = "";
txtManageDepartmentUpdate.Text = "";
txtManageDepartmentsSearch.Text = "";
selectedDepartmentIndex = -1;
Departments = userController.GetDepartments();
ListUtil.InitializeListView(mlvDepartments, Departments);
}
private void FireSelectedEvent(object[] AddedItems)
{
List <string> AddedItemsLZ = ListUtil <string> .ToList(AddedItems);
DanoEventArgs DEA = new DanoEventArgs();
DEA.DanoParameters.Add(AddedItemsLZ);
LayerSelected(this, DEA);
}
public void Init(SBulletThenEmbedData data)
{
this._data = data;
this.AddCallback(this.Embed);
this._data.TargetObject = ListUtil <GameObject> .GetRandomElement(this._data.TargetableObjects);
this._data.Target = RotateTranslateUtil.Instance.RandomTranslate(
this._data.Target,
this._data.Offset);
}
protected ICacheWalkerResult WalkIntern(IObjRef[] objRefs, IdentityHashSet <ICache> allCachesSet)
{
IdentityHashMap <ICache, List <ICache> > cacheToChildCaches = new IdentityHashMap <ICache, List <ICache> >();
IdentityHashMap <ICache, ICache> cacheToProxyCache = new IdentityHashMap <ICache, ICache>();
ICache currentCommittedRootCache = CommittedRootCache.CurrentCache;
if (!CacheProvider.IsNewInstanceOnCall)
{
allCachesSet.Add(FirstLevelCache.CurrentCache);
}
ICache[] allChildCaches = allCachesSet.ToArray();
allCachesSet.Add(currentCommittedRootCache);
foreach (ICache childCache in allChildCaches)
{
ICache child = childCache;
ICache parent = ((ChildCache)child).Parent;
while (parent != null)
{
ICache currentParent = parent.CurrentCache;
if (!allCachesSet.Add(currentParent))
{
// skip this cache. we handled it already
break;
}
CheckParentCache(parent, currentParent, child, cacheToChildCaches, cacheToProxyCache);
parent = ((IRootCache)currentParent).Parent;
child = currentParent;
}
CheckParentCache(CommittedRootCache, currentCommittedRootCache, child, cacheToChildCaches, cacheToProxyCache);
}
if (objRefs != allEntityRefs)
{
objRefs = new CHashSet <IObjRef>(objRefs).ToArray();
Array.Sort(objRefs, ObjRef.comparator);
}
CacheWalkerResult rootEntry = BuildWalkedEntry(currentCommittedRootCache, objRefs, cacheToChildCaches, cacheToProxyCache);
if (objRefs == allEntityRefs)
{
HashMap <IObjRef, int?> allObjRefs = new HashMap <IObjRef, int?>();
CollectAllObjRefs(rootEntry, allObjRefs);
objRefs = allObjRefs.Count > 0 ? ListUtil.ToArray(allObjRefs.KeyList()) : ObjRef.EMPTY_ARRAY;
Array.Sort(objRefs, ObjRef.comparator);
for (int a = objRefs.Length; a-- > 0;)
{
allObjRefs.Put(objRefs[a], a);
}
ReallocateObjRefsAndCacheValues(rootEntry, objRefs, allObjRefs);
}
return(rootEntry);
}
private IEnumerable <PointMutation> GetPointMutationsForIndex(int index)
{
var removedPointPolygons = ListUtil.Singleton((PointMutation) new DeletedPoint(index));
var changedPointPolygons = MutatePoint(index);
var insertedPointPolygons = EnumerableUtil.From(0).Select(i => InsertPoint(index));
var changedInserted = EnumerableUtil.ConcatUtil(changedPointPolygons, insertedPointPolygons);
var changedInsertedDiagonal = Diagonalizes.DiagonalizeListRateEmpty(changedInserted, 2).ConcatUtil().Select(xs => CombineAddedChangedMutations(xs.ToLazyList()));
var combined = removedPointPolygons.Concat(changedInsertedDiagonal);
return(combined);
}
public void testAnyToSet_Object()
{
Int32 testItem = 9843789;
ISet <Object> actual = ListUtil.AnyToSet(testItem);
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
IEnumerator <Object> enumerator = actual.GetEnumerator();
Assert.IsTrue(enumerator.MoveNext());
Assert.AreEqual(testItem, enumerator.Current);
}
public IEnumerable <PolygonChanged> OutGoingForPoint(int index)
{
var changedPointPolygons = MutatePoint(index);
var insertedPointPolygons = InsertPoint(index);
var removedPointPolygons = ListUtil.Singleton(RemovePoint(index));
var changeInsertPolygons = ListUtil.New <IEnumerable <IList <PolygonChanged> > >(
changedPointPolygons.DivideInfinite(CHANGES_PER_INSERT), insertedPointPolygons.Select(
x => ListUtil.New(x))).Intertwine().SelectMany(x => x);
var combined = removedPointPolygons.Concat(changeInsertPolygons);
return(combined.Where(x => !x.NewPolygon.IsSelfIntersecting()));
}
public void CalcCutOffs2()
{
// 1 2 3
// 0123456789012345678901234567890123
Init("01234567890123456 0123456789012345");
line.CalcCutOffs(20);
Assert.AreEqual("[(18/0)]", ListUtil.ToString(line.cutOffs.ToArray()));
line.CalcCutOffs(18);
Assert.AreEqual("[(18/0)]", ListUtil.ToString(line.cutOffs.ToArray()));
line.CalcCutOffs(17);
Assert.AreEqual("[(17/0)]", ListUtil.ToString(line.cutOffs.ToArray()));
}
public IHex GetRandomNearbyTile(int probes, IHex tile)
{
var currNeighbors = tile.GetAdjacent();
for (int i = 0; i < probes; i++)
{
var random = ListUtil <IHex> .GetRandomElement(currNeighbors);
currNeighbors = random.GetAdjacent();
}
return(ListUtil <IHex> .GetRandomElement(currNeighbors));
}
private async Task <IList <CourseDto> > ToDto(IQueryable <Course> query)
{
query = query.Include(x => x.RelTags)
.ThenInclude(x => x.Tag);
IList <Course> list = await query
.Include(x => x.RelTags)
.ThenInclude(x => x.Tag)
.ToListAsync();
return(await ListUtil.ToDtoListAsync(list, ToCourseDto));
}
private void OnSourceListPropertyDescriptorAdded(ListChangedEventArgs e)
{
_pdc = ListUtil.GetItemProperties(SourceList);
int field = _pdc.IndexOf(e.PropertyDescriptor);
int columnIndex = field + 1;
Model.InsertColumns(columnIndex, 1);
BlinkQueueInsertField(field, null);
//InsertDirtyCellColumns(columnIndex, 1, null);
InsertTotalField(field, 1);
InvalidateVisual(true);
}
protected void BuildSetterCommands(Object entity, IObjRef[] newORIs, RelationMember member, IReader reader)
{
if (!member.IsToMany)
{
if (newORIs.Length == 0)
{
return;
}
else if (newORIs.Length == 1)
{
IObjectFuture objectFuture = new ObjRefFuture(newORIs[0]);
IObjectCommand command = CommandBuilder.Build(reader.CommandTypeRegistry, objectFuture, entity, member);
reader.AddObjectCommand(command);
}
else
{
throw new ArgumentException("Multiple values for to-one relation");
}
}
else
{
Object coll = ListUtil.CreateCollectionOfType(member.RealType, newORIs.Length);
MethodInfo addMethod = coll.GetType().GetMethod("Add");
Object[] parameters = new Object[1];
bool useObjectFuture = false;
ICommandBuilder commandBuilder = CommandBuilder;
ICommandTypeRegistry commandTypeRegistry = reader.CommandTypeRegistry;
foreach (IObjRef ori in newORIs)
{
if (!(ori is IDirectObjRef))
{
IObjectFuture objectFuture = new ObjRefFuture(ori);;
IObjectCommand command = commandBuilder.Build(commandTypeRegistry, objectFuture, coll, addMethod);
reader.AddObjectCommand(command);
useObjectFuture = true;
continue;
}
Object item = ((IDirectObjRef)ori).Direct;
if (useObjectFuture)
{
IObjectCommand command = commandBuilder.Build(commandTypeRegistry, null, coll, addMethod, item);
reader.AddObjectCommand(command);
}
else
{
parameters[0] = item;
addMethod.Invoke(coll, parameters);
}
}
}
}
private int RestoreGravityAssist(IList <int> initialMemory)
{
IList <int> memory = ListUtil.DeepCopy(initialMemory);
int noun = 12;
int verb = 2;
memory[1] = noun;
memory[2] = verb;
IList <int> finalMemory = intcodeCPU.ApplyOperations(memory);
return(finalMemory[0]);
}
private void OnSourceListPropertyDescriptorDeleted(ListChangedEventArgs e)
{
int field = _pdc.IndexOf(e.PropertyDescriptor);
_pdc = ListUtil.GetItemProperties(SourceList);
int columnIndex = field + 1;
Model.RemoveColumns(columnIndex, 1);
BlinkQueueDeleteField(field, null);
//RemoveDirtyCellColumns(columnIndex, 1, null);
RemoveTotalField(field, 1);
InvalidateVisual(true);
}
private void OnSourceListPropertyDescriptorChanged(ListChangedEventArgs e)
{
_pdc = ListUtil.GetItemProperties(SourceList);
int field = _pdc.IndexOf(e.PropertyDescriptor);
int columnIndex = field + 1;
InvalidateCell(GridRangeInfo.Col(columnIndex));
InvalidateCell(new RowColumnIndex(SourceList.Count + 1, columnIndex));
if (IsColumnVisible(columnIndex))
{
InvalidateVisual(false);
}
}
// Item List Selected Operations
private void mlvSearchBorrowItem_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
{
if (e.IsSelected)
{
selectedBorrowItemIndex = mlvSearchBorrowItem.FocusedItem.Index;
selectedBorrowItem = Items.ElementAt(selectedBorrowItemIndex);
Stocks = selectedBorrowItem.Stocks.Count != 0 ? selectedBorrowItem.Stocks.ToList() : new List <Stock>();
ListUtil.InitializeListView(mlvSearchBorrowStock, Stocks);
tbcBorrow.SelectedTab = tbpSelectBorrowStock;
}
}
//Select Item Stock
private void mlvSelectRefundItemStock_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
{
if (e.IsSelected)
{
selectedRefundedItemStock = mlvSelectRefundItemStock.FocusedItem.Index;
selectedRefundBorrow = selectedRefunderUser.Borrows.Where(x => !x.IsReturn).ElementAt(selectedRefundedItemStock);
selectedItem = RefundItems.FirstOrDefault(x => x.Id.Equals(selectedRefundBorrow.Item_Id));
SelectedItems = new List <int>();
ListUtil.InitializeListView(mlvSelectRefundItem, Borrows.Where(x => x.Id.Equals(selectedRefundBorrow.Id)).ToList(), RefundItems, (int)selectedRefundBorrow.Quantity);
tbcManageRefund.SelectedTab = tbpAcceptRefund;
}
}
public override Task <TypeReaderResult> Read(ICommandContext context, string input, IServiceProvider services)
{
try
{
LeagueRole match = LeagueRole.Get(input);
return(Task.FromResult(TypeReaderResult.FromSuccess(match)));
}
catch (NotExistingException)
{
string roles = ListUtil.BuildEnumeration(LeagueRole.Values());
return(Task.FromResult(TypeReaderResult.FromError(CommandError.ParseFailed, $"Role `{input}` doesn't exist. Choose one of `{roles}`")));
}
}
private static bool Remove(List <Subscription> subscriptions, Subscription subscription)
{
for (int i = 0, size = subscriptions.Count; i < size; i++)
{
if (subscription == subscriptions[i])
{
ListUtil.FastUnorderedRemove(subscriptions, i, size - 1);
return(true);
}
}
return(false);
}
public void testAnyToSet_Array2()
{
Int32[] input = { 1, 2, 3, 4, 5 };
ISet <Object> expected = new HashSet <Object>();
for (uint i = 0; i < input.Length; i++)
{
expected.Add(input[i]);
}
ISet <Object> actual = ListUtil.AnyToSet(input);
AssertSimilar(expected, actual);
}
// Search Departments by name
private void txtManageDepartmentsSearch_OnValueChanged(object sender, EventArgs e)
{
txtManageDepartmentsSearch.Text = txtManageDepartmentsSearch.MaximumLength(200);
if (isReporterAdmin)
{
Departments = userController.GetDepartments().Where(x => x.Name.ToLower().Contains(txtManageDepartmentsSearch.Text.ToLower())).ToList();
}
else
{
Departments = userController.GetDepartments().Where(x => x.Id.Equals(userController.GetUser().Department_Id) && x.Name.ToLower().Contains(txtManageDepartmentsSearch.Text.ToLower())).ToList();
}
ListUtil.InitializeListView(mlvDepartments, Departments);
}
public void ProcessPostFatalityBark(FatalityData data)
{
var hit = ListUtil <MHit> .GetRandomElement(data.FatalHits);
var origin = data.Source.GameHandle;
var barks = new List <string>();
if (hit.Data.Target.Current != null &&
hit.Data.Target.Current.GetType().Equals(typeof(CChar)))
{
var tgt = hit.Data.Target.Current as CChar;
if (hit.Data.Source.Proxy.LParty == tgt.Proxy.LParty)
{
barks = BarkTable.Instance.Table[EBark.FriendlyFatality];
}
else
{
var roll = RNG.Instance.NextDouble();
if (roll < NEUTRAL_BARK_CHANCE)
{
barks = BarkTable.Instance.Table[EBark.NeutralFatality];
var characters = CombatManager.Instance.GetData().Characters;
origin = ListUtil <CChar> .GetRandomElement(characters).GameHandle;
}
else
{
barks = this.GetPostEnemyFatalityBarks(data);
}
}
}
else
{
var roll = RNG.Instance.NextDouble();
if (roll < NEUTRAL_BARK_CHANCE)
{
barks = BarkTable.Instance.Table[EBark.NeutralFatality];
var characters = CombatManager.Instance.GetData().Characters;
origin = ListUtil <CChar> .GetRandomElement(characters).GameHandle;
}
else
{
barks = this.GetPostEnemyFatalityBarks(data);
}
}
var bark = ListUtil <string> .GetRandomElement(barks);
if (bark != null)
{
this.DisplayBark(bark, origin);
}
}
public void BeforeRender(RectFloat clipRect)
{
if ((!this.afterRenderCalled || this.beforeRenderCalled) || this.renderCalled)
{
throw new PaintDotNet.InternalErrorException();
}
this.afterRenderCalled = false;
this.beforeRenderCalled = true;
bool flag = this.canvasView.RenderTarget.IsSupported(RenderTargetType.Software, null, null, null);
if (flag || this.IsActive)
{
this.renderStopwatch.Restart();
RectInt32 num2 = RectInt32.Intersect(clipRect.Int32Bound, this.owner.Document.Bounds());
bool flag2 = false;
if (num2.HasPositiveArea)
{
PointInt32 num7;
PointInt32[] array = this.nonCurrentTileOffsets.ToArrayEx <PointInt32>();
this.nonCurrentTileOffsets.Clear();
PointInt32 sourcePt = PointDouble.Round(this.owner.Owner.MouseLocation, MidpointRounding.AwayFromZero);
PointInt32 comparand = this.tileMathHelper.ConvertSourcePointToTileOffset(sourcePt);
CompareTileOffsetsByDistance comparer = new CompareTileOffsetsByDistance(comparand);
ListUtil.Sort <PointInt32, ArrayStruct <PointInt32>, CompareTileOffsetsByDistance>(array.AsStruct <PointInt32>(), comparer);
DequeSet <PointInt32> set = new DequeSet <PointInt32>(array);
int count = set.Count;
while (set.TryDequeue(out num7))
{
if (!this.isDeviceBitmapCurrent[num7.Y][num7.X])
{
if (flag2)
{
this.nonCurrentTileOffsets.TryEnqueue(num7);
}
else
{
if (!this.TryUpdateDeviceBitmap(num7))
{
this.nonCurrentTileOffsets.TryEnqueue(num7);
flag2 = true;
}
if ((!flag2 && !flag) && (this.renderStopwatch.ElapsedMilliseconds > 0x7fffffffffffffffL))
{
flag2 = true;
}
}
}
}
}
}
}
protected void HandlePrimitiveMember(Member primitiveMember, Object entity)
{
Type realType = primitiveMember.RealType;
if (ListUtil.IsCollection(realType))
{
Object primitive = primitiveMember.GetValue(entity);
if (primitive == null)
{
primitive = ListUtil.CreateObservableCollectionOfType(realType);
primitiveMember.SetValue(entity, primitive);
}
}
}
public static void calcNeighbourInnerLoop(Loop outerB)
{
if (outerB.innerLoops == null)
{
return;
}
List <Loop> needRemoveList = new List <Loop>();
for (int i = 0; i < outerB.innerLoops.Count; i++)
{
needRemoveList.AddRange(outerB.innerLoops[i].innerLoops);
}
outerB.neighbourInnerLoops = ListUtil <Loop> .getRemainedRange(outerB.innerLoops, needRemoveList);
}
// Select Refunder User
private void mlvSelectRefunderUser_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
{
if (e.IsSelected)
{
selectedRefunderUserIndex = mlvSelectRefunderUser.FocusedItem.Index;
selectedRefunderUser = Users.ElementAt(selectedRefunderUserIndex);
RefundItems = userController.GetItems(true).Where(x => x.Borrows.Any(y => !y.IsReturn)).ToList();
ListUtil.InitializeListView(mlvSelectRefundItemStock, selectedRefunderUser.Borrows.Where(x => !x.IsReturn).ToList(), RefundItems);
selectedRefundedItemStock = -1;
tbcManageRefund.SelectedTab = tbpSelectRefundedItem;
}
}
public static IEnumerable <int> DistinctSampling(Random random, int count, double exp = 0.5)
{
var indexes = ListUtil.FromTo(0, count);
int itemsLeft = count;
for (int i = 0; i < count; i++)
{
int index = (int)(itemsLeft * Sample(random, exp));
int element = indexes[index];
indexes = RemoveRewrite(indexes, index);
itemsLeft--;
yield return(element);
}
}
