/// <summary>
/// Removes several keys from this key-value map.
/// </summary>
/// <param name="keys">A sequence of keys to remove. Can be much faster if it's a set compatible with this map.</param>
/// <returns></returns>
public override ImmSortedMap <TKey, TValue> RemoveRange(IEnumerable <TKey> keys)
{
keys.CheckNotNull("keys");
var set = keys as ImmSortedSet <TKey>;
if (set != null && Comparer.Equals(set.Comparer))
{
return(Root.Except(set.Root, Lineage.Mutable()).WrapMap(Comparer));
}
return(base.RemoveRange(keys));
}
public static ICommonSortedSet <T> GetSortedSetIfSameComparer(IEnumerable <T> other, IComparer <T> comparer)
{
if ((other is ICommonSortedSet <T> set) && comparer.Equals(set.Comparer))
{
return(set);
}
if ((other is SortedSet <T> set2) && comparer.Equals(set2.Comparer))
{
return(new SortedSetWrapper(set2));
}
return(null);
}
public void Update()
{
if (true == m_IsInit || !IComparer.Equals(m_tState, m_tNextState))
{
m_stateCurrent.onExit();
#if UNITY_EDITOR
if (!m_hashState.ContainsKey(m_tState))
{
Debug.LogError("GFSM::state change error=" + m_tState.ToString());
return;
}
#endif
m_tNextState = m_tState;
m_stateCurrent = m_hashState[m_tState];
m_stateCurrent.onEnter();
m_IsInit = false;
m_nRenderedFrameCount = Time.renderedFrameCount;
}
else
{
if (m_nRenderedFrameCount < Time.renderedFrameCount)
{
m_stateCurrent.onUpdate();
}
}
}
/// <summary>
/// The terms array must be newly created <see cref="TermsEnum"/>, ie
/// <see cref="TermsEnum.MoveNext()"/> has not yet been called.
/// </summary>
public TermsEnum Reset(TermsEnumIndex[] termsEnumsIndex)
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(termsEnumsIndex.Length <= top.Length);
}
numSubs = 0;
numTop = 0;
termComp = null;
queue.Clear();
for (int i = 0; i < termsEnumsIndex.Length; i++)
{
TermsEnumIndex termsEnumIndex = termsEnumsIndex[i];
if (Debugging.AssertsEnabled)
{
Debugging.Assert(termsEnumIndex != null);
}
// init our term comp
if (termComp == null)
{
queue.termComp = termComp = termsEnumIndex.TermsEnum.Comparer;
}
else
{
// We cannot merge sub-readers that have
// different TermComps
IComparer <BytesRef> subTermComp = termsEnumIndex.TermsEnum.Comparer;
if (subTermComp != null && !subTermComp.Equals(termComp))
{
throw new InvalidOperationException("sub-readers have different BytesRef.Comparers: " + subTermComp + " vs " + termComp + "; cannot merge");
}
}
BytesRef term;
if (termsEnumIndex.TermsEnum.MoveNext())
{
term = termsEnumIndex.TermsEnum.Term;
TermsEnumWithSlice entry = subs[termsEnumIndex.SubIndex];
entry.Reset(termsEnumIndex.TermsEnum, term);
queue.Add(entry);
currentSubs[numSubs++] = entry;
}
else
{
// field has no terms
}
}
if (queue.Count == 0)
{
return(TermsEnum.EMPTY);
}
else
{
return(this);
}
}
/**
* Sort an interval based first on start, then on end, if they have
* Equal underlying IComparer<T> objects
* @throw ArgumentException if they do not have Equal IComparer<T>
*/
public int CompareTo(Interval <T> other)
{
if (false == _comp.Equals(other._comp))
{
throw new ArgumentException("Intervals do not share a comparer");
}
int start_cmp = _comp.Compare(Start, other.Start);
if (start_cmp != 0)
{
return(start_cmp);
}
else
{
if (StartIsOpen == other.StartIsOpen)
{
int end_cmp = _comp.Compare(End, other.End);
if (end_cmp == 0)
{
if (EndIsOpen == other.EndIsOpen)
{
return(0);
}
else
{
//Put the open end interval first:
return(EndIsOpen ? -1 : 1);
}
}
else
{
return(end_cmp);
}
}
else
{
/*
* these intervals start at the same point, but only one is open.
* put the closed interval first
*/
return(StartIsOpen ? 1 : -1);
}
}
}
public override IFilterNode <TFilter> Sort(IComparer <IFilterNode <TFilter> > comparer)
{
if (_comparer != null && _comparer.Equals(comparer))
{
return(this);
}
var sortedInnerNode = NodeToInvert.Sort();
return(new InvertedFilterNode <TFilter>(sortedInnerNode, IsCollapsed, comparer));
}
/// <summary>
/// The terms array must be newly created TermsEnum, ie
/// <seealso cref="TermsEnum#next"/> has not yet been called.
/// </summary>
public TermsEnum Reset(TermsEnumIndex[] termsEnumsIndex)
{
Debug.Assert(termsEnumsIndex.Length <= Top.Length);
NumSubs = 0;
NumTop = 0;
TermComp = null;
Queue.Clear();
for (int i = 0; i < termsEnumsIndex.Length; i++)
{
TermsEnumIndex termsEnumIndex = termsEnumsIndex[i];
Debug.Assert(termsEnumIndex != null);
// init our term comp
if (TermComp == null)
{
Queue.TermComp = TermComp = termsEnumIndex.TermsEnum.Comparator;
}
else
{
// We cannot merge sub-readers that have
// different TermComps
IComparer <BytesRef> subTermComp = termsEnumIndex.TermsEnum.Comparator;
if (subTermComp != null && !subTermComp.Equals(TermComp))
{
throw new InvalidOperationException("sub-readers have different BytesRef.Comparators: " + subTermComp + " vs " + TermComp + "; cannot merge");
}
}
BytesRef term = termsEnumIndex.TermsEnum.Next();
if (term != null)
{
TermsEnumWithSlice entry = Subs[termsEnumIndex.SubIndex];
entry.Reset(termsEnumIndex.TermsEnum, term);
Queue.Add(entry);
CurrentSubs[NumSubs++] = entry;
}
else
{
// field has no terms
}
}
if (Queue.Size() == 0)
{
return(TermsEnum.EMPTY);
}
else
{
return(this);
}
}
public void AddRange(IEnumerable <T> items)
{
items.CheckNotNull("items");
var set = items as ImmSortedSet <T>;
if (set != null && _comparer.Equals(set.Comparer))
{
_inner = _inner.Union(set.Root, null, _lineage);
}
else
{
items.ForEach(x => Add(x));
}
}
public void AddRange(IEnumerable <KeyValuePair <TKey, TValue> > items)
{
items.CheckNotNull("items");
var map = items as ImmSortedMap <TKey, TValue>;
if (map != null && _comparer.Equals(map.Comparer))
{
_inner = _inner.Union(map.Root, null, _lineage);
}
else
{
items.ForEach(x => Add(x));
}
}
public override IFilterNode <TFilter> Sort(IComparer <IFilterNode <TFilter> > comparer)
{
// Only sort if absolutely necessary. We still need to sort inner nodes even if there is only 1.
if (_comparer != null && _comparer.Equals(comparer) || Nodes.Length == 0)
{
return(this);
}
var sortedNodes = Nodes
.Select(n => n.Sort(comparer))
.OrderBy(n => n, comparer);
return(new CombinationFilterNode <TFilter>(
sortedNodes,
Operator,
IsCollapsed,
comparer));
}
/// <summary>
/// Sole constructor.
/// </summary>
/// <param name="subs"> The <see cref="Terms"/> instances of all sub-readers. </param>
/// <param name="subSlices"> A parallel array (matching
/// <paramref name="subs"/>) describing the sub-reader slices. </param>
public MultiTerms(Terms[] subs, ReaderSlice[] subSlices)
{
this.subs = subs;
this.subSlices = subSlices;
IComparer <BytesRef> _termComp = null;
if (Debugging.AssertsEnabled)
{
Debugging.Assert(subs.Length > 0, "inefficient: don't use MultiTerms over one sub");
}
bool _hasFreqs = true;
bool _hasOffsets = true;
bool _hasPositions = true;
bool _hasPayloads = false;
for (int i = 0; i < subs.Length; i++)
{
if (_termComp == null)
{
_termComp = subs[i].Comparer;
}
else
{
// We cannot merge sub-readers that have
// different TermComps
IComparer <BytesRef> subTermComp = subs[i].Comparer;
if (subTermComp != null && !subTermComp.Equals(_termComp))
{
throw IllegalStateException.Create("sub-readers have different BytesRef.Comparers; cannot merge");
}
}
_hasFreqs &= subs[i].HasFreqs;
_hasOffsets &= subs[i].HasOffsets;
_hasPositions &= subs[i].HasPositions;
_hasPayloads |= subs[i].HasPayloads;
}
termComp = _termComp;
hasFreqs = _hasFreqs;
hasOffsets = _hasOffsets;
hasPositions = _hasPositions;
hasPayloads = hasPositions && _hasPayloads; // if all subs have pos, and at least one has payloads.
}
/// <summary>
/// Sole constructor.
/// </summary>
/// <param name="subs"> The <seealso cref="Terms"/> instances of all sub-readers. </param>
/// <param name="subSlices"> A parallel array (matching {@code
/// subs}) describing the sub-reader slices. </param>
public MultiTerms(Terms[] subs, ReaderSlice[] subSlices)
{
this.Subs = subs;
this.SubSlices = subSlices;
IComparer <BytesRef> _termComp = null;
Debug.Assert(subs.Length > 0, "inefficient: don't use MultiTerms over one sub");
bool _hasFreqs = true;
bool _hasOffsets = true;
bool _hasPositions = true;
bool _hasPayloads = false;
for (int i = 0; i < subs.Length; i++)
{
if (_termComp == null)
{
_termComp = subs[i].Comparator;
}
else
{
// We cannot merge sub-readers that have
// different TermComps
IComparer <BytesRef> subTermComp = subs[i].Comparator;
if (subTermComp != null && !subTermComp.Equals(_termComp))
{
throw new InvalidOperationException("sub-readers have different BytesRef.Comparators; cannot merge");
}
}
_hasFreqs &= subs[i].HasFreqs();
_hasOffsets &= subs[i].HasOffsets();
_hasPositions &= subs[i].HasPositions();
_hasPayloads |= subs[i].HasPayloads();
}
TermComp = _termComp;
HasFreqs_Renamed = _hasFreqs;
HasOffsets_Renamed = _hasOffsets;
HasPositions_Renamed = _hasPositions;
HasPayloads_Renamed = HasPositions_Renamed && _hasPayloads; // if all subs have pos, and at least one has payloads.
}
/// <summary>
/// Initialize a new instance of the <see cref="T:Academy.Collections.Generic.PriorityQueue`1"/> class that contains
/// elements copied from the especified collection and uses the specified comparer.
/// </summary>
/// <param name="collection">The collection whose elements are copied to the new <see cref="T:Academy.Collections.Generic.PriorityQueue`1"/>.</param>
/// <param name="comparer">The default comparer to use for compare objects.</param>
public PriorityQueue(IEnumerable <T> collection, IComparer <T> comparer)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
if (comparer == null)
{
comparer = Comparer <T> .Default;
}
_comparer = comparer;
if (collection is PriorityQueue <T> heap && _comparer.Equals(heap.Comparer))
{
_elements = heap._elements.Clone() as T[];
_currentIndex = heap._currentIndex;
}
else
{
if (!CollectionHelper.IsWellKnownCollection(collection, out int num))
{
num = DefaultCapacity;
}
_elements = new T[num + 1];
_comparer = comparer;
_currentIndex = 1;
_elements[0] = default(T);
using (IEnumerator <T> enumerator = collection.GetEnumerator())
{
while (enumerator.MoveNext())
{
Enqueue(enumerator.Current);
}
}
TrimExcess();
}
}
public bool IsEqualState(T tState)
{
return(IComparer.Equals(m_tState, tState));
}
private static bool AreEqualComparers(IComparer <T> comparer1, IComparer <T> comparer2)
{
return(comparer1.Equals(comparer2));
}
public Equals(string x, string y)
{
return(_baseCmp.Equals(x ?? string.Empty, y ?? string.Empty));
}
public override bool Equals(object o)
{
return((o == this) ||
(o is ReverseComparer2 <T> &&
cmp.Equals(((ReverseComparer2 <T>)o).cmp)));
}
public override bool Equals(object obj)
{
ReverseComparer <T> objTyped = obj as ReverseComparer <T>;
return(objTyped != null && _originalComparer.Equals(objTyped._originalComparer));
}
