#include "insets/InsetText.h"
+#include "support/docstream.h"
#include "support/lassert.h"
+#include "support/lyxalgo.h"
#include "support/qstring_helpers.h"
-#include <boost/next_prior.hpp>
-
using namespace std;
using namespace lyx::support;
: from(from_), to(to_)
{}
- DocRange(Buffer const * buf)
+ DocRange(Buffer const * buf) :
+ from(doc_iterator_begin(buf)),
+ to(doc_iterator_end(buf))
{
- from = doc_iterator_begin(buf);
- to = doc_iterator_end(buf);
to.backwardPos();
}
public:
///
Impl(Compare const & compare)
- : abort_(false), N_(0), M_(0), offset_reverse_diagonal_(0),
+ : abort_(false), n_(0), m_(0), offset_reverse_diagonal_(0),
odd_offset_(0), compare_(compare),
old_buf_(0), new_buf_(0), dest_buf_(0), dest_pars_(0),
recursion_level_(0), nested_inset_level_(0), D_(0)
void writeToDestBuffer(ParagraphList const & copy_pars) const;
/// The length of the old chunk currently processed
- int N_;
+ int n_;
/// The length of the new chunk currently processed
- int M_;
+ int m_;
/// The offset diagonal of the reverse path of the
/// currently processed chunk
int offset_reverse_diagonal_;
pit_type startpit = range.from.pit();
pit_type endpit = range.to.pit();
ParagraphList const & ps_ = range.text()->paragraphs();
- ParagraphList tmp_pars(boost::next(ps_.begin(), startpit),
- boost::next(ps_.begin(), endpit + 1));
+ ParagraphList tmp_pars(lyx::next(ps_.begin(), startpit),
+ lyx::next(ps_.begin(), endpit + 1));
// Remove the end of the last paragraph; afterwards, remove the
// beginning of the first paragraph. Keep this order - there may only
if (os[k].empty() && os_r[kk].empty()) {
// No, there is no snake at all, in which case
// the length of the shortest edit script is M+N.
- LATTEST(2 * D - odd_offset_ == M_ + N_);
+ LATTEST(2 * D - odd_offset_ == m_ + n_);
return NoSnake;
}
DocPair & middle_snake)
{
// The lengths of the old and new chunks.
- N_ = rp.o.length();
- M_ = rp.n.length();
+ n_ = rp.o.length();
+ m_ = rp.n.length();
// Forward paths are centered around the 0-diagonal; reverse paths
// are centered around the diagonal N - M. (Delta in the article)
- offset_reverse_diagonal_ = N_ - M_;
+ offset_reverse_diagonal_ = n_ - m_;
// If the offset is odd, only check for overlap while extending forward
// paths, otherwise only check while extending reverse paths.
nrs.reset(DocIterator());
// In the formula below, the "+ 1" ensures we round like ceil()
- int const D_max = (M_ + N_ + 1)/2;
+ int const D_max = (m_ + n_ + 1)/2;
// D is the number of horizontal and vertical steps, i.e.
// different characters in the old and new chunk.
for (int D = 0; D <= D_max; ++D) {