internal bool IsSupersetOf(Node other) { if (other.Count > Count) { return(false); } var iter = new TreeIterator(this); return(other.ForEachWhileNode(node => { if (!iter.MoveNext()) { return false; } var myCur = iter.Current; var compare = Comparer.Compare(node.Key, myCur.Key); if (compare > 0) { while ((compare = Comparer.Compare(node.Key, iter.Current.Key)) > 0) { if (!iter.MoveNext()) { return false; } } } return compare == 0; })); }
private long?TryFindSmallValue(Transaction tx, TreeIterator it, int num) { do { var stream = it.CreateReaderForCurrent(); { var current = new StreamBitArray(stream); var currentSectionId = it.CurrentKey.CreateReader().ReadBigEndianInt64(); long?page; if (current.SetCount < num) { if (TryFindSmallValueMergingTwoSections(tx, it, num, current, currentSectionId, out page)) { return(page); } continue; } if (TryFindContinuousRange(tx, it, num, current, currentSectionId, out page)) { return(page); } //could not find a continuous so trying to merge if (TryFindSmallValueMergingTwoSections(tx, it, num, current, currentSectionId, out page)) { return(page); } } } while (it.MoveNext()); return(null); }
public bool FindTarget(TreeNode root, int k) { var left = new TreeIterator(root, true); var right = new TreeIterator(root, false); while (left.Current != right.Current) { int sum = left.Current.val + right.Current.val; if (sum == k) { return(true); } if (sum < k) { left.MoveNext(); } else { right.MoveNext(); } } return(false); }
public void TestFlatAB() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(nil A B)"); TreeIterator it = new TreeIterator(t); StringBuilder buf = new StringBuilder(); bool first = true; while (it.MoveNext()) { CommonTree n = (CommonTree)it.Current; if (!first) { buf.Append(" "); } first = false; buf.Append(n); } string expecting = "nil DOWN A B UP EOF"; string found = buf.ToString(); Assert.AreEqual(expecting, found); }
public IEnumerator <KeyValuePair <TKey, TValue> > GetEnumerator() { var iterator = new TreeIterator(this); while (iterator.MoveNext()) { yield return(Kvp.Of(iterator.Current.Key, iterator.Current.Value)); } }
public bool IsSupersetOf(Node other) { if (other.NodeCount > NodeCount) { return(false); } if (other.Count > Count) { return(false); } var iter = new TreeIterator(this); //The idea is tht we go over the nodes in order of hash, from smallest to largest. //If we find a node in `other` that is smaller than the current node in `this //This means that node doesn't exist in `this` at all, so it isn't a superset. return(other.ForEachWhileNode(node => { if (!iter.MoveNext()) { return false; } var cur = iter.Current; if (node.Hash > cur.Hash) { while (node.Hash > iter.Current.Hash) { if (!iter.MoveNext()) { return false; } } cur = iter.Current; } if (node.Hash < cur.Hash) { return false; } var result = node.Bucket.ForEachWhile((k, v) => cur.Bucket.Find(k).IsSome); return result; })); }
public IEnumerator <KeyValuePair <TKey, TValue> > GetEnumerator() { var iterator = new TreeIterator(this); while (iterator.MoveNext()) { var bucket = iterator.Current.Bucket; while (!bucket.IsEmpty) { yield return(Kvp.Of(bucket.Key, bucket.Value)); bucket = bucket.Next; } } }
/// <summary> /// Returns an iterator for retrieving all the elements shared between this tree and another tree. /// </summary> /// <param name="other"></param> /// <returns></returns> public IEnumerable <StructTuple <Node, Node> > IntersectElements(Node other) { if (IsEmpty || other.IsEmpty) { yield break; } var aIterator = new TreeIterator(this); var bIterator = new TreeIterator(other); var pivotInA = true; var success = aIterator.MoveNext(); var pivot = aIterator.Current; while (!aIterator.IsEnded || !bIterator.IsEnded) { var trySeekIn = pivotInA ? bIterator : aIterator; int cmpResult; success = trySeekIn.SeekGreaterThan(pivot.Key, out cmpResult); if (!success) { break; } var maybePivot = trySeekIn.Current; if (cmpResult == 0) { yield return(pivotInA ? StructTuple.Create(pivot, maybePivot) : StructTuple.Create(maybePivot, pivot)); pivotInA = !pivotInA; trySeekIn = pivotInA ? aIterator : bIterator; success = trySeekIn.MoveNext(); if (!success) { break; } pivot = trySeekIn.Current; } else { pivot = maybePivot; pivotInA = !pivotInA; //If the pivot was in X, it's now in Y... } } }
public void TestAB() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard( adaptor, tokens ); CommonTree t = (CommonTree)wiz.Create( "(A B)" ); TreeIterator it = new TreeIterator( t ); StringBuilder buf = new StringBuilder(); bool first = true; while ( it.MoveNext() ) { CommonTree n = (CommonTree)it.Current; if ( !first ) buf.Append( " " ); first = false; buf.Append( n ); } string expecting = "A DOWN B UP EOF"; string found = buf.ToString(); Assert.AreEqual( expecting, found ); }
private long?TryFindLargeValue(Transaction tx, TreeIterator it, int num) { int numberOfNeededFullSections = num / NumberOfPagesInSection; int numberOfExtraBitsNeeded = num % NumberOfPagesInSection; int foundSections = 0; Slice startSection = null; long? startSectionId = null; var sections = new List <Slice>(); do { var stream = it.CreateReaderForCurrent(); { var current = new StreamBitArray(stream); var currentSectionId = it.CurrentKey.CreateReader().ReadBigEndianInt64(); //need to find full free pages if (current.SetCount < NumberOfPagesInSection) { ResetSections(ref foundSections, sections, ref startSection, ref startSectionId); continue; } //those sections are not following each other in the memory if (startSectionId != null && currentSectionId != startSectionId + foundSections) { ResetSections(ref foundSections, sections, ref startSection, ref startSectionId); } //set the first section of the sequence if (startSection == null) { startSection = it.CurrentKey; startSectionId = currentSectionId; } sections.Add(it.CurrentKey); foundSections++; if (foundSections != numberOfNeededFullSections) { continue; } //we found enough full sections now we need just a bit more if (numberOfExtraBitsNeeded == 0) { foreach (var section in sections) { tx.State.FreeSpaceRoot.Delete(section); } return(startSectionId * NumberOfPagesInSection); } var nextSectionId = currentSectionId + 1; var nextId = new Slice(EndianBitConverter.Big.GetBytes(nextSectionId)); var read = tx.State.FreeSpaceRoot.Read(nextId); if (read == null) { //not a following next section ResetSections(ref foundSections, sections, ref startSection, ref startSectionId); continue; } var next = new StreamBitArray(read.Reader); if (next.HasStartRangeCount(numberOfExtraBitsNeeded) == false) { //not enough start range count ResetSections(ref foundSections, sections, ref startSection, ref startSectionId); continue; } //mark selected bits to false if (next.SetCount == numberOfExtraBitsNeeded) { tx.State.FreeSpaceRoot.Delete(nextId); } else { for (int i = 0; i < numberOfExtraBitsNeeded; i++) { next.Set(i, false); } tx.State.FreeSpaceRoot.Add(nextId, next.ToStream()); } foreach (var section in sections) { tx.State.FreeSpaceRoot.Delete(section); } return(startSectionId * NumberOfPagesInSection); } } while (it.MoveNext()); return(null); }