OrderedCollection/*PERMUDA*/Proxy( IOrderedCollection/*PERMUDA*//*PERMUDA FROMSUFFIX*/ from ) { NonNull.CheckParameter( from, "from" ); this.From = from; }
/// <summary> /// Initializes a new instance of the <see cref="TransformCollection<TInt, TExt>"/> class. /// </summary> /// <param name="orderedCollection">The ordered collection.</param> /// <param name="transformExtInt">The transform ext int.</param> /// <param name="transformIntExt">The transform int ext.</param> public TransformOrderedCollection( IOrderedCollection <TInt> orderedCollection, Func <TExt, TInt> transformExtInt, Func <TInt, TExt> transformIntExt) : base( orderedCollection, transformExtInt, transformIntExt) { _orderedCollection = orderedCollection; }
protected override void PutMany(IOrderedCollection <int, string> collection, params string[] values) { var pairs = new List <KeyValuePair <int, string> >(values.Length); foreach (var value in values) { pairs.Add(new KeyValuePair <int, string>(Interlocked.Increment(ref _lastKey), value)); } collection.PutMany(pairs); }
public SystemManager(World world) { _World = world; _ComponentSystems = new OrderedList <ComponentSystem>(); _HandledComponentsArrays = new Dictionary <Type, HandledComponents[]>(); _UpdateStopwatch = new Stopwatch(); RegisterLast <FirstOrderSystem>(); RegisterLast <DefaultOrderSystem>(); RegisterLast <LastOrderSystem>(); }
internal static IOrderedCollection <T> AsOrderedCollection <T>(this IEnumerable <T> sequence) { Requires.NotNull <IEnumerable <T> >(sequence, "sequence"); IOrderedCollection <T> orderedCollection = sequence as IOrderedCollection <T>; if (orderedCollection != null) { return(orderedCollection); } IList <T> list = sequence as IList <T>; if (list != null) { return(new ImmutableExtensions.ListOfTWrapper <T>(list)); } return(new ImmutableExtensions.FallbackWrapper <T>(sequence)); }
internal static Node NodeTreeFromList(IOrderedCollection <T> items, int start, int length) { Requires.NotNull(items, nameof(items)); Debug.Assert(start >= 0); Debug.Assert(length >= 0); if (length == 0) { return(EmptyNode); } int rightCount = (length - 1) / 2; int leftCount = (length - 1) - rightCount; Node left = NodeTreeFromList(items, start, leftCount); Node right = NodeTreeFromList(items, start + leftCount + 1, rightCount); return(new Node(items[start + leftCount], left, right, true)); }
/// <summary> /// Creates a node tree that contains the contents of a list. /// </summary> /// <param name="items">An indexable list with the contents that the new node tree should contain.</param> /// <param name="start">The starting index within <paramref name="items"/> that should be captured by the node tree.</param> /// <param name="length">The number of elements from <paramref name="items"/> that should be captured by the node tree.</param> /// <returns>The root of the created node tree.</returns> private static Node NodeTreeFromList(IOrderedCollection <KeyValuePair <TKey, TValue> > items, int start, int length) { Requires.NotNull(items, nameof(items)); Requires.Range(start >= 0, nameof(start)); Requires.Range(length >= 0, nameof(length)); if (length == 0) { return(EmptyNode); } int rightCount = (length - 1) / 2; int leftCount = (length - 1) - rightCount; Node left = NodeTreeFromList(items, start, leftCount); Node right = NodeTreeFromList(items, start + leftCount + 1, rightCount); var item = items[start + leftCount]; return(new Node(item.Key, item.Value, left, right, true)); }
private static SortedInt32KeyNode <TValue> NodeTreeFromList(IOrderedCollection <KeyValuePair <int, TValue> > items, int start, int length) { Requires.NotNull(items, "items"); Requires.Range(start >= 0, "start"); Requires.Range(length >= 0, "length"); if (length == 0) { return(EmptyNode); } int rightCount = (length - 1) / 2; int leftCount = (length - 1) - rightCount; SortedInt32KeyNode <TValue> left = NodeTreeFromList(items, start, leftCount); SortedInt32KeyNode <TValue> right = NodeTreeFromList(items, start + leftCount + 1, rightCount); var item = items[start + leftCount]; return(new SortedInt32KeyNode <TValue>(item.Key, item.Value, left, right, true)); }
IndexSlice/*PERMUDA*/( IOrderedCollection/*PERMUDA*//*PERMUDA TYPESUFFIX*/ from, ///< The underlying collection long sliceIndex, ///< Index at which the slice begins /// - <tt>GTE( 0 )</tt> /// - <tt>LTE( from.Count )</tt> long sliceCount ///< Length of the slice /// - <tt>GTE( 0 )</tt> /// - <tt>LTE( from.Count - sliceIndex )</tt> ) { NonNull.CheckParameter( from, "from" ); GTE.CheckParameter( 0, sliceIndex, "sliceIndex" ); LTE.CheckParameter( from.Count, sliceIndex, "sliceIndex" ); GTE.CheckParameter( 0, sliceCount, "sliceCount" ); LTE.CheckParameter( from.Count - sliceIndex, sliceCount, "sliceCount" ); this.From = from; this.SliceIndex = sliceIndex; this.SliceCount = sliceCount; }
/// <summary> /// Returns the sorted collection. /// </summary> /// <typeparam name="T"> /// The data type of the collection. /// </typeparam> /// <param name="collection"> /// The sorted collection definition. /// </param> /// <returns> /// The sorted collection. /// </returns> internal static IQueryable <T> GetCollection <T>(this IOrderedCollection <T> collection) where T : class { return(((OrderedCollection <T>)collection).GetCollection()); }
protected override void RemoveLastPutValue(IOrderedCollection <int, string> collection) { collection.RemoveRange(Interval.Create(_lastKey, _lastKey)); }
protected override void Put(IOrderedCollection <int, string> collection, string value) { collection.Put(Interlocked.Increment(ref _lastKey), value); }