void merge_diff_types (const basic_string_token &rhs_,
basic_string_token &merged_) const
{
if (_negated)
{
merge_negated (*this, rhs_, merged_);
}
else
{
merge_negated (rhs_, *this, merged_);
}
merged_.normalise ();
}
void intersect_charset (basic_string_token &rhs_,
basic_string_token &overlap_)
{
if (rhs_.any ())
{
overlap_._charset = _charset;
rhs_._negated = true;
rhs_._charset = _charset;
clear ();
}
else // rhs_._negated == true
{
typename string::iterator iter_ = _charset.begin ();
typename string::iterator end_ = _charset.end ();
typename string::iterator rhs_iter_ = rhs_._charset.begin ();
typename string::iterator rhs_end_ = rhs_._charset.end ();
while (iter_ != end_ && rhs_iter_ != rhs_end_)
{
if (*iter_ < *rhs_iter_)
{
overlap_._charset += *iter_;
rhs_iter_ = rhs_._charset.insert (rhs_iter_, *iter_);
++rhs_iter_;
rhs_end_ = rhs_._charset.end ();
iter_ = _charset.erase (iter_);
end_ = _charset.end ();
}
else if (*iter_ > *rhs_iter_)
{
++rhs_iter_;
}
else
{
++iter_;
++rhs_iter_;
}
}
if (iter_ != end_)
{
// nothing bigger in rhs_ than iter_,
// so safe to merge using std lib.
string temp_ (iter_, end_);
// src, dest
merge (temp_, overlap_._charset);
_charset.erase (iter_, end_);
}
if (!overlap_._charset.empty ())
{
merge (overlap_._charset, rhs_._charset);
// possible duplicates, so check for any and erase.
rhs_._charset.erase (std::unique (rhs_._charset.begin (),
rhs_._charset.end ()), rhs_._charset.end ());
normalise ();
overlap_.normalise ();
rhs_.normalise ();
}
}
}
void intersect_same_types (basic_string_token &rhs_, basic_string_token &overlap_)
{
if (any ())
{
clear ();
overlap_._negated = true;
rhs_.clear ();
}
else
{
typename string::iterator iter_ = _charset.begin ();
typename string::iterator end_ = _charset.end ();
typename string::iterator rhs_iter_ = rhs_._charset.begin ();
typename string::iterator rhs_end_ = rhs_._charset.end ();
overlap_._negated = _negated;
while (iter_ != end_ && rhs_iter_ != rhs_end_)
{
if (*iter_ < *rhs_iter_)
{
++iter_;
}
else if (*iter_ > *rhs_iter_)
{
++rhs_iter_;
}
else
{
overlap_._charset += *iter_;
iter_ = _charset.erase (iter_);
end_ = _charset.end ();
rhs_iter_ = rhs_._charset.erase (rhs_iter_);
rhs_end_ = rhs_._charset.end ();
}
}
if (_negated)
{
// duplicates already merged, so safe to merge
// using std lib.
// src, dest
merge (_charset, overlap_._charset);
// duplicates already merged, so safe to merge
// using std lib.
// src, dest
merge (rhs_._charset, overlap_._charset);
_negated = false;
rhs_._negated = false;
std::swap (_charset, rhs_._charset);
normalise ();
overlap_.normalise ();
rhs_.normalise ();
}
else if (!overlap_._charset.empty ())
{
normalise ();
overlap_.normalise ();
rhs_.normalise ();
}
}
}
void merge_same_types (const basic_string_token &rhs_,
basic_string_token &merged_) const
{
if (any ())
{
merged_._negated = true;
}
else if (_negated)
{
typename string::const_iterator iter_ = _chars.begin ();
typename string::const_iterator end_ = _chars.end ();
typename string::const_iterator rhs_iter_ = rhs_._chars.begin ();
typename string::const_iterator rhs_end_ = rhs_._chars.end ();
merged_._negated = _negated;
while (iter_ != end_ && rhs_iter_ != rhs_end_)
{
if (*iter_ < *rhs_iter_)
{
++iter_;
}
else if (*iter_ > *rhs_iter_)
{
++rhs_iter_;
}
else
{
merged_._chars += *iter_;
++iter_;
++rhs_iter_;
}
}
merged_.normalise ();
}
else
{
typename string::const_iterator iter_ = _chars.begin ();
typename string::const_iterator end_ = _chars.end ();
typename string::const_iterator rhs_iter_ = rhs_._chars.begin ();
typename string::const_iterator rhs_end_ = rhs_._chars.end ();
while (iter_ != end_ && rhs_iter_ != rhs_end_)
{
if (*iter_ < *rhs_iter_)
{
merged_._chars += *iter_;
++iter_;
}
else if (*iter_ > *rhs_iter_)
{
merged_._chars += *rhs_iter_;
++rhs_iter_;
}
else
{
merged_._chars += *iter_;
++iter_;
++rhs_iter_;
}
}
// Include any trailing chars
if (iter_ != end_)
{
string temp_ (iter_, end_);
merged_._chars += temp_;
}
else if (rhs_iter_ != rhs_end_)
{
string temp_ (rhs_iter_, rhs_end_);
merged_._chars += temp_;
}
merged_.normalise ();
}
}
