[llvm-commits] [llvm] r119820 - /llvm/trunk/include/llvm/ADT/IntervalMap.h
Jakob Stoklund Olesen
stoklund at 2pi.dk
Fri Nov 19 11:10:39 PST 2010
Author: stoklund
Date: Fri Nov 19 13:10:39 2010
New Revision: 119820
URL: http://llvm.org/viewvc/llvm-project?rev=119820&view=rev
Log:
Rename methods for clarity instead of brevity. No functional changes.
Modified:
llvm/trunk/include/llvm/ADT/IntervalMap.h
Modified: llvm/trunk/include/llvm/ADT/IntervalMap.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/IntervalMap.h?rev=119820&r1=119819&r2=119820&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ADT/IntervalMap.h (original)
+++ llvm/trunk/include/llvm/ADT/IntervalMap.h Fri Nov 19 13:10:39 2010
@@ -203,10 +203,10 @@
VT val[N];
/// copy - Copy elements from another node.
- /// @param other Node elements are copied from.
+ /// @param Other Node elements are copied from.
/// @param i Beginning of the source range in other.
/// @param j Beginning of the destination range in this.
- /// @param count Number of elements to copy.
+ /// @param Count Number of elements to copy.
template <unsigned M>
void copy(const NodeBase<KT, VT, M> &Other, unsigned i,
unsigned j, unsigned Count) {
@@ -216,21 +216,21 @@
std::copy(Other.val + i, Other.val + i + Count, val + j);
}
- /// lmove - Move elements to the left.
+ /// moveLeft - Move elements to the left.
/// @param i Beginning of the source range.
/// @param j Beginning of the destination range.
- /// @param count Number of elements to copy.
- void lmove(unsigned i, unsigned j, unsigned Count) {
- assert(j <= i && "Use rmove shift elements right");
+ /// @param Count Number of elements to copy.
+ void moveLeft(unsigned i, unsigned j, unsigned Count) {
+ assert(j <= i && "Use moveRight shift elements right");
copy(*this, i, j, Count);
}
- /// rmove - Move elements to the right.
+ /// moveRight - Move elements to the right.
/// @param i Beginning of the source range.
/// @param j Beginning of the destination range.
- /// @param count Number of elements to copy.
- void rmove(unsigned i, unsigned j, unsigned Count) {
- assert(i <= j && "Use lmove shift elements left");
+ /// @param Count Number of elements to copy.
+ void moveRight(unsigned i, unsigned j, unsigned Count) {
+ assert(i <= j && "Use moveLeft shift elements left");
assert(j + Count <= N && "Invalid range");
std::copy_backward(key + i, key + i + Count, key + j + Count);
std::copy_backward(val + i, val + i + Count, val + j + Count);
@@ -239,55 +239,57 @@
/// erase - Erase elements [i;j).
/// @param i Beginning of the range to erase.
/// @param j End of the range. (Exclusive).
- /// @param size Number of elements in node.
+ /// @param Size Number of elements in node.
void erase(unsigned i, unsigned j, unsigned Size) {
- lmove(j, i, Size - j);
+ moveLeft(j, i, Size - j);
}
/// shift - Shift elements [i;size) 1 position to the right.
/// @param i Beginning of the range to move.
- /// @param size Number of elements in node.
+ /// @param Size Number of elements in node.
void shift(unsigned i, unsigned Size) {
- rmove(i, i + 1, Size - i);
+ moveRight(i, i + 1, Size - i);
}
- /// xferLeft - Transfer elements to a left sibling node.
- /// @param size Number of elements in this.
- /// @param sib Left sibling node.
- /// @param ssize Number of elements in sib.
- /// @param count Number of elements to transfer.
- void xferLeft(unsigned Size, NodeBase &Sib, unsigned SSize, unsigned Count) {
+ /// transferToLeftSib - Transfer elements to a left sibling node.
+ /// @param Size Number of elements in this.
+ /// @param Sib Left sibling node.
+ /// @param SSize Number of elements in sib.
+ /// @param Count Number of elements to transfer.
+ void transferToLeftSib(unsigned Size, NodeBase &Sib, unsigned SSize,
+ unsigned Count) {
Sib.copy(*this, 0, SSize, Count);
erase(0, Count, Size);
}
- /// xferRight - Transfer elements to a right sibling node.
- /// @param size Number of elements in this.
- /// @param sib Right sibling node.
- /// @param ssize Number of elements in sib.
- /// @param count Number of elements to transfer.
- void xferRight(unsigned Size, NodeBase &Sib, unsigned SSize, unsigned Count) {
- Sib.rmove(0, Count, SSize);
+ /// transferToRightSib - Transfer elements to a right sibling node.
+ /// @param Size Number of elements in this.
+ /// @param Sib Right sibling node.
+ /// @param SSize Number of elements in sib.
+ /// @param Count Number of elements to transfer.
+ void transferToRightSib(unsigned Size, NodeBase &Sib, unsigned SSize,
+ unsigned Count) {
+ Sib.moveRight(0, Count, SSize);
Sib.copy(*this, Size-Count, 0, Count);
}
- /// adjLeftSib - Adjust the number if elements in this node by moving
+ /// adjustFromLeftSib - Adjust the number if elements in this node by moving
/// elements to or from a left sibling node.
- /// @param size Number of elements in this.
- /// @param sib Right sibling node.
- /// @param ssize Number of elements in sib.
- /// @param add The number of elements to add to this node, possibly < 0.
+ /// @param Size Number of elements in this.
+ /// @param Sib Right sibling node.
+ /// @param SSize Number of elements in sib.
+ /// @param Add The number of elements to add to this node, possibly < 0.
/// @return Number of elements added to this node, possibly negative.
- int adjLeftSib(unsigned Size, NodeBase &Sib, unsigned SSize, int Add) {
+ int adjustFromLeftSib(unsigned Size, NodeBase &Sib, unsigned SSize, int Add) {
if (Add > 0) {
// We want to grow, copy from sib.
unsigned Count = std::min(std::min(unsigned(Add), SSize), N - Size);
- Sib.xferRight(SSize, *this, Size, Count);
+ Sib.transferToRightSib(SSize, *this, Size, Count);
return Count;
} else {
// We want to shrink, copy to sib.
unsigned Count = std::min(std::min(unsigned(-Add), Size), N - SSize);
- xferLeft(Size, Sib, SSize, Count);
+ transferToLeftSib(Size, Sib, SSize, Count);
return -Count;
}
}
@@ -463,7 +465,7 @@
/// findFrom - Find the first interval after i that may contain x.
/// @param i Starting index for the search.
- /// @param size Number of elements in node.
+ /// @param Size Number of elements in node.
/// @param x Key to search for.
/// @return First index with !stopLess(key[i].stop, x), or size.
/// This is the first interval that can possibly contain x.
@@ -519,7 +521,7 @@
/// possible. This may cause the node to grow by 1, or it may cause the node
/// to shrink because of coalescing.
/// @param i Starting index = insertFrom(0, size, a)
-/// @param size Number of elements in node.
+/// @param Size Number of elements in node.
/// @param a Interval start.
/// @param b Interval stop.
/// @param y Value be mapped.
@@ -578,7 +580,7 @@
/// extendStop - Extend stop(i) to b, coalescing with following intervals.
/// @param i Interval to extend.
-/// @param size Number of elements in node.
+/// @param Size Number of elements in node.
/// @param b New interval end point.
/// @return New node size after coalescing.
template <typename KeyT, typename ValT, unsigned N, typename Traits>
@@ -644,7 +646,7 @@
/// findFrom - Find the first subtree after i that may contain x.
/// @param i Starting index for the search.
- /// @param size Number of elements in node.
+ /// @param Size Number of elements in node.
/// @param x Key to search for.
/// @return First index with !stopLess(key[i], x), or size.
/// This is the first subtree that can possibly contain x.
@@ -680,9 +682,9 @@
/// insert - Insert a new (subtree, stop) pair.
/// @param i Insert position, following entries will be shifted.
- /// @param size Number of elements in node.
- /// @param node Subtree to insert.
- /// @param stp Last key in subtree.
+ /// @param Size Number of elements in node.
+ /// @param Node Subtree to insert.
+ /// @param Stop Last key in subtree.
void insert(unsigned i, unsigned Size, NodeRefT Node, KeyT Stop) {
assert(Size < N && "branch node overflow");
assert(i <= Size && "Bad insert position");
@@ -1647,7 +1649,7 @@
if (CurSize[n] == NewSize[n])
continue;
for (int m = n - 1; m != -1; --m) {
- int d = Node[n]->adjLeftSib(CurSize[n], *Node[m], CurSize[m],
+ int d = Node[n]->adjustFromLeftSib(CurSize[n], *Node[m], CurSize[m],
NewSize[n] - CurSize[n]);
CurSize[m] -= d;
CurSize[n] += d;
@@ -1662,7 +1664,7 @@
if (CurSize[n] == NewSize[n])
continue;
for (unsigned m = n + 1; m != Nodes; ++m) {
- int d = Node[m]->adjLeftSib(CurSize[m], *Node[n], CurSize[n],
+ int d = Node[m]->adjustFromLeftSib(CurSize[m], *Node[n], CurSize[n],
CurSize[n] - NewSize[n]);
CurSize[m] += d;
CurSize[n] -= d;
More information about the llvm-commits
mailing list