public void printList() { String strLine = ""; // to be written // Open a new file to write the new words System.IO.StreamWriter fsrWriting = new System.IO.StreamWriter(new System.IO.FileStream(".\\output.txt", System.IO.FileMode.OpenOrCreate)); for (int bucket = 0; bucket < 26; bucket++) { IComparer comp = new EntryComparer(); list[bucket].Sort(comp); for (int i = 0; i < list[bucket].Count; i++) { Word w = (Word)(list[bucket][i]); for (int m = 0; m < w.getUsages().Length; m++) { strLine = strLine + w.getUsages()[m] + " "; } strLine = strLine + "\\ "; strLine = strLine + w.getWord() + " "; strLine = strLine + w.getMeaning(); // Write it fsrWriting.WriteLine(strLine); strLine = ""; } } fsrWriting.Close(); }
private MultiTaggedReadResult <TEntry, TMeasureType> Merge( TMeasureType measureType, IFieldCalculator[] calculators, Sort sort, Dictionary <TagCollection, List <TaggedReadResult <TEntry, TMeasureType> > > collectionsByTags) { // construct final result from previously grouped results var finalResults = new Dictionary <TagCollection, TaggedReadResult <TEntry, TMeasureType> >(); foreach (var collections in collectionsByTags) { List <TEntry> newCollection; if (collections.Value.Count == 1) { newCollection = collections.Value[0].Entries; } else { newCollection = MergeSort.Sort( collections: collections.Value.Select(x => x.Entries), comparer: EntryComparer.GetComparer <TKey, TEntry>(sort), resolveConflict: x => Aggregate(x, calculators)); } // need tag information RIGHT HERE var tagCollection = collections.Key; finalResults.Add(tagCollection, new TaggedReadResult <TEntry, TMeasureType>(tagCollection, sort, newCollection)); } var finalResult = new MultiTaggedReadResult <TEntry, TMeasureType>(measureType, finalResults); return(finalResult); }
/// <summary> /// Constructor /// </summary> /// <param name="behaviour">Behaviour</param> /// <param name="max">Max</param> /// <param name="key">Key</param> /// <param name="order">Order</param> public Pool(PoolMaxBehaviour behaviour, int max, Func <TValue, TKey> key, Comparison <TValue> order) { if (max <= 0) { throw new ArgumentException(nameof(max)); } Behaviour = behaviour; Max = max; _key = key; _order = order; _isSorted = false; _list = new List <Entry>(); _comparer = new EntryComparer(); }
public WordEntry FindEntry(string strSelectedWord) { IComparer comp = new EntryComparer(); wordList.Sort(comp); WordEntry we = new WordEntry(); we.SetWord(strSelectedWord); int index = wordList.BinarySearch(we, comp); if (index >= 0) { return((WordEntry)wordList[index]); } return(null); }
public void Persist(T entry) { if (SelectedItem != null) { EntryComparer comparer = new EntryComparer(); if (_entries.Contains(entry, comparer)) { Update(entry); } else { Insert(entry); } } else { Insert(entry); } }
private async Task StoreForId(TKey id, List <TEntry> newEntries, DateTime from, DateTime to) { // retrieve existing entries for this period var retrievals = await RetrieveRangeForId(id, from, to, Sort.Descending).ConfigureAwait(false); var oldEntities = retrievals.ToDictionary(x => x.RowKey); // merge results var oldEntries = retrievals.SelectMany(x => x.GetEntries <TKey, TEntry>(Sort.Descending)).ToList(); var mergedEntries = MergeSort.Sort( collections: new IEnumerable <TEntry>[] { newEntries, oldEntries }, comparer: EntryComparer.GetComparer <TKey, TEntry>(Sort.Descending), resolveConflict: x => x.First()); // prioritize the item from the first collection (new one) // create new entities var newEntities = CreateTableEntitiesFor(id, mergedEntries).ToDictionary(x => x.RowKey); var operations = CreateAtsOperations(newEntities, oldEntities); await ExecuteAtsOperatioons(operations).ConfigureAwait(false); }
static void Main(string[] args) { var source = new[] { new Entry { Id = 1, DateTime = DateTime.Parse("21.05.2019 10:00:00") }, new Entry { Id = 2, DateTime = DateTime.Parse("21.05.2019 10:10:00") }, new Entry { Id = 3, DateTime = DateTime.Parse("21.05.2019 10:20:00") }, new Entry { Id = 4, DateTime = DateTime.Parse("21.05.2019 10:30:00") }, new Entry { Id = 5, DateTime = DateTime.Parse("21.05.2019 10:40:00") }, new Entry { Id = 6, DateTime = DateTime.Parse("21.05.2019 10:50:00") }, new Entry { Id = 7, DateTime = DateTime.Parse("21.05.2019 11:00:00") } }; var destination = new[] { new Entry { Id = 1, DateTime = DateTime.Parse("21.05.2019 09:00:00") }, new Entry { Id = 3, DateTime = DateTime.Parse("21.05.2019 10:25:00") }, new Entry { Id = 5, DateTime = DateTime.Parse("21.05.2019 10:45:00") }, new Entry { Id = 7, DateTime = DateTime.Parse("21.05.2019 10:30:00") }, new Entry { Id = 9, DateTime = DateTime.Parse("21.05.2019 10:40:00") }, new Entry { Id = 11, DateTime = DateTime.Parse("21.05.2019 10:50:00") } }; var comparer = new EntryComparer(); var partA = source.Except(destination, comparer); var partB = source.Intersect(destination, comparer) .Where(i => source.First(j => j.Id == i.Id).DateTime > destination.First(j => j.Id == i.Id).DateTime); var result = partA.Concat(partB); foreach (var i in result) { Console.WriteLine(i); } }
/// <summary> /// Generic implementation of the get methods for the particular /// <see cref="IFilter"/> provided. /// </summary> /// <param name="cache"> /// The <see cref="ICache"/> to be queried. /// </param> /// <param name="dictIndex"> /// The <see cref="IDictionary"/> of indexes. /// </param> /// <param name="filter"> /// The <see cref="IFilter"/> object representing the criteria that /// the entries of this cache should satisfy. /// </param> /// <param name="queryType"> /// An enum value that defines whether return array should be values, /// keys or entries. /// </param> /// <param name="sort"> /// If <b>true</b>, sort the result-set before returning. /// </param> /// <param name="comparer"> /// The <see cref="IComparer"/> to use for sorting (optional). /// </param> /// <returns> /// A collection of the keys/values for entries that satisfy the /// specified criteria. /// </returns> public static object[] Query(ICache cache, IDictionary dictIndex, IFilter filter, QueryType queryType, bool sort, IComparer comparer) { IFilter filterOrig = filter; if (AlwaysFilter.Instance.Equals(filter)) { filter = null; } object[] results; // may contain keys, values, or entries // try to apply an index (if available) if (dictIndex != null && filter is IIndexAwareFilter) { // take a thread-safe snapshot of the cache key set; this // differs a from the Java version in which the Set interface, // SubSet class, and thread-safe Collection.toArray() methods // are at our disposal ICollection keys; CollectionUtils.AcquireReadLock(cache); try { keys = new HashSet(cache.Keys); } finally { CollectionUtils.ReleaseReadLock(cache); } filter = ((IIndexAwareFilter)filter).ApplyIndex(dictIndex, keys); results = CollectionUtils.ToArray(keys); } else { // perform a thread-safe conversion of the cache key set into // an object array; again, this differs a bit from the Java // version CollectionUtils.AcquireReadLock(cache); try { results = CollectionUtils.ToArray(cache.Keys); } finally { CollectionUtils.ReleaseReadLock(cache); } } int resultCount = 0; if (filter == null && queryType == QueryType.Keys) { resultCount = results.Length; } else { // we still have a filter to evaluate or we need an entry set // or values collection for (int i = 0, c = results.Length; i < c; i++) { var key = results[i]; var value = cache[key]; if (value != null || cache.Contains(key)) { ICacheEntry entry = new CacheEntry(key, value); if (filter == null || EvaluateEntry(filter, entry)) { object result; switch (queryType) { case QueryType.Entries: result = entry; break; case QueryType.Keys: result = key; break; default: result = value; break; } results[resultCount++] = result; } } } } // convert the result array into an array of the appropriate // type and length; this differs from the Java version in which // this method returns a Set and not an array if (queryType == QueryType.Entries) { var entries = new ICacheEntry[resultCount]; Array.Copy(results, 0, entries, 0, resultCount); results = entries; } else if (resultCount < results.Length) { var newResults = new object[resultCount]; Array.Copy(results, 0, newResults, 0, resultCount); results = newResults; } // sort the results; this differs from the Java version in which // this method only can return keys or entries (and not values) if (sort) { if (comparer == null) { comparer = SafeComparer.Instance; } if (queryType == QueryType.Entries) { comparer = new EntryComparer(comparer); } Array.Sort(results, 0, resultCount, comparer); } // if the original filter is a LimitFilter then we can only return // a page at a time if (filterOrig is LimitFilter) { var filterLimit = filterOrig as LimitFilter; filterLimit.Comparer = null; results = filterLimit.ExtractPage(results); resultCount = results.Length; filterLimit.Comparer = comparer; // for debug output only } // convert the result array into an array of the appropriate // type and length; this differs from the Java version in which // this method returns a Set and not an array if (queryType == QueryType.Entries) { var entries = new ICacheEntry[resultCount]; Array.Copy(results, 0, entries, 0, resultCount); results = entries; } else if (resultCount < results.Length) { var newResults = new object[resultCount]; Array.Copy(results, 0, newResults, 0, resultCount); results = newResults; } return(results); }
public void Sort(Sort sort) { _entries.Sort(EntryComparer.GetComparer <TKey, TEntry>(sort)); }