public bool Equals(KeySelector keySelector) { return keySelector.Alt == Alt && keySelector.CharCode == CharCode && keySelector.Control == Control && keySelector.Shift == Shift; }
private KeySelector(int charCode, bool ctrl, bool alt, bool shift) { this = new KeySelector { CharCode = charCode, Control = ctrl, Alt = alt, Shift = shift }; }
/** * Creates a <code>DOMValidateContext</code> containing the specified key * selector and node. * * @param ks a key selector for finding a validation key * @param node the node * @throws NullPointerException if <code>ks</code> or <code>node</code> is * <code>null</code> */ public DOMValidateContext(KeySelector ks, org.w3c.dom.Node node) { if (ks == null) { throw new java.lang.NullPointerException("key selector is null"); } if (node == null) { throw new java.lang.NullPointerException("node is null"); } setKeySelector(ks); this.node = node; }
public ResearchTeamCollection(KeySelector <Tkey> keySelector) { KeySelector = keySelector; }
/// <summary> /// Buckets sorts returning a dictionary of lists /// </summary> /// <typeparam name="TValue">The type of the value.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <param name="inputs">The inputs.</param> /// <param name="keySelector">The key selector.</param> /// <returns></returns> internal static Dictionary <TKey, IList <TValue> > BucketSort <TValue, TKey>(IList <TValue> inputs, KeySelector <TValue, TKey> keySelector) { var retVal = new Dictionary <TKey, IList <TValue> >(); for (int i = 0; i < inputs.Count; ++i) { var input = inputs[i]; var keyValue = keySelector(input); if (!retVal.TryGetValue(keyValue, out var eventsInBucket)) { eventsInBucket = new List <TValue>(inputs.Count - i); retVal.Add(keyValue, eventsInBucket); } eventsInBucket.Add(input); } return(retVal); }
public GetKeyCommand(KeySelector selector) { this.Selector = selector; }
public override FdbRangeQuery <TResult> GetRange <TResult>(KeySelector beginInclusive, KeySelector endExclusive, Func <System.Collections.Generic.KeyValuePair <Slice, Slice>, TResult> selector, FdbRangeOptions options = null) { throw new NotImplementedException(); }
/// <summary> /// Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set. /// </summary> /// <typeparam name="TValue">The type of the value.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <param name="inputs">The inputs.</param> /// <param name="keySelector">The key selector function.</param> /// <returns> /// Dictionary where keys are unique input keys, and values are lists of <see cref="AsyncLogEventInfo"/>. /// </returns> public static Dictionary <TKey, List <TValue> > BucketSort <TValue, TKey>(this IEnumerable <TValue> inputs, KeySelector <TValue, TKey> keySelector) { return(BucketSort(inputs, val => true, keySelector, () => new Dictionary <TKey, List <TValue> >(), () => new List <TValue>())); }
public StudentCollection(KeySelector <TKey> selector) { keySelector = selector; this.students = new Dictionary <TKey, Student>(); }
/// <summary> /// Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set. /// </summary> /// <typeparam name="TValue">The type of the value.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <param name="inputs">The inputs.</param> /// <param name="keySelector">The key selector function.</param> /// <returns> /// Dictionary where keys are unique input keys, and values are lists of <see cref="AsyncLogEventInfo"/>. /// </returns> public static ReadOnlySingleBucketDictionary <TKey, IList <TValue> > BucketSort <TValue, TKey>(this IList <TValue> inputs, KeySelector <TValue, TKey> keySelector) { return(BucketSort(inputs, keySelector, EqualityComparer <TKey> .Default)); }
public GenericStudentCollection(KeySelector <TKey> input_key_selector) { this.key_selector_method = input_key_selector; }
public TChildType Find(BaseBindingList <TChildType> bindingList, TChildKey key) { return(bindingList.FirstOrDefault(child => KeySelector.Invoke(child).CompareTo(key) == 0)); }
/// <summary> /// Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set. /// </summary> /// <typeparam name="TValue">The type of the value.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <param name="inputs">The inputs.</param> /// <param name="keySelector">The key selector function.</param> /// <param name="keyComparer">The key comparer function.</param> /// <returns> /// Dictionary where keys are unique input keys, and values are lists of <see cref="AsyncLogEventInfo"/>. /// </returns> public static ReadOnlySingleBucketDictionary <TKey, IList <TValue> > BucketSort <TValue, TKey>(this IList <TValue> inputs, KeySelector <TValue, TKey> keySelector, IEqualityComparer <TKey> keyComparer) { Dictionary <TKey, IList <TValue> > buckets = null; bool singleBucketFirstKey = false; TKey singleBucketKey = default(TKey); for (int i = 0; i < inputs.Count; i++) { TKey keyValue = keySelector(inputs[i]); if (!singleBucketFirstKey) { singleBucketFirstKey = true; singleBucketKey = keyValue; } else if (buckets == null) { if (!keyComparer.Equals(singleBucketKey, keyValue)) { // Multiple buckets needed, allocate full dictionary buckets = CreateBucketDictionaryWithValue(inputs, keyComparer, i, singleBucketKey, keyValue); } } else { if (!buckets.TryGetValue(keyValue, out var eventsInBucket)) { eventsInBucket = new List <TValue>(); buckets.Add(keyValue, eventsInBucket); } eventsInBucket.Add(inputs[i]); } } if (buckets != null) { return(new ReadOnlySingleBucketDictionary <TKey, IList <TValue> >(buckets, keyComparer)); } else { return(new ReadOnlySingleBucketDictionary <TKey, IList <TValue> >(new KeyValuePair <TKey, IList <TValue> >(singleBucketKey, inputs), keyComparer)); } }
/// <summary> /// Read from the blob, starting at <paramref name="offset"/>, retrieving up to <paramref name="n"/> bytes (fewer then n bytes are returned when the end of the blob is reached). /// </summary> public async Task <Slice> ReadAsync(IFdbReadOnlyTransaction trans, long offset, int n) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (offset < 0) { throw new ArgumentNullException(nameof(offset), "Offset cannot be less than zero"); } long?size = await GetSizeInternalAsync(trans).ConfigureAwait(false); if (size == null) { return(Slice.Nil); // not found } if (offset >= size.Value) { return(Slice.Empty); } // read all chunks matching the segment we need, and copy them in our buffer var buffer = new byte[Math.Min(n, size.Value - offset)]; await trans .GetRange( KeySelector.LastLessOrEqual(DataKey(offset)), KeySelector.FirstGreaterOrEqual(DataKey(offset + n)) ) .ForEachAsync((chunk) => { // get offset of this chunk long chunkOffset = DataKeyOffset(chunk.Key); var chunkData = chunk.Value; checked { // intersect chunk bounds with output int delta = (int)(chunkOffset - offset); int start = delta; int end = delta + chunkData.Count; if (start < 0) { start = 0; } if (end > n) { end = n; } // compute the relative offsets in the chunk int rStart = start - delta; int rEnd = end - delta; var intersect = chunkData[rStart, rEnd]; if (intersect.IsPresent) { // copy the data that fits intersect.CopyTo(buffer, start); } } }) .ConfigureAwait(false); return(buffer.AsSlice(0, buffer.Length)); }
public async Task Run(IFdbDatabase db, TextWriter log, CancellationToken ct) { // estimate the number of machines... Console.WriteLine("# Detecting cluster topology..."); var servers = await db.QueryAsync(tr => tr .WithReadAccessToSystemKeys() .GetRange(KeyRange.StartsWith(Fdb.System.ServerList)) .Select(kvp => new { Node = kvp.Value.Substring(8, 16).ToHexaString(), Machine = kvp.Value.Substring(24, 16).ToHexaString(), DataCenter = kvp.Value.Substring(40, 16).ToHexaString() }), ct ); var numNodes = servers.Select(s => s.Node).Distinct().Count(); var numMachines = servers.Select(s => s.Machine).Distinct().Count(); var numDCs = servers.Select(s => s.DataCenter).Distinct().Count(); Console.WriteLine("# > Found " + numNodes + " process(es) on " + numMachines + " machine(s) in " + numDCs + " datacenter(s)"); Console.WriteLine("# Reading list of shards..."); // dump keyServers var ranges = await Fdb.System.GetChunksAsync(db, FdbKey.MinValue, FdbKey.MaxValue, ct); Console.WriteLine("# > Found " + ranges.Count + " shards:"); // take a sample var rnd = new Random(1234); int sz = Math.Max((int)Math.Ceiling(this.Ratio * ranges.Count), 1); if (sz > 500) { sz = 500; //SAFETY } if (sz < 50) { sz = Math.Max(sz, Math.Min(50, ranges.Count)); } var samples = new List <KeyRange>(); for (int i = 0; i < sz; i++) { int p = rnd.Next(ranges.Count); samples.Add(ranges[p]); ranges.RemoveAt(p); } Console.WriteLine("# Sampling " + sz + " out of " + ranges.Count + " shards (" + (100.0 * sz / ranges.Count).ToString("N1") + "%) ..."); Console.WriteLine("{0,9}{1,10}{2,10}{3,10} : K+V size distribution", "Count", "Keys", "Values", "Total"); var rangeOptions = new FdbRangeOptions { Mode = FdbStreamingMode.WantAll }; samples = samples.OrderBy(x => x.Begin).ToList(); long total = 0; int workers = Math.Min(numMachines, 8); var sw = Stopwatch.StartNew(); var tasks = new List <Task>(); while (samples.Count > 0) { while (tasks.Count < workers && samples.Count > 0) { var range = samples[0]; samples.RemoveAt(0); tasks.Add(Task.Run(async() => { var hh = new RobustHistogram(RobustHistogram.TimeScale.Ticks); #region Method 1: get_range everything... using (var tr = db.BeginTransaction(ct)) { long keySize = 0; long valueSize = 0; long count = 0; int iter = 0; var beginSelector = KeySelector.FirstGreaterOrEqual(range.Begin); var endSelector = KeySelector.FirstGreaterOrEqual(range.End); while (true) { FdbRangeChunk data = default(FdbRangeChunk); FdbException error = null; try { data = await tr.Snapshot.GetRangeAsync( beginSelector, endSelector, rangeOptions, iter ).ConfigureAwait(false); } catch (FdbException e) { error = e; } if (error != null) { await tr.OnErrorAsync(error.Code).ConfigureAwait(false); continue; } if (data.Count == 0) { break; } count += data.Count; foreach (var kvp in data.Chunk) { keySize += kvp.Key.Count; valueSize += kvp.Value.Count; hh.Add(TimeSpan.FromTicks(kvp.Key.Count + kvp.Value.Count)); } if (!data.HasMore) { break; } beginSelector = KeySelector.FirstGreaterThan(data.Last.Key); ++iter; } long totalSize = keySize + valueSize; Interlocked.Add(ref total, totalSize); Console.WriteLine("{0,9}{1,10}{2,10}{3,10} : {4}", count.ToString("N0"), FormatSize(keySize), FormatSize(valueSize), FormatSize(totalSize), hh.GetDistribution(begin: 1, end: 10000, fold: 2)); } #endregion #region Method 2: estimate the count using key selectors... //long counter = await Fdb.System.EstimateCountAsync(db, range, ct); //Console.WriteLine("COUNT = " + counter.ToString("N0")); #endregion }, ct)); } var done = await Task.WhenAny(tasks); tasks.Remove(done); } await Task.WhenAll(tasks); sw.Stop(); Console.WriteLine("> Sampled " + FormatSize(total) + " (" + total.ToString("N0") + " bytes) in " + sw.Elapsed.TotalSeconds.ToString("N1") + " sec"); Console.WriteLine("> Estimated total size is " + FormatSize(total * ranges.Count / sz)); }
/// <summary> /// Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set. /// </summary> /// <typeparam name="TValue">The type of the value.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <param name="inputs">The inputs.</param> /// <param name="keySelector">The key selector function.</param> /// <returns> /// Dictionary where keys are unique input keys, and values are lists of <see cref="AsyncLogEventInfo"/>. /// </returns> public static ReadOnlySingleBucketDictionary <TKey, IList <TValue> > BucketSort <TValue, TKey>(this IList <TValue> inputs, KeySelector <TValue, TKey> keySelector) { Dictionary <TKey, IList <TValue> > buckets = null; bool singleBucketFirstKey = false; TKey singleBucketKey = default(TKey); EqualityComparer <TKey> c = EqualityComparer <TKey> .Default; for (int i = 0; i < inputs.Count; i++) { TKey keyValue = keySelector(inputs[i]); if (!singleBucketFirstKey) { singleBucketFirstKey = true; singleBucketKey = keyValue; } else if (buckets == null) { if (!c.Equals(singleBucketKey, keyValue)) { // Multiple buckets needed, allocate full dictionary buckets = new Dictionary <TKey, IList <TValue> >(); var bucket = new List <TValue>(i); for (int j = 0; j < i; j++) { bucket.Add(inputs[j]); } buckets[singleBucketKey] = bucket; bucket = new List <TValue>(); bucket.Add(inputs[i]); buckets[keyValue] = bucket; } } else { IList <TValue> eventsInBucket; if (!buckets.TryGetValue(keyValue, out eventsInBucket)) { eventsInBucket = new List <TValue>(); buckets.Add(keyValue, eventsInBucket); } eventsInBucket.Add(inputs[i]); } } if (buckets != null) { return(new ReadOnlySingleBucketDictionary <TKey, IList <TValue> >(buckets)); } else { return(new ReadOnlySingleBucketDictionary <TKey, IList <TValue> >(new KeyValuePair <TKey, IList <TValue> >(singleBucketKey, inputs))); } }
public StudentCollection(KeySelector <TKey> selector, string name) { this.selector = selector; this.name = name; }
/// <summary>Initializes a new instance of the <seealso cref="FlexibleInitializableValueDictionary{TKey, TValue}"/> class. Each item in the provided collection is transformed with <paramref name="keySelector"/> and added to the dictionary.</summary> /// <param name="valueCollection">The collection of values to initialize the dictionary from.</param> /// <param name="keySelector">The selector that transforms a <typeparamref name="TValue"/> into a <typeparamref name="TKey"/>.</param> public FlexibleInitializableValueDictionary(IEnumerable <TValue> valueCollection, KeySelector <TKey, TValue> keySelector) : base(valueCollection, keySelector) { }
/// <summary> /// Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set. /// </summary> /// <typeparam name="TValue">The type of the value.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <param name="inputs">The inputs.</param> /// <param name="keySelector">The key selector function.</param> /// <returns> /// Dictionary where keys are unique input keys, and values are lists of <see cref="AsyncLogEventInfo"/>. /// </returns> public static Dictionary <TKey, List <TValue> > BucketSort <TValue, TKey>(this IEnumerable <TValue> inputs, KeySelector <TValue, TKey> keySelector) { var buckets = new Dictionary <TKey, List <TValue> >(); foreach (var input in inputs) { var keyValue = keySelector(input); if (!buckets.TryGetValue(keyValue, out var eventsInBucket)) { eventsInBucket = new List <TValue>(); buckets.Add(keyValue, eventsInBucket); } eventsInBucket.Add(input); } return(buckets); }
public SCollection(KeySelector <TKey> ks) { keySelector = ks; collection = new Dictionary <TKey, Student>(); }
public WeakIdentityMap(KeySelector key_selector, int capacity = 10) { this.key_selector = key_selector; Init(capacity); }
public virtual Task <Slice> GetKeyAsync(KeySelector selector) { ThrowIfDisposed(); return(m_transaction.GetKeyAsync(selector)); }
public void setKeySelector(KeySelector ks) { this.ks = ks; }
public virtual Task <Slice> GetKeyAsync(KeySelector selector) { return(m_transaction.GetKeyAsync(selector)); }
public virtual Task <FdbRangeChunk> GetRangeAsync(KeySelector beginInclusive, KeySelector endExclusive, FdbRangeOptions options = null, int iteration = 0) { return(m_transaction.GetRangeAsync(beginInclusive, endExclusive, options, iteration)); }
public virtual FdbRangeQuery <KeyValuePair <Slice, Slice> > GetRange(KeySelector beginInclusive, KeySelector endInclusive, FdbRangeOptions options = null) { return(m_transaction.GetRange(beginInclusive, endInclusive, options)); }
public MagazineCollection(KeySelector <TKey> keySelector) { this.myKaySelector = keySelector; }
/// <summary> /// Buckets sorts returning a dictionary of lists /// </summary> /// <typeparam name="TValue">The type of the value.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <param name="inputs">The inputs.</param> /// <param name="keySelector">The key selector.</param> /// <returns></returns> internal static Dictionary <TKey, List <TValue> > BucketSort <TValue, TKey>(IEnumerable <TValue> inputs, KeySelector <TValue, TKey> keySelector) { var retVal = new Dictionary <TKey, List <TValue> >(); foreach (var input in inputs) { var keyValue = keySelector(input); var eventsInBucket = new List <TValue>(); if (!retVal.TryGetValue(keyValue, out eventsInBucket)) { eventsInBucket = new List <TValue>(); retVal.Add(keyValue, eventsInBucket); } eventsInBucket.Add(input); } return(retVal); }
public override async Task <Slice> GetKeyAsync(KeySelector selector) { return(Decode(await base.GetKeyAsync(Encode(selector)).ConfigureAwait(false))); }
public DictionaryCache(KeySelector <TKey, TValue> keySelector) { _values = new Dictionary <TKey, TValue>(); _keySelector = keySelector; }
public override Task <FdbRangeChunk> GetRangeAsync(KeySelector beginInclusive, KeySelector endExclusive, FdbRangeOptions options = null, int iteration = 0) { throw new NotImplementedException(); }
public DictionaryCache(KeySelector <TKey, TValue> keySelector, IEnumerable <TValue> values) : this(keySelector) { Fill(values); }
public StudentCollection(KeySelector <TKey> k) { key = k; }
/** * Creates a <code>DOMSignContext</code> with the specified key selector, * parent and next sibling nodes. The marshalled <code>XMLSignature</code> * will be inserted as a child element of the specified parent node and * immediately before the specified next sibling node. * * @param ks the key selector * @param parent the parent node * @param nextSibling the next sibling node * @throws NullPointerException if <code>ks</code>, <code>parent</code> or * <code>nextSibling</code> is <code>null</code> */ public DOMSignContext(KeySelector ks, org.w3c.dom.Node parent, org.w3c.dom.Node nextSibling) { if (ks == null) { throw new java.lang.NullPointerException("key selector cannot be null"); } if (parent == null) { throw new java.lang.NullPointerException("parent cannot be null"); } if (nextSibling == null) { throw new java.lang.NullPointerException("nextSibling cannot be null"); } setKeySelector(ks); this.parent = parent; this.nextSibling = nextSibling; }