ardour/libs/temporal/range.cc

120 lines
3.5 KiB
C++

/*
Copyright (C) 2017 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef NDEBUG
#include <sstream>
#endif
#include "temporal/range.h"
using namespace Temporal;
/** Subtract the ranges in `sub' from this range returning the result.
*/
RangeList
Range::subtract (RangeList & sub) const
{
/* Start with the input range */
RangeList result;
result.add (*this);
if (sub.empty () || empty()) {
return result;
}
RangeList::List s = sub.get ();
/* The basic idea here is to keep a list of the result ranges, and subtract
the bits of `sub' from them one by one.
*/
for (typename RangeList::List::const_iterator i = s.begin(); i != s.end(); ++i) {
/* Here's where we'll put the new current result after subtracting *i from it */
RangeList new_result;
typename RangeList::List r = result.get ();
/* Work on all parts of the current result using this range *i */
for (typename RangeList::List::const_iterator j = r.begin(); j != r.end(); ++j) {
switch (coverage_exclusive_ends (j->start(), j->end(), i->start(), i->end())) {
case OverlapNone:
/* The thing we're subtracting (*i) does not overlap this bit of the result (*j),
so pass it through.
*/
new_result.add (*j);
break;
case OverlapInternal:
/* Internal overlap of the thing we're subtracting (*i) from this bit of the result,
so we should end up with two bits of (*j) left over, from the start of (*j) to
the start of (*i), and from the end of (*i) to the end of (*j).
*/
assert (j->start() < i->start());
assert (j->end() > i->end());
new_result.add (Range (j->start(), i->start()));
new_result.add (Range (i->end(), j->end()));
break;
case OverlapStart:
/* The bit we're subtracting (*i) overlaps the start of the bit of the result (*j),
* so we keep only the part of of (*j) from after the end of (*i)
*/
assert (i->end() < j->end());
new_result.add (Range (i->end(), j->end()));
break;
case OverlapEnd:
/* The bit we're subtracting (*i) overlaps the end of the bit of the result (*j),
* so we keep only the part of of (*j) from before the start of (*i)
*/
assert (j->start() < i->start());
new_result.add (Range (j->start(), i->start()));
break;
case OverlapExternal:
/* total overlap of the bit we're subtracting with the result bit, so the
result bit is completely removed; do nothing */
break;
}
}
new_result.coalesce ();
result = new_result;
}
return result;
}
timepos_t
Range::squish (timepos_t const & t) const
{
if (t < _end) {
return t;
}
timepos_t start = _start;
start.set_time_domain (t.time_domain());
return start + (start.distance (t) % length());
}
template<> OverlapType Temporal::coverage_exclusive_ends<int64_t> (int64_t sa, int64_t eaE, int64_t sb, int64_t ebE)
{
/* convert end positions to inclusive */
return coverage_inclusive_ends (sa, eaE-1, sb, ebE-1);
}