style: fix indentation

Julia Pham · Julia Pham · commit c4506ebeb5d0 · 2025-12-08T17:34:07.000+01:00
diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java
@@ -29,19 +29,18 @@ public AndConstraint(Constraint left, Constraint right) {
     }
 
     public Constraint getLeft() {
-        if (children.isEmpty()){
+        if (children.isEmpty()) {
             throw new ParseError("Left child can not be returned because there are no children.");
-        }
-        else{
+        } else {
             return children.get(0);
         }
     }
 
     public Constraint getRight() {
-        if (children.isEmpty() || children.size() < 2){
-            throw new ParseError("Right child can not be returned because there are less than two children.");;
-        }
-        else{
+        if (children.isEmpty() || children.size() < 2) {
+            throw new ParseError("Right child can not be returned because there are less than two children.");
+            ;
+        } else {
             return children.get(children.size() - 1);
         }
     }
@@ -53,29 +52,27 @@ public List<Constraint> getChildren() {
     public void setLeft(Constraint left) {
         if (children.isEmpty()) {
             children.add(left);
-        }
-        else {
+        } else {
             children.set(0, left);
         }
     }
 
-    public void setRight(Constraint right){
+    public void setRight(Constraint right) {
         if (children.size() < 2) {
             if (children.size() < 1) {
                 children.add(null);
             }
             children.add(right);
-        }
-        else {
+        } else {
             children.set(children.size() - 1, right);
         }
     }
 
     @Override
     public String toString(boolean withSubmodels, String currentAlias) {
-        return  children.stream()
-        .map(c -> AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, c, withSubmodels, currentAlias))
-        .collect(Collectors.joining(" & "));
+        return children.stream()
+                .map(c -> AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, c, withSubmodels, currentAlias))
+                .collect(Collectors.joining(" & "));
     }
 
     @Override
@@ -85,8 +82,8 @@ public List<Constraint> getConstraintSubParts() {
 
     @Override
     public void replaceConstraintSubPart(Constraint oldSubConstraint, Constraint newSubConstraint) {
-        for (int i = 0; i< children.size(); i++) {
-            if (children.get(i) == oldSubConstraint){
+        for (int i = 0; i < children.size(); i++) {
+            if (children.get(i) == oldSubConstraint) {
                 children.set(i, newSubConstraint);
             }
         }
@@ -101,7 +98,7 @@ public Constraint clone() {
         return clone;
     }
 
-    public void addChild(Constraint constraint){
+    public void addChild(Constraint constraint) {
         if (constraint != null) {
             children.add(constraint);
         }
@@ -111,7 +108,7 @@ public void addChild(Constraint constraint){
     public int hashCode(int level) {
         final int prime = 31;
         int result = prime * level;
-        for(Constraint c: children) {
+        for (Constraint c : children) {
             result = prime * result + (c == null ? 0 : c.hashCode(1 + level));
         }
         return result;
@@ -132,7 +129,7 @@ public boolean equals(Object obj) {
     @Override
     public List<VariableReference> getReferences() {
         List<VariableReference> references = new ArrayList<>();
-        for(Constraint c: children){
+        for (Constraint c : children) {
             references.addAll(c.getReferences());
         }
         return references;
diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java
@@ -28,19 +28,17 @@ public OrConstraint(Constraint left, Constraint right) {
     }
 
     public Constraint getLeft() {
-        if (children.isEmpty()){
+        if (children.isEmpty()) {
             throw new ParseError("Left child can not be returned because there are no children.");
-        }
-        else{
+        } else {
             return children.get(0);
         }
     }
 
     public Constraint getRight() {
-        if (children.isEmpty() || children.size() < 2){
+        if (children.isEmpty() || children.size() < 2) {
             throw new ParseError("RIght child can not be returned because there are less than two children.");
-        }
-        else{
+        } else {
             return children.get(children.size() - 1);
         }
     }
@@ -52,29 +50,27 @@ public List<Constraint> getChildren() {
     public void setLeft(Constraint left) {
         if (children.isEmpty()) {
             children.add(left);
-        }
-        else {
+        } else {
             children.set(0, left);
         }
     }
 
-    public void setRight(Constraint right){
+    public void setRight(Constraint right) {
         if (children.size() < 2) {
             if (children.size() < 1) {
                 children.add(null);
             }
             children.add(right);
-        }
-        else {
+        } else {
             children.set(children.size() - 1, right);
         }
     }
 
     @Override
     public String toString(boolean withSubmodels, String currentAlias) {
         return children.stream()
-        .map(c -> AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, c, withSubmodels, currentAlias))
-        .collect(Collectors.joining(" | "));
+                .map(c -> AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, c, withSubmodels, currentAlias))
+                .collect(Collectors.joining(" | "));
     }
 
     @Override
@@ -84,8 +80,8 @@ public List<Constraint> getConstraintSubParts() {
 
     @Override
     public void replaceConstraintSubPart(Constraint oldSubConstraint, Constraint newSubConstraint) {
-        for (int i = 0; i< children.size(); i++) {
-            if (children.get(i) == oldSubConstraint){
+        for (int i = 0; i < children.size(); i++) {
+            if (children.get(i) == oldSubConstraint) {
                 children.set(i, newSubConstraint);
             }
         }
@@ -100,7 +96,7 @@ public Constraint clone() {
         return clone;
     }
 
-    public void addChild(Constraint constraint){
+    public void addChild(Constraint constraint) {
         if (constraint != null) {
             children.add(constraint);
         }
@@ -110,7 +106,7 @@ public void addChild(Constraint constraint){
     public int hashCode(int level) {
         final int prime = 31;
         int result = prime * level;
-        for(Constraint c: children) {
+        for (Constraint c : children) {
             result = prime * result + (c == null ? 0 : c.hashCode(1 + level));
         }
         return result;
@@ -131,7 +127,7 @@ public boolean equals(Object obj) {
     @Override
     public List<VariableReference> getReferences() {
         List<VariableReference> references = new ArrayList<>();
-        for(Constraint c: children){
+        for (Constraint c : children) {
             references.addAll(c.getReferences());
         }
         return references;

Original file line number	Diff line number	Diff line change
`@@ -29,19 +29,18 @@ public AndConstraint(Constraint left, Constraint right) {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`public Constraint getLeft() {`
`32`		`- if (children.isEmpty()){`
	`32`	`+ if (children.isEmpty()) {`
`33`	`33`	`throw new ParseError("Left child can not be returned because there are no children.");`
`34`		`- }`
`35`		`- else{`
	`34`	`+ } else {`
`36`	`35`	`return children.get(0);`
`37`	`36`	`}`
`38`	`37`	`}`
`39`	`38`
`40`	`39`	`public Constraint getRight() {`
`41`		`- if (children.isEmpty() \|\| children.size() < 2){`
`42`		`- throw new ParseError("Right child can not be returned because there are less than two children.");;`
`43`		`- }`
`44`		`- else{`
	`40`	`+ if (children.isEmpty() \|\| children.size() < 2) {`
	`41`	`+ throw new ParseError("Right child can not be returned because there are less than two children.");`
	`42`	`+ ;`
	`43`	`+ } else {`
`45`	`44`	`return children.get(children.size() - 1);`
`46`	`45`	`}`
`47`	`46`	`}`
`@@ -53,29 +52,27 @@ public List<Constraint> getChildren() {`
`53`	`52`	`public void setLeft(Constraint left) {`
`54`	`53`	`if (children.isEmpty()) {`
`55`	`54`	`children.add(left);`
`56`		`- }`
`57`		`- else {`
	`55`	`+ } else {`
`58`	`56`	`children.set(0, left);`
`59`	`57`	`}`
`60`	`58`	`}`
`61`	`59`
`62`		`- public void setRight(Constraint right){`
	`60`	`+ public void setRight(Constraint right) {`
`63`	`61`	`if (children.size() < 2) {`
`64`	`62`	`if (children.size() < 1) {`
`65`	`63`	`children.add(null);`
`66`	`64`	`}`
`67`	`65`	`children.add(right);`
`68`		`- }`
`69`		`- else {`
	`66`	`+ } else {`
`70`	`67`	`children.set(children.size() - 1, right);`
`71`	`68`	`}`
`72`	`69`	`}`
`73`	`70`
`74`	`71`	`@Override`
`75`	`72`	`public String toString(boolean withSubmodels, String currentAlias) {`
`76`		`- return children.stream()`
`77`		`- .map(c -> AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, c, withSubmodels, currentAlias))`
`78`		`- .collect(Collectors.joining(" & "));`
	`73`	`+ return children.stream()`
	`74`	`+ .map(c -> AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, c, withSubmodels, currentAlias))`
	`75`	`+ .collect(Collectors.joining(" & "));`
`79`	`76`	`}`
`80`	`77`
`81`	`78`	`@Override`
`@@ -85,8 +82,8 @@ public List<Constraint> getConstraintSubParts() {`
`85`	`82`
`86`	`83`	`@Override`
`87`	`84`	`public void replaceConstraintSubPart(Constraint oldSubConstraint, Constraint newSubConstraint) {`
`88`		`- for (int i = 0; i< children.size(); i++) {`
`89`		`- if (children.get(i) == oldSubConstraint){`
	`85`	`+ for (int i = 0; i < children.size(); i++) {`
	`86`	`+ if (children.get(i) == oldSubConstraint) {`
`90`	`87`	`children.set(i, newSubConstraint);`
`91`	`88`	`}`
`92`	`89`	`}`
`@@ -101,7 +98,7 @@ public Constraint clone() {`
`101`	`98`	`return clone;`
`102`	`99`	`}`
`103`	`100`
`104`		`- public void addChild(Constraint constraint){`
	`101`	`+ public void addChild(Constraint constraint) {`
`105`	`102`	`if (constraint != null) {`
`106`	`103`	`children.add(constraint);`
`107`	`104`	`}`
`@@ -111,7 +108,7 @@ public void addChild(Constraint constraint){`
`111`	`108`	`public int hashCode(int level) {`
`112`	`109`	`final int prime = 31;`
`113`	`110`	`int result = prime * level;`
`114`		`- for(Constraint c: children) {`
	`111`	`+ for (Constraint c : children) {`
`115`	`112`	`result = prime * result + (c == null ? 0 : c.hashCode(1 + level));`
`116`	`113`	`}`
`117`	`114`	`return result;`
`@@ -132,7 +129,7 @@ public boolean equals(Object obj) {`
`132`	`129`	`@Override`
`133`	`130`	`public List<VariableReference> getReferences() {`
`134`	`131`	`List<VariableReference> references = new ArrayList<>();`
`135`		`- for(Constraint c: children){`
	`132`	`+ for (Constraint c : children) {`
`136`	`133`	`references.addAll(c.getReferences());`
`137`	`134`	`}`
`138`	`135`	`return references;`
Original file line number	Diff line number	Diff line change
`@@ -28,19 +28,17 @@ public OrConstraint(Constraint left, Constraint right) {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`public Constraint getLeft() {`
`31`		`- if (children.isEmpty()){`
	`31`	`+ if (children.isEmpty()) {`
`32`	`32`	`throw new ParseError("Left child can not be returned because there are no children.");`
`33`		`- }`
`34`		`- else{`
	`33`	`+ } else {`
`35`	`34`	`return children.get(0);`
`36`	`35`	`}`
`37`	`36`	`}`
`38`	`37`
`39`	`38`	`public Constraint getRight() {`
`40`		`- if (children.isEmpty() \|\| children.size() < 2){`
	`39`	`+ if (children.isEmpty() \|\| children.size() < 2) {`
`41`	`40`	`throw new ParseError("RIght child can not be returned because there are less than two children.");`
`42`		`- }`
`43`		`- else{`
	`41`	`+ } else {`
`44`	`42`	`return children.get(children.size() - 1);`
`45`	`43`	`}`
`46`	`44`	`}`
`@@ -52,29 +50,27 @@ public List<Constraint> getChildren() {`
`52`	`50`	`public void setLeft(Constraint left) {`
`53`	`51`	`if (children.isEmpty()) {`
`54`	`52`	`children.add(left);`
`55`		`- }`
`56`		`- else {`
	`53`	`+ } else {`
`57`	`54`	`children.set(0, left);`
`58`	`55`	`}`
`59`	`56`	`}`
`60`	`57`
`61`		`- public void setRight(Constraint right){`
	`58`	`+ public void setRight(Constraint right) {`
`62`	`59`	`if (children.size() < 2) {`
`63`	`60`	`if (children.size() < 1) {`
`64`	`61`	`children.add(null);`
`65`	`62`	`}`
`66`	`63`	`children.add(right);`
`67`		`- }`
`68`		`- else {`
	`64`	`+ } else {`
`69`	`65`	`children.set(children.size() - 1, right);`
`70`	`66`	`}`
`71`	`67`	`}`
`72`	`68`
`73`	`69`	`@Override`
`74`	`70`	`public String toString(boolean withSubmodels, String currentAlias) {`
`75`	`71`	`return children.stream()`
`76`		`- .map(c -> AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, c, withSubmodels, currentAlias))`
`77`		`- .collect(Collectors.joining(" \| "));`
	`72`	`+ .map(c -> AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, c, withSubmodels, currentAlias))`
	`73`	`+ .collect(Collectors.joining(" \| "));`
`78`	`74`	`}`
`79`	`75`
`80`	`76`	`@Override`
`@@ -84,8 +80,8 @@ public List<Constraint> getConstraintSubParts() {`
`84`	`80`
`85`	`81`	`@Override`
`86`	`82`	`public void replaceConstraintSubPart(Constraint oldSubConstraint, Constraint newSubConstraint) {`
`87`		`- for (int i = 0; i< children.size(); i++) {`
`88`		`- if (children.get(i) == oldSubConstraint){`
	`83`	`+ for (int i = 0; i < children.size(); i++) {`
	`84`	`+ if (children.get(i) == oldSubConstraint) {`
`89`	`85`	`children.set(i, newSubConstraint);`
`90`	`86`	`}`
`91`	`87`	`}`
`@@ -100,7 +96,7 @@ public Constraint clone() {`
`100`	`96`	`return clone;`
`101`	`97`	`}`
`102`	`98`
`103`		`- public void addChild(Constraint constraint){`
	`99`	`+ public void addChild(Constraint constraint) {`
`104`	`100`	`if (constraint != null) {`
`105`	`101`	`children.add(constraint);`
`106`	`102`	`}`
`@@ -110,7 +106,7 @@ public void addChild(Constraint constraint){`
`110`	`106`	`public int hashCode(int level) {`
`111`	`107`	`final int prime = 31;`
`112`	`108`	`int result = prime * level;`
`113`		`- for(Constraint c: children) {`
	`109`	`+ for (Constraint c : children) {`
`114`	`110`	`result = prime * result + (c == null ? 0 : c.hashCode(1 + level));`
`115`	`111`	`}`
`116`	`112`	`return result;`
`@@ -131,7 +127,7 @@ public boolean equals(Object obj) {`
`131`	`127`	`@Override`
`132`	`128`	`public List<VariableReference> getReferences() {`
`133`	`129`	`List<VariableReference> references = new ArrayList<>();`
`134`		`- for(Constraint c: children){`
	`130`	`+ for (Constraint c : children) {`
`135`	`131`	`references.addAll(c.getReferences());`
`136`	`132`	`}`
`137`	`133`	`return references;`