bool
join (patch& p1, patch p2, tree t) {
//cout << "Join " << p1 << LF << "with " << p2 << LF;
if (get_type (p1) == PATCH_AUTHOR &&
get_type (p2) == PATCH_AUTHOR &&
get_author (p1) == get_author (p2))
{
double author= get_author (p1);
patch q1= p1[0];
patch q2= p2[0];
bool r= join (q1, q2, t);
if (r) p1= patch (author, q1);
return r;
}
if (get_type (p1) == PATCH_MODIFICATION &&
get_type (p2) == PATCH_MODIFICATION)
{
modification m1= get_modification (p1);
modification m2= get_modification (p2);
modification i2= get_inverse (p2);
modification i1= get_inverse (p1);
bool r= join (m1, m2, t);
bool v= join (i2, i1, clean_apply (p2, clean_apply (p1, t)));
if (r && v) p1= patch (m1, i2);
return r && v;
}
if (get_type (p1) == PATCH_COMPOUND &&
nr_children (p1) > 0 &&
nr_children (remove_set_cursor (p1)) == 1 &&
nr_children (p1[0]) == 1)
{
patch q= p1[0];
bool rf= join (q, p2, t);
if (rf) p1= q;
return rf;
}
if (get_type (p2) == PATCH_COMPOUND &&
nr_children (p2) > 0 &&
nr_children (remove_set_cursor (p2)) == 1 &&
nr_children (p2[0]) == 1)
{
patch q= p2[0];
bool rf= join (p1, q, t);
if (rf) {
array<patch> a= children (p1);
array<patch> b= children (p2);
p1= patch (append (a, range (b, 1, N(b))));
}
return rf;
}
return false;
}
patch
remove_set_cursor (patch p) {
switch (get_type (p)) {
case PATCH_MODIFICATION:
if (get_modification (p)->k != MOD_SET_CURSOR) return copy (p);
return patch (array<patch> ());
case PATCH_COMPOUND:
{
array<patch> r;
for (int i=0; i<N(p); i++) {
patch q= remove_set_cursor (p[i]);
r << children (q);
}
if (N(r) == 1) return r[0];
return patch (r);
}
case PATCH_BRANCH:
case PATCH_BIRTH:
return copy (p);
case PATCH_AUTHOR:
{
patch q= remove_set_cursor (p[0]);
if (nr_children (q) == 0) return q;
else return patch (get_author (p), q);
}
default:
FAILED ("unsupported patch type");
}
return p;
}
patch
invert (patch p, tree t) {
switch (get_type (p)) {
case PATCH_MODIFICATION:
return patch (get_inverse (p), get_modification (p));
case PATCH_BRANCH:
ASSERT (N(p) <= 1, "ambiguous application");
case PATCH_COMPOUND:
{
int i, n=N(p);
array<patch> r(n);
for (i=0; i<n; i++) {
r[n-1-i]= invert (p[i], t);
t= clean_apply (p[i], t);
}
return patch (get_type (p) == PATCH_BRANCH, r);
}
case PATCH_BIRTH:
return patch (get_author (p), !get_birth (p));
case PATCH_AUTHOR:
return patch (get_author (p), invert (p[0], t));
default:
FAILED ("unsupported patch type");
return patch ();
}
}
void
insert (array<patch>& a, patch p) {
if (get_type (p) == PATCH_COMPOUND) {
int i, n= N(p);
for (i=0; i<n; i++)
insert (a, p[i]);
}
else if (get_type (p) == PATCH_MODIFICATION &&
N(a) > 0 &&
get_type (a[N(a)-1]) == PATCH_MODIFICATION &&
(get_inverse (a[N(a)-1]) == get_modification (p) &&
get_modification (a[N(a)-1]) == get_inverse (p)))
{
// cout << "Cancel " << a[N(a)-1] << " against " << p << "\n";
a->resize (N(a) - 1);
}
else a << p;
}
bool
operator == (patch p1, patch p2) {
if (get_type (p1) != get_type (p2)) return false;
switch (get_type (p1)) {
case PATCH_MODIFICATION:
return get_modification (p1) == get_modification (p2) &&
get_inverse (p1) == get_inverse (p2);
case PATCH_COMPOUND:
case PATCH_BRANCH:
if (N(p1) != N(p2)) return false;
for (int i=0; i<N(p1); i++)
if (p1[i] != p2[i]) return false;
return true;
case PATCH_BIRTH:
return get_birth (p1) == get_birth (p2) &&
get_author (p1) == get_author (p2);
case PATCH_AUTHOR:
return get_author (p1) == get_author (p2) && p1[0] == p2[0];
default:
FAILED ("unsupported patch type");
}
return false;
}
bool
does_modify (patch p) {
switch (get_type (p)) {
case PATCH_MODIFICATION:
return get_modification (p)->k != MOD_SET_CURSOR;
case PATCH_COMPOUND:
case PATCH_BRANCH:
for (int i=0; i<N(p); i++)
if (does_modify (p[i]))
return true;
return false;
case PATCH_BIRTH:
case PATCH_AUTHOR:
return false;
default:
return true;
}
}
void
apply (patch p, tree& t) {
switch (get_type (p)) {
case PATCH_MODIFICATION:
apply (t, get_modification (p));
break;
case PATCH_BRANCH:
ASSERT (N(p) <= 1, "ambiguous application");
case PATCH_COMPOUND:
case PATCH_AUTHOR:
for (int i=0; i<N(p); i++)
apply (p[i], t);
break;
case PATCH_BIRTH:
break;
default:
FAILED ("unsupported patch type");
}
}
tree
clean_apply (patch p, tree t) {
switch (get_type (p)) {
case PATCH_MODIFICATION:
return clean_apply (t, get_modification (p));
case PATCH_BRANCH:
ASSERT (N(p) <= 1, "ambiguous application");
case PATCH_COMPOUND:
case PATCH_AUTHOR:
for (int i=0; i<N(p); i++)
t= clean_apply (p[i], t);
return t;
case PATCH_BIRTH:
return t;
default:
FAILED ("unsupported patch type");
return t;
}
}
path
cursor_hint (patch p, tree t) {
switch (get_type (p)) {
case PATCH_MODIFICATION:
return cursor_hint (get_modification (p), t);
case PATCH_COMPOUND:
for (int i=0; i<N(p); i++) {
path r= cursor_hint (p[i], t);
if (!is_nil (r)) return r;
}
return path ();
case PATCH_BRANCH:
if (N(p) == 0) return path ();
case PATCH_AUTHOR:
return cursor_hint (p[0], t);
case PATCH_BIRTH:
return path ();
default:
FAILED ("unsupported patch type");
}
return path ();
}
patch
copy (patch p) {
switch (get_type (p)) {
case PATCH_MODIFICATION:
return patch (copy (get_modification (p)), copy (get_inverse (p)));
case PATCH_COMPOUND:
case PATCH_BRANCH:
{
int i, n= N(p);
array<patch> r (n);
for (i=0; i<N(p); i++) r[i]= copy (p[i]);
return patch (get_type (p) == PATCH_BRANCH, r);
}
case PATCH_BIRTH:
return p;
case PATCH_AUTHOR:
return patch (get_author (p), copy (p[0]));
default:
FAILED ("unsupported patch type");
}
return p;
}
tm_ostream&
operator << (tm_ostream& out, patch p) {
switch (get_type (p)) {
case PATCH_MODIFICATION:
out << get_modification (p) << " -- " << get_inverse (p);
break;
case PATCH_COMPOUND:
if (N(p) == 0) out << "No children";
else {
out << "Composite" << INDENT;
for (int i=0; i<N(p); i++)
out << LF << p[i];
out << UNINDENT;
}
break;
case PATCH_BRANCH:
if (N(p) == 0) out << "No branches";
else for (int i=0; i<N(p); i++) {
if (i != 0) out << LF;
out << "Branch " << i << INDENT << LF << p[i] << UNINDENT;
}
break;
case PATCH_BIRTH:
if (get_birth (p)) out << "Birth ";
else out << "Death ";
out << get_author (p);
break;
case PATCH_AUTHOR:
out << "Author " << get_author (p) << INDENT << LF;
out << p[0];
out << UNINDENT;
break;
default:
FAILED ("unsupported patch type");
}
return out;
}
bool
is_applicable (patch p, tree t) {
switch (get_type (p)) {
case PATCH_MODIFICATION:
return is_applicable (t, get_modification (p));
case PATCH_COMPOUND:
for (int i=0; i<N(p); i++) {
if (!is_applicable (p[i], t)) return false;
t= clean_apply (p[i], t);
}
return true;
case PATCH_BRANCH:
case PATCH_AUTHOR:
for (int i=0; i<N(p); i++)
if (!is_applicable (p[i], t))
return false;
return true;
case PATCH_BIRTH:
return true;
default:
FAILED ("unsupported patch type");
return false;
}
}
bool
swap (patch& p1, patch& p2, double a1, double a2) {
if (is_nil (p1) || is_nil (p2)) return false;
if (get_type (p1) == PATCH_BRANCH)
return false;
if (get_type (p2) == PATCH_BRANCH)
return false;
if (get_type (p1) == PATCH_COMPOUND) {
int n= N(p1);
array<patch> a (n);
for (int i=0; i<n; i++) a[i]= p1[i];
for (int i=n-1; i>=0; i--) {
if (!swap (a[i], p2, a1, a2)) return false;
swap_basic (a[i], p2);
}
p1= p2;
p2= patch (a);
return true;
}
if (get_type (p2) == PATCH_COMPOUND) {
int n= N(p2);
array<patch> a (n);
for (int i=0; i<n; i++) a[i]= p2[i];
for (int i=0; i<n; i++) {
if (!swap (p1, a[i], a1, a2)) return false;
swap_basic (p1, a[i]);
}
p2= p1;
p1= patch (a);
return true;
}
if (get_type (p1) == PATCH_AUTHOR) {
patch s= p1[0];
bool r= swap (s, p2, get_author (p1), a2);
p2= patch (get_author (p1), p2);
p1= s;
return r;
}
if (get_type (p2) == PATCH_AUTHOR) {
patch s= p2[0];
bool r= swap (p1, s, a1, get_author (p2));
p1= patch (get_author (p2), p1);
p2= s;
return r;
}
if (get_type (p1) == PATCH_BIRTH) {
if (get_author (p1) == a2) return false;
return swap_basic (p1, p2);
}
if (get_type (p2) == PATCH_BIRTH) {
if (get_author (p2) == a1) return false;
return swap_basic (p1, p2);
}
if (get_type (p1) == PATCH_MODIFICATION &&
get_type (p2) == PATCH_MODIFICATION)
{
modification m1= get_modification (p1);
modification m2= get_modification (p2);
modification i1= get_inverse (p1);
modification i2= get_inverse (p2);
bool r= swap (m1, m2);
bool v= swap (i2, i1);
p1= patch (m1, i1);
p2= patch (m2, i2);
return r && v && possible_inverse (m1, i1) && possible_inverse (m2, i2);
}
FAILED ("invalid situation");
return false;
}
