/// <summary> /// Append new sort key to the current run of sort keys. /// </summary> private void AppendSortKey(XmlSortKey key) { // Ensure that sort will be stable by setting index of key key.Priority = this.pos; if (this.keys[this.pos] == null) this.keys[this.pos] = key; else this.keys[this.pos].AddSortKey(key); }
/// <summary> /// Finish creating the current run of sort keys and begin a new run. /// </summary> public void FinishSortKeys() { this.pos++; if (this.pos >= this.keys.Length) { XmlSortKey[] keysNew = new XmlSortKey[this.pos * 2]; Array.Copy(this.keys, 0, keysNew, 0, this.keys.Length); this.keys = keysNew; } this.keys[this.pos] = null; }
/// <summary> /// When two keys are compared and found to be equal, the tie must be broken. If there is a secondary key, /// then use that to break the tie. Otherwise, use the input ordering to break the tie. Since every key /// has a unique index, this is guaranteed to always break the tie. /// </summary> protected int BreakSortingTie(XmlSortKey that) { if (this.nextKey != null) { // There are multiple keys, so break tie using next key Debug.Assert(this.nextKey != null && that.nextKey != null); return this.nextKey.CompareTo(that.nextKey); } Debug.Assert(this.priority != that.priority); return (this.priority < that.priority) ? -1 : 1; }
/// <summary> /// Finish creating the current run of sort keys and begin a new run. /// </summary> public void FinishSortKeys() { _pos++; if (_pos >= _keys.Length) { XmlSortKey[] keysNew = new XmlSortKey[_pos * 2]; Array.Copy(_keys, 0, keysNew, 0, _keys.Length); _keys = keysNew; } _keys[_pos] = null; }
/// <summary> /// Finish creating the current run of sort keys and begin a new run. /// </summary> public void FinishSortKeys() { _pos++; if (_pos >= _keys.Length) { XmlSortKey[] keysNew = new XmlSortKey[_pos * 2]; Array.Copy(_keys, keysNew, _keys.Length); _keys = keysNew; } _keys[_pos] = null; }
/// <summary> /// Sometimes a key is composed of multiple parts. For example: (LastName, FirstName). Multi-part /// keys are linked together in a list. This method recursively adds a new key part to the end of the list. /// Returns the first (primary) key in the list. /// </summary> public XmlSortKey AddSortKey(XmlSortKey sortKey) { if (this.nextKey != null) { // Add to end of list--this is not it this.nextKey.AddSortKey(sortKey); } else { // This is the end of the list this.nextKey = sortKey; } return this; }
protected int BreakSortingTie(XmlSortKey that) { if (_nextKey != null) { // There are multiple keys, so break tie using next key Debug.Assert(_nextKey != null && that._nextKey != null); return(_nextKey.CompareTo(that._nextKey)); } Debug.Assert(_priority != that._priority); return((_priority < that._priority) ? -1 : 1); }
/// <summary> /// Append new sort key to the current run of sort keys. /// </summary> private void AppendSortKey(XmlSortKey key) { // Ensure that sort will be stable by setting index of key key.Priority = _pos; if (_keys[_pos] == null) { _keys[_pos] = key; } else { _keys[_pos] !.AddSortKey(key); } }
/// <summary> /// Append new sort key to the current run of sort keys. /// </summary> private void AppendSortKey(XmlSortKey key) { // Ensure that sort will be stable by setting index of key key.Priority = this.pos; if (this.keys[this.pos] == null) { this.keys[this.pos] = key; } else { this.keys[this.pos].AddSortKey(key); } }
public XmlSortKey AddSortKey(XmlSortKey sortKey) { if (_nextKey != null) { // Add to end of list--this is not it _nextKey.AddSortKey(sortKey); } else { // This is the end of the list _nextKey = sortKey; } return(this); }