summaryrefslogtreecommitdiff
path: root/indra
diff options
context:
space:
mode:
authorNat Goodspeed <nat@lindenlab.com>2012-03-23 15:53:44 -0400
committerNat Goodspeed <nat@lindenlab.com>2012-03-23 15:53:44 -0400
commit8815cfa5c916ac454cfa5b6f22f9ce312b00a846 (patch)
treec478b4519d34a64dd62f1f969d133210d43e04d1 /indra
parent1e10e1c625035b4bd237dd1439491c39ef44e934 (diff)
Rename In[Esc]String helper-class data members, per code review.
Diffstat (limited to 'indra')
-rw-r--r--indra/llcommon/llstring.h92
1 files changed, 46 insertions, 46 deletions
diff --git a/indra/llcommon/llstring.h b/indra/llcommon/llstring.h
index 5085d32f7f..09733e8e2a 100644
--- a/indra/llcommon/llstring.h
+++ b/indra/llcommon/llstring.h
@@ -745,23 +745,23 @@ struct InString
typedef typename string_type::const_iterator const_iterator;
InString(const_iterator b, const_iterator e):
- iter(b),
- end(e)
+ mIter(b),
+ mEnd(e)
{}
virtual ~InString() {}
- bool done() const { return iter == end; }
- /// Is the current character (*iter) escaped? This implementation can
+ bool done() const { return mIter == mEnd; }
+ /// Is the current character (*mIter) escaped? This implementation can
/// answer trivially because it doesn't support escapes.
virtual bool escaped() const { return false; }
- /// Obtain the current character and advance @c iter.
- virtual T next() { return *iter++; }
+ /// Obtain the current character and advance @c mIter.
+ virtual T next() { return *mIter++; }
/// Does the current character match specified character?
- virtual bool is(T ch) const { return (! done()) && *iter == ch; }
+ virtual bool is(T ch) const { return (! done()) && *mIter == ch; }
/// Is the current character any one of the specified characters?
virtual bool oneof(const string_type& delims) const
{
- return (! done()) && LLStringUtilBase<T>::contains(delims, *iter);
+ return (! done()) && LLStringUtilBase<T>::contains(delims, *mIter);
}
/**
@@ -769,10 +769,10 @@ struct InString
* useful for processing quoted substrings.
*
* If we do see @a delim, append everything from @from until (excluding)
- * @a delim to @a into, advance @c iter to skip @a delim, and return @c
+ * @a delim to @a into, advance @c mIter to skip @a delim, and return @c
* true.
*
- * If we do not see @a delim, do not alter @a into or @c iter and return
+ * If we do not see @a delim, do not alter @a into or @c mIter and return
* @c false. Do not pass GO, do not collect $200.
*
* @note The @c false case described above implements normal getTokens()
@@ -785,18 +785,18 @@ struct InString
*/
virtual bool collect_until(string_type& into, const_iterator from, T delim)
{
- const_iterator found = std::find(from, end, delim);
+ const_iterator found = std::find(from, mEnd, delim);
// If we didn't find delim, change nothing, just tell caller.
- if (found == end)
+ if (found == mEnd)
return false;
// Found delim! Append everything between from and found.
into.append(from, found);
// advance past delim in input
- iter = found + 1;
+ mIter = found + 1;
return true;
}
- const_iterator iter, end;
+ const_iterator mIter, mEnd;
};
/// InString subclass that handles escape characters
@@ -808,33 +808,33 @@ public:
typedef typename super::string_type string_type;
typedef typename super::const_iterator const_iterator;
using super::done;
- using super::iter;
- using super::end;
+ using super::mIter;
+ using super::mEnd;
- InEscString(const_iterator b, const_iterator e, const string_type& escapes_):
+ InEscString(const_iterator b, const_iterator e, const string_type& escapes):
super(b, e),
- escapes(escapes_)
+ mEscapes(escapes)
{
- // Even though we've already initialized 'iter' via our base-class
+ // Even though we've already initialized 'mIter' via our base-class
// constructor, set it again to check for initial escape char.
setiter(b);
}
/// This implementation uses the answer cached by setiter().
- virtual bool escaped() const { return isesc; }
+ virtual bool escaped() const { return mIsEsc; }
virtual T next()
{
// If we're looking at the escape character of an escape sequence,
- // skip that character. This is the one time we can modify 'iter'
+ // skip that character. This is the one time we can modify 'mIter'
// without using setiter: for this one case we DO NOT CARE if the
// escaped character is itself an escape.
- if (isesc)
- ++iter;
+ if (mIsEsc)
+ ++mIter;
// If we were looking at an escape character, this is the escaped
// character; otherwise it's just the next character.
- T result(*iter);
- // Advance iter, checking for escape sequence.
- setiter(iter + 1);
+ T result(*mIter);
+ // Advance mIter, checking for escape sequence.
+ setiter(mIter + 1);
return result;
}
@@ -842,14 +842,14 @@ public:
{
// Like base-class is(), except that an escaped character matches
// nothing.
- return (! done()) && (! isesc) && *iter == ch;
+ return (! done()) && (! mIsEsc) && *mIter == ch;
}
virtual bool oneof(const string_type& delims) const
{
// Like base-class oneof(), except that an escaped character matches
// nothing.
- return (! done()) && (! isesc) && LLStringUtilBase<T>::contains(delims, *iter);
+ return (! done()) && (! mIsEsc) && LLStringUtilBase<T>::contains(delims, *mIter);
}
virtual bool collect_until(string_type& into, const_iterator from, T delim)
@@ -860,27 +860,27 @@ public:
// directly appending to 'into' in case we do not find delim, in which
// case we're supposed to leave 'into' unmodified.
string_type collected;
- // For scanning purposes, we're going to work directly with 'iter'.
+ // For scanning purposes, we're going to work directly with 'mIter'.
// Save its current value in case we fail to see delim.
- const_iterator save_iter(iter);
- // Okay, set 'iter', checking for escape.
+ const_iterator save_iter(mIter);
+ // Okay, set 'mIter', checking for escape.
setiter(from);
while (! done())
{
// If we see an unescaped delim, stop and report success.
- if ((! isesc) && *iter == delim)
+ if ((! mIsEsc) && *mIter == delim)
{
// Append collected chars to 'into'.
into.append(collected);
- // Don't forget to advance 'iter' past delim.
- setiter(iter + 1);
+ // Don't forget to advance 'mIter' past delim.
+ setiter(mIter + 1);
return true;
}
// We're not at end, and either we're not looking at delim or it's
// escaped. Collect this character and keep going.
collected.push_back(next());
}
- // Here we hit 'end' without ever seeing delim. Restore iter and tell
+ // Here we hit 'mEnd' without ever seeing delim. Restore mIter and tell
// caller.
setiter(save_iter);
return false;
@@ -889,24 +889,24 @@ public:
private:
void setiter(const_iterator i)
{
- iter = i;
+ mIter = i;
- // Every time we change 'iter', set 'isesc' to be able to repetitively
- // answer escaped() without having to rescan 'escapes'. isesc caches
- // contains(escapes, *iter).
+ // Every time we change 'mIter', set 'mIsEsc' to be able to repetitively
+ // answer escaped() without having to rescan 'mEscapes'. mIsEsc caches
+ // contains(mEscapes, *mIter).
// We're looking at an escaped char if we're not already at end (that
- // is, *iter is even meaningful); if *iter is in fact one of the
+ // is, *mIter is even meaningful); if *mIter is in fact one of the
// specified escape characters; and if there's one more character
// following it. That is, if an escape character is the very last
// character of the input string, it loses its special meaning.
- isesc = (! done()) &&
- LLStringUtilBase<T>::contains(escapes, *iter) &&
- (iter+1) != end;
+ mIsEsc = (! done()) &&
+ LLStringUtilBase<T>::contains(mEscapes, *mIter) &&
+ (mIter+1) != mEnd;
}
- const string_type escapes;
- bool isesc;
+ const string_type mEscapes;
+ bool mIsEsc;
};
/// getTokens() implementation based on InString concept
@@ -957,7 +957,7 @@ void getTokens(INSTRING& instr, std::vector<string_type>& tokens,
// If we're looking at an open quote, search forward for
// a close quote, collecting characters along the way.
if (instr.oneof(quotes) &&
- instr.collect_until(tokens.back(), instr.iter+1, *instr.iter))
+ instr.collect_until(tokens.back(), instr.mIter+1, *instr.mIter))
{
// collect_until is cleverly designed to do exactly what we
// need here. No further action needed if it returns true.