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