Skip to content

Commit 9f233ba

Browse files
kevinlanokevinlano
authored
further refactorings
1 parent 31f091d commit 9f233ba

2 files changed

Lines changed: 251 additions & 4 deletions

File tree

‎Expression.java‎

Lines changed: 212 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3353,7 +3353,7 @@ static public Expression simplify(final String op,
33533353
return Expression.simplifyStringExpression(op, arg);
33543354
}
33553355

3356-
return arg;
3356+
return new UnaryExpression(op, arg);
33573357
}
33583358

33593359
public static Expression simplifyStringExpression(String op,
@@ -4163,8 +4163,10 @@ public static Expression simplifyPlus(
41634163
}
41644164

41654165
public static Expression simplifyMinus(Expression e1, Expression e2)
4166-
{ if (e1 == null) { return simplifyUnaryMinus(e2); }
4167-
if (e2 == null) { return e1; }
4166+
{ if (e1 == null)
4167+
{ return simplifyUnaryMinus(e2); }
4168+
if (e2 == null)
4169+
{ return e1; }
41684170

41694171
// also for strings
41704172

@@ -5731,10 +5733,21 @@ public static Expression simplifyAny(Expression src)
57315733
return uarg;
57325734
}
57335735

5736+
if (src instanceof BasicExpression &&
5737+
((BasicExpression) src).getData().equals("subrange") &&
5738+
"Integer".equals(
5739+
((BasicExpression) src).getObjectRef() + ""))
5740+
{ BasicExpression lcol = (BasicExpression) src;
5741+
Vector pars = lcol.getParameters();
5742+
if (pars != null && pars.size() > 0)
5743+
{ return (Expression) pars.get(0); }
5744+
}
5745+
57345746
if (src instanceof UnaryExpression)
57355747
{ UnaryExpression uexpr = (UnaryExpression) src;
57365748
String uop = uexpr.getOperator();
5737-
if ("->asSet".equals(uop) || "->asSequence".equals(uop) ||
5749+
if ("->asSet".equals(uop) ||
5750+
"->asSequence".equals(uop) ||
57385751
"->oclAsSet".equals(uop) ||
57395752
"->oclAsSequence".equals(uop))
57405753
{ System.err.println("!! OES: Redundant operator " + uop + " in: " + src + "->any()");
@@ -5794,6 +5807,39 @@ public static Expression simplifyReverse(Expression src)
57945807
return new UnaryExpression("->reverse", src);
57955808
}
57965809

5810+
public static Expression simplifySort(Expression src)
5811+
{ // sq->reverse()->sort() is sq->sort()
5812+
// Integer.subrange(a,b)->sort() is Integer.subrange(a,b)
5813+
// sq->sort()->sort() is sq->sort()
5814+
5815+
if (src instanceof BasicExpression &&
5816+
((BasicExpression) src).getData().equals("subrange") &&
5817+
"Integer".equals(
5818+
((BasicExpression) src).getObjectRef() + ""))
5819+
{ BasicExpression lcol = (BasicExpression) src;
5820+
System.err.println("!! OES: Redundant operator ->sort() in: " + src + "->sort()");
5821+
return lcol;
5822+
}
5823+
5824+
5825+
if (src instanceof UnaryExpression)
5826+
{ UnaryExpression usrc = (UnaryExpression) src;
5827+
String uop = usrc.getOperator();
5828+
5829+
if ("->reverse".equals(uop) ||
5830+
"->sort".equals(uop) ||
5831+
"->asSequence".equals(uop) ||
5832+
"->oclAsSequence".equals(uop))
5833+
{ Expression uarg = usrc.getArgument();
5834+
System.err.println("!! OES: Redundant operator " + uop + " in: " + src + "->sort()");
5835+
5836+
return uarg;
5837+
}
5838+
}
5839+
5840+
return new UnaryExpression("->sort", src);
5841+
}
5842+
57975843
public static Expression simplifyFront(Expression src)
57985844
{ // sq->front()->front() is sq.subrange(1, sq->size()-2)
57995845
// sq->tail()->front() is sq.subrange(2,sq->size()-1)
@@ -6687,6 +6733,96 @@ else if (e instanceof BasicExpression)
66876733
return new UnaryExpression("not",e);
66886734
} // and other cases
66896735

6736+
protected static Expression simplifyIsEmpty(
6737+
Expression re,
6738+
Vector vars)
6739+
{ if (re instanceof SetExpression)
6740+
{ SetExpression rse = (SetExpression) re;
6741+
6742+
if (rse.isEmpty())
6743+
{ return new BasicExpression(true); }
6744+
6745+
return new BasicExpression(false);
6746+
} // x : a \/ b as x : a or x : b etc?
6747+
6748+
if (re instanceof UnaryExpression)
6749+
{ UnaryExpression ue = (UnaryExpression) re;
6750+
String uop = ue.getOperator();
6751+
if ("->reverse".equals(uop) || "->sort".equals(uop) ||
6752+
"->asSet".equals(uop) || "->oclAsSet".equals(uop) ||
6753+
"->asSequence".equals(uop) ||
6754+
"->oclAsSequence".equals(uop))
6755+
{ return simplifyIsEmpty(ue.getArgument(), vars); }
6756+
}
6757+
6758+
if (re instanceof BinaryExpression)
6759+
{ BinaryExpression ue = (BinaryExpression) re;
6760+
String uop = ue.getOperator();
6761+
6762+
if ("->append".equals(uop) ||
6763+
"->including".equals(uop) ||
6764+
"->prepend".equals(uop))
6765+
{ return new BasicExpression(false); }
6766+
6767+
if ("->sortedBy".equals(uop) || "->collect".equals(uop))
6768+
{ return simplifyIsEmpty(ue.getLeft(), vars); }
6769+
6770+
if ("|sortedBy".equals(uop) ||
6771+
"|C".equals(uop))
6772+
{ BinaryExpression arg =
6773+
(BinaryExpression) ue.getLeft();
6774+
return simplifyIsEmpty(arg.getRight(), vars);
6775+
}
6776+
}
6777+
6778+
return new UnaryExpression("->isEmpty",re);
6779+
}
6780+
6781+
protected static Expression simplifyNotEmpty(
6782+
Expression re,
6783+
Vector vars)
6784+
{ if (re instanceof SetExpression)
6785+
{ SetExpression rse = (SetExpression) re;
6786+
6787+
if (rse.isEmpty())
6788+
{ return new BasicExpression(false); }
6789+
6790+
return new BasicExpression(true);
6791+
} // x : a \/ b as x : a or x : b etc?
6792+
6793+
if (re instanceof UnaryExpression)
6794+
{ UnaryExpression ue = (UnaryExpression) re;
6795+
String uop = ue.getOperator();
6796+
if ("->reverse".equals(uop) || "->sort".equals(uop) ||
6797+
"->asSet".equals(uop) || "->oclAsSet".equals(uop) ||
6798+
"->asSequence".equals(uop) ||
6799+
"->oclAsSequence".equals(uop))
6800+
{ return simplifyNotEmpty(ue.getArgument(), vars); }
6801+
}
6802+
6803+
if (re instanceof BinaryExpression)
6804+
{ BinaryExpression ue = (BinaryExpression) re;
6805+
String uop = ue.getOperator();
6806+
6807+
if ("->append".equals(uop) ||
6808+
"->including".equals(uop) ||
6809+
"->prepend".equals(uop))
6810+
{ return new BasicExpression(true); }
6811+
6812+
if ("->sortedBy".equals(uop) || "->collect".equals(uop))
6813+
{ return simplifyNotEmpty(ue.getLeft(), vars); }
6814+
6815+
if ("|sortedBy".equals(uop) ||
6816+
"|C".equals(uop))
6817+
{ BinaryExpression arg =
6818+
(BinaryExpression) ue.getLeft();
6819+
return simplifyNotEmpty(arg.getRight(), vars);
6820+
}
6821+
}
6822+
6823+
return new UnaryExpression("->notEmpty",re);
6824+
}
6825+
66906826
private static Expression simplifyIn(Expression le,
66916827
Expression re,
66926828
Vector vars)
@@ -6706,6 +6842,30 @@ private static Expression simplifyIn(Expression le,
67066842
return rse.includes(le);
67076843
} // x : a \/ b as x : a or x : b etc?
67086844

6845+
if (re instanceof UnaryExpression)
6846+
{ UnaryExpression ue = (UnaryExpression) re;
6847+
String uop = ue.getOperator();
6848+
if ("->reverse".equals(uop) || "->sort".equals(uop) ||
6849+
"->asSet".equals(uop) || "->oclAsSet".equals(uop) ||
6850+
"->asSequence".equals(uop) ||
6851+
"->oclAsSequence".equals(uop))
6852+
{ return simplifyIn(le, ue.getArgument(), vars); }
6853+
}
6854+
6855+
if (re instanceof BinaryExpression)
6856+
{ BinaryExpression ue = (BinaryExpression) re;
6857+
String uop = ue.getOperator();
6858+
6859+
if ("->sortedBy".equals(uop))
6860+
{ return simplifyIn(le, ue.getLeft(), vars); }
6861+
6862+
if ("|sortedBy".equals(uop))
6863+
{ BinaryExpression arg =
6864+
(BinaryExpression) ue.getLeft();
6865+
return simplifyIn(le, arg.getRight(), vars);
6866+
}
6867+
}
6868+
67096869
return new BinaryExpression(":",le,re);
67106870
}
67116871

@@ -6729,6 +6889,30 @@ private static Expression simplifyNotIn(Expression le,
67296889
return Expression.simplifyNot(isin);
67306890
}
67316891

6892+
if (re instanceof UnaryExpression)
6893+
{ UnaryExpression ue = (UnaryExpression) re;
6894+
String uop = ue.getOperator();
6895+
if ("->reverse".equals(uop) || "->sort".equals(uop) ||
6896+
"->asSet".equals(uop) || "->oclAsSet".equals(uop) ||
6897+
"->asSequence".equals(uop) ||
6898+
"->oclAsSequence".equals(uop))
6899+
{ return simplifyNotIn(le, ue.getArgument(), vars); }
6900+
}
6901+
6902+
if (re instanceof BinaryExpression)
6903+
{ BinaryExpression ue = (BinaryExpression) re;
6904+
String uop = ue.getOperator();
6905+
6906+
if ("->sortedBy".equals(uop))
6907+
{ return simplifyNotIn(le, ue.getLeft(), vars); }
6908+
6909+
if ("|sortedBy".equals(uop))
6910+
{ BinaryExpression arg =
6911+
(BinaryExpression) ue.getLeft();
6912+
return simplifyNotIn(le, arg.getRight(), vars);
6913+
}
6914+
}
6915+
67326916
return new BinaryExpression("/:",le,re);
67336917
}
67346918

@@ -6750,6 +6934,30 @@ private static Expression simplifyIn(Expression le,
67506934
return rse.includes(le);
67516935
} // x : a \/ b as x : a or x : b etc?
67526936

6937+
if (re instanceof UnaryExpression)
6938+
{ UnaryExpression ue = (UnaryExpression) re;
6939+
String uop = ue.getOperator();
6940+
if ("->reverse".equals(uop) || "->sort".equals(uop) ||
6941+
"->asSet".equals(uop) || "->oclAsSet".equals(uop) ||
6942+
"->asSequence".equals(uop) ||
6943+
"->oclAsSequence".equals(uop))
6944+
{ return simplifyIn(le, ue.getArgument()); }
6945+
}
6946+
6947+
if (re instanceof BinaryExpression)
6948+
{ BinaryExpression ue = (BinaryExpression) re;
6949+
String uop = ue.getOperator();
6950+
6951+
if ("->sortedBy".equals(uop))
6952+
{ return simplifyIn(le, ue.getLeft()); }
6953+
6954+
if ("|sortedBy".equals(uop))
6955+
{ BinaryExpression arg =
6956+
(BinaryExpression) ue.getLeft();
6957+
return simplifyIn(le, arg.getRight());
6958+
}
6959+
}
6960+
67536961
return new BinaryExpression(":",le,re);
67546962
}
67556963

‎UnaryExpression.java‎

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8233,6 +8233,45 @@ public Expression simplify()
82338233
if ("->size".equals(operator))
82348234
{ return simplifySize(argsimp); }
82358235

8236+
if ("->isEmpty".equals(operator))
8237+
{ return Expression.simplifyIsEmpty(argsimp,null); }
8238+
8239+
if ("->notEmpty".equals(operator))
8240+
{ return Expression.simplifyNotEmpty(argsimp,null); }
8241+
8242+
if ("->sort".equals(operator))
8243+
{ return Expression.simplifySort(argsimp); }
8244+
8245+
if ("->reverse".equals(operator))
8246+
{ return Expression.simplifyReverse(argsimp); }
8247+
8248+
if ("->first".equals(operator))
8249+
{ return Expression.simplifyFirst(argsimp); }
8250+
8251+
if ("->last".equals(operator))
8252+
{ return Expression.simplifyLast(argsimp); }
8253+
8254+
if ("->front".equals(operator))
8255+
{ return Expression.simplifyFront(argsimp); }
8256+
8257+
if ("->tail".equals(operator))
8258+
{ return Expression.simplifyTail(argsimp); }
8259+
8260+
if ("->max".equals(operator))
8261+
{ return Expression.simplifyMax(argsimp); }
8262+
8263+
if ("->min".equals(operator))
8264+
{ return Expression.simplifyMin(argsimp); }
8265+
8266+
if ("->sum".equals(operator))
8267+
{ return Expression.simplifySum(argsimp); }
8268+
8269+
if ("->prd".equals(operator))
8270+
{ return Expression.simplifyPrd(argsimp); }
8271+
8272+
if ("->average".equals(operator))
8273+
{ return Expression.simplifyAverage(argsimp); }
8274+
82368275
UnaryExpression clne = (UnaryExpression) clone();
82378276
clne.argument = argsimp;
82388277
return clne;

0 commit comments

Comments
 (0)