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;
}
