Cross Reference: /external/llvm/include/llvm/ADT/IntervalMap.h

Lines Matching defs:stop
28 // value. The interval bounds are accessible through the start() and stop()
52 //   KeyT stop() const;
75 //   const KeyT &stop() const;
529 // - Traits::stopLess(start(i), stop(i))    - Non-empty, sane intervals.
531 // - Traits::stopLess(stop(i), start(i + 1) - Sorted.
533 // - value(i) != value(i + 1) || !Traits::adjacent(stop(i), start(i + 1))
542   const KeyT &stop(unsigned i) const { return this->first[i].second; }
546   KeyT &stop(unsigned i) { return this->first[i].second; }
553   /// @return     First index with !stopLess(key[i].stop, x), or size.
557     assert((i == 0 || Traits::stopLess(stop(i - 1), x)) &&
559     while (i != Size && Traits::stopLess(stop(i), x)) ++i;
568   /// @return  First index with !stopLess(key[i].stop, x), never size.
572     assert((i == 0 || Traits::stopLess(stop(i - 1), x)) &&
574     while (Traits::stopLess(stop(i), x)) ++i;
598 /// @param b    Interval stop.
609   assert((i == 0 || Traits::stopLess(stop(i - 1), a)));
610   assert((i == Size || !Traits::stopLess(stop(i), a)));
614   if (i && value(i - 1) == y && Traits::adjacent(stop(i - 1), a)) {
618       stop(i - 1) = stop(i);
622     stop(i - 1) = b;
633     stop(i) = b;
651   stop(i) = b;
663 // The key array in a branch node holds the rightmost stop key of each subtree.
664 // It is redundant to store the last stop key since it can be found in the
679   const KeyT &stop(unsigned i) const { return this->second[i]; }
682   KeyT &stop(unsigned i) { return this->second[i]; }
693     assert((i == 0 || Traits::stopLess(stop(i - 1), x)) &&
695     while (i != Size && Traits::stopLess(stop(i), x)) ++i;
707     assert((i == 0 || Traits::stopLess(stop(i - 1), x)) &&
709     while (Traits::stopLess(stop(i), x)) ++i;
721   /// insert - Insert a new (subtree, stop) pair.
731     stop(i) = Stop;
1055   /// stop - Return the largest mapped key in a non-empty map.
1056   KeyT stop() const {
1057     assert(!empty() && "Empty IntervalMap has no stop");
1058     return !branched() ? rootLeaf().stop(rootSize - 1) :
1059                          rootBranch().stop(rootSize - 1);
1064     if (empty() || Traits::startLess(x, start()) || Traits::stopLess(stop(), x))
1176     rootBranch().stop(n) = node[n].template get<Leaf>().stop(size[n]-1);
1215     rootBranch().stop(n) = Node[n].template get<Branch>().stop(Size[n]-1);
1313   /// unsafeStop - Writable access to stop() for iterator.
1316     return branched() ? path.leaf<Leaf>().stop(path.leafOffset()) :
1317                         path.leaf<RootLeaf>().stop(path.leafOffset());
1344   /// stop - Return the end of the current interval.
1345   const KeyT &stop() const { return unsafeStop(); }
1408   /// find - Move to the first interval with stop >= x, or end().
1417   /// advanceTo - Move to the first interval with stop >= x, or end().
1462   if (!Traits::stopLess(path.leaf<Leaf>().stop(path.leafSize() - 1), x)) {
1473       if (!Traits::stopLess(path.node<Branch>(l).stop(path.offset(l)), x)) {
1482     if (!Traits::stopLess(map->rootBranch().stop(path.offset(0)), x)) {
1525   /// @param b New stop key, must not overlap the following interval.
1542   /// @param b New stop key.
1599                 Traits::adjacent(Node.stop(i-1), Start);
1604     return Node.value(i-1) == Value && Traits::adjacent(Node.stop(i-1), Start);
1608     return Node.value(i) == Value && Traits::adjacent(Node.stop(i), Start);
1614 /// changing stop or value?
1615 /// @param Stop New stop of current interval.
1641 /// setNodeStop - Update the stop key of the current node at level and above.
1651     P.node<Branch>(Level).stop(P.offset(Level)) = Stop;
1656   P.node<RootBranch>(Level).stop(P.offset(Level)) = Stop;
1662   assert(Traits::stopLess(a, this->stop()) && "Cannot move start beyond stop");
1678   assert(Traits::stopLess(this->start(), b) && "Cannot move stop beyond start");
1679   if (Traits::startLess(b, this->stop()) ||
1694   if (canCoalesceRight(this->stop(), x)) {
1800           Traits::adjacent(SibLeaf.stop(SibOfs), a)) {
1803         //  1. Extend SibLeaf.stop to b and be done, or
1811           setNodeStop(P.height(), SibLeaf.stop(SibOfs) = b);
1882   // When we erase the last entry, update stop and move to a legal position.
1884     setNodeStop(IM.height, Node.stop(NewSize - 1));
1922       // If we removed the last branch, update stop and move to a legal pos.
1924         setNodeStop(Level, Parent.stop(NewSize - 1));
1998     KeyT Stop = Node[Pos]->stop(NewSize[Pos]-1);
2051     if (Traits::stopLess(posA.stop(), posB.start())) {
2054       if (!posA.valid() || !Traits::stopLess(posB.stop(), posA.start()))
2056     } else if (Traits::stopLess(posB.stop(), posA.start())) {
2059       if (!posB.valid() || !Traits::stopLess(posA.stop(), posB.start()))
2068       if (!posA.valid() || !Traits::stopLess(posB.stop(), posA.start()))
2072       if (!posB.valid() || !Traits::stopLess(posA.stop(), posB.start()))
2101   /// stop - End of the overlapping interval.
2102   KeyType stop() const {
2103     KeyType ak = a().stop();
2104     KeyType bk = b().stop();
2123     if (Traits::startLess(posB.stop(), posA.stop()))
2131   /// stopLess(x, stop()).
2136     if (Traits::stopLess(posA.stop(), x))
2138     if (Traits::stopLess(posB.stop(), x))