refact: Statements extends List<Statement>

manticore-projects · manticore-projects · commit 9dafae873c77 · 2023-05-17T18:41:38.000+07:00
diff --git a/src/main/java/net/sf/jsqlparser/statement/Statements.java b/src/main/java/net/sf/jsqlparser/statement/Statements.java
@@ -11,21 +11,19 @@
 
 import java.io.Serializable;
 import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
-import java.util.Optional;
 
-public class Statements implements Serializable {
-
-    private List<Statement> statements;
+public class Statements extends ArrayList<Statement> implements Serializable {
 
+    @Deprecated
     public List<Statement> getStatements() {
-        return statements;
+        return this;
     }
 
+    @Deprecated
     public void setStatements(List<Statement> statements) {
-        this.statements = statements;
+        this.clear();
+        this.addAll(statements);
     }
 
     public void accept(StatementVisitor statementVisitor) {
@@ -35,7 +33,7 @@ public void accept(StatementVisitor statementVisitor) {
     @Override
     public String toString() {
         StringBuilder b = new StringBuilder();
-        for (Statement stmt : statements) {
+        for (Statement stmt : this) {
             // IfElseStatements and Blocks control the Semicolons by themselves
             if (stmt instanceof IfElseStatement || stmt instanceof Block) {
                 b.append(stmt).append("\n");
@@ -45,21 +43,4 @@ public String toString() {
         }
         return b.toString();
     }
-
-    public Statements withStatements(List<Statement> statements) {
-        this.setStatements(statements);
-        return this;
-    }
-
-    public Statements addStatements(Statement... statements) {
-        List<Statement> collection = Optional.ofNullable(getStatements()).orElseGet(ArrayList::new);
-        Collections.addAll(collection, statements);
-        return this.withStatements(collection);
-    }
-
-    public Statements addStatements(Collection<? extends Statement> statements) {
-        List<Statement> collection = Optional.ofNullable(getStatements()).orElseGet(ArrayList::new);
-        collection.addAll(statements);
-        return this.withStatements(collection);
-    }
 }
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -737,8 +737,6 @@ Block Block() #Block : {
 
 Statements Statements() #Statements: {
     Statements stmts = new Statements();
-    List<Statement> list = new ArrayList<Statement>();
-    
     IfElseStatement ifElseStatement = null;
     Statement stm = null;
     Statement stm2 = null;
@@ -756,18 +754,18 @@ Statements Statements() #Statements: {
                      <K_ELSE> ( stm2 = SingleStatement() |  stm2 =  Block() ) {  ifElseStatement.setElseStatement(stm2);  }
                  ]
 
-                 { list.add( ifElseStatement ); }
+                 { stmts.add( ifElseStatement ); }
             )
             |
             (
                  stm = SingleStatement() 
                  | stm = Block()
 
                  [ LOOKAHEAD(2)  <ST_SEMICOLON> ]
-            ) { list.add(stm); }
+            ) { stmts.add(stm); }
             |
             LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) } ) stm = UnsupportedStatement()
-            { if ( !((UnsupportedStatement) stm).isEmpty() ) list.add(stm); }
+            { if ( !((UnsupportedStatement) stm).isEmpty() ) stmts.add(stm); }
         )
 
         (
@@ -784,20 +782,20 @@ Statements Statements() #Statements: {
                         <K_ELSE> ( stm2 = SingleStatement() | stm2 = Block() ) {  ifElseStatement.setElseStatement(stm2);  }
                     ]
 
-                    { list.add( ifElseStatement ); }
+                    { stmts.add( ifElseStatement ); }
                )
                |
                (
                     stm = SingleStatement()
                     | stm = Block()
 
                     [ LOOKAHEAD(2)  <ST_SEMICOLON> ]
-               ) { list.add(stm); }
+               ) { stmts.add(stm); }
                |
                // For any reason, we can't LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) } ) here
                // As it will result in a Stack Overflow
                stm = UnsupportedStatement()
-               { if ( !((UnsupportedStatement) stm).isEmpty() ) list.add(stm); }
+               { if ( !((UnsupportedStatement) stm).isEmpty() ) stmts.add(stm); }
             ]
         )*
         <EOF>
@@ -810,7 +808,7 @@ Statements Statements() #Statements: {
         }
     }
     {
-        return stmts.withStatements(list);
+        return stmts;
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -737,8 +737,6 @@ Block Block() #Block : {`
`737`	`737`
`738`	`738`	`Statements Statements() #Statements: {`
`739`	`739`	`Statements stmts = new Statements();`
`740`		`- List<Statement> list = new ArrayList<Statement>();`
`741`		`-`
`742`	`740`	`IfElseStatement ifElseStatement = null;`
`743`	`741`	`Statement stm = null;`
`744`	`742`	`Statement stm2 = null;`
`@@ -756,18 +754,18 @@ Statements Statements() #Statements: {`
`756`	`754`	`<K_ELSE> ( stm2 = SingleStatement() \| stm2 = Block() ) { ifElseStatement.setElseStatement(stm2); }`
`757`	`755`	`]`
`758`	`756`
`759`		`- { list.add( ifElseStatement ); }`
	`757`	`+ { stmts.add( ifElseStatement ); }`
`760`	`758`	`)`
`761`	`759`	`\|`
`762`	`760`	`(`
`763`	`761`	`stm = SingleStatement()`
`764`	`762`	`\| stm = Block()`
`765`	`763`
`766`	`764`	`[ LOOKAHEAD(2) <ST_SEMICOLON> ]`
`767`		`- ) { list.add(stm); }`
	`765`	`+ ) { stmts.add(stm); }`
`768`	`766`	`\|`
`769`	`767`	`LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) } ) stm = UnsupportedStatement()`
`770`		`- { if ( !((UnsupportedStatement) stm).isEmpty() ) list.add(stm); }`
	`768`	`+ { if ( !((UnsupportedStatement) stm).isEmpty() ) stmts.add(stm); }`
`771`	`769`	`)`
`772`	`770`
`773`	`771`	`(`
`@@ -784,20 +782,20 @@ Statements Statements() #Statements: {`
`784`	`782`	`<K_ELSE> ( stm2 = SingleStatement() \| stm2 = Block() ) { ifElseStatement.setElseStatement(stm2); }`
`785`	`783`	`]`
`786`	`784`
`787`		`- { list.add( ifElseStatement ); }`
	`785`	`+ { stmts.add( ifElseStatement ); }`
`788`	`786`	`)`
`789`	`787`	`\|`
`790`	`788`	`(`
`791`	`789`	`stm = SingleStatement()`
`792`	`790`	`\| stm = Block()`
`793`	`791`
`794`	`792`	`[ LOOKAHEAD(2) <ST_SEMICOLON> ]`
`795`		`- ) { list.add(stm); }`
	`793`	`+ ) { stmts.add(stm); }`
`796`	`794`	`\|`
`797`	`795`	`// For any reason, we can't LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) } ) here`
`798`	`796`	`// As it will result in a Stack Overflow`
`799`	`797`	`stm = UnsupportedStatement()`
`800`		`- { if ( !((UnsupportedStatement) stm).isEmpty() ) list.add(stm); }`
	`798`	`+ { if ( !((UnsupportedStatement) stm).isEmpty() ) stmts.add(stm); }`
`801`	`799`	`]`
`802`	`800`	`)*`
`803`	`801`	`<EOF>`
`@@ -810,7 +808,7 @@ Statements Statements() #Statements: {`
`810`	`808`	`}`
`811`	`809`	`}`
`812`	`810`	`{`
`813`		`- return stmts.withStatements(list);`
	`811`	`+ return stmts;`
`814`	`812`	`}`
`815`	`813`	`}`
`816`	`814`