/*
    * Themis: Java Project Framework
    * Copyright 2012-2026. Tony Washer
    *
    * Licensed under the Apache License, Version 2.0 (the "License"); you may not
    * use this file except in compliance with the License.  You may obtain a copy
    * of the License at
    *
    *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
   * License for the specific language governing permissions and limitations under
   * the License.
   */
  package io.github.tonywasher.joceanus.themis.parser.stmt;
  
  import com.github.javaparser.ast.stmt.Statement;
  import io.github.tonywasher.joceanus.oceanus.base.OceanusException;
  import io.github.tonywasher.joceanus.themis.parser.base.ThemisInstance.ThemisId;
  import io.github.tonywasher.joceanus.themis.parser.base.ThemisParserDef;
  
  import java.util.function.Predicate;
  
  /**
   * Analysis StatementType.
   */
  public enum ThemisStatement
          implements ThemisId {
      /**
       * Assert.
       */
      ASSERT(Statement::isAssertStmt),
  
      /**
       * Block.
       */
      BLOCK(Statement::isBlockStmt),
  
      /**
       * Break.
       */
      BREAK(Statement::isBreakStmt),
  
      /**
       * Continue.
       */
      CONTINUE(Statement::isContinueStmt),
  
      /**
       * Constructor.
       */
      CONSTRUCTOR(Statement::isExplicitConstructorInvocationStmt),
  
      /**
       * Do.
       */
      DO(Statement::isDoStmt),
  
      /**
       * Empty.
       */
      EMPTY(Statement::isEmptyStmt),
  
      /**
       * Expression.
       */
      EXPRESSION(Statement::isExpressionStmt),
  
      /**
       * For.
       */
      FOR(Statement::isForStmt),
  
      /**
       * ForEach.
       */
      FOREACH(Statement::isForEachStmt),
  
      /**
       * If.
       */
      IF(Statement::isIfStmt),
  
      /**
       * Labeled.
       */
      LABELED(Statement::isLabeledStmt),
  
      /**
       * LocalClass.
       */
      LOCALCLASS(Statement::isLocalClassDeclarationStmt),
  
      /**
       * LocalRecord.
       */
      LOCALRECORD(Statement::isLocalRecordDeclarationStmt),
 
     /**
      * Return.
      */
     RETURN(Statement::isReturnStmt),
 
     /**
      * ForEach.
      */
     SWITCH(Statement::isSwitchStmt),
 
     /**
      * Synchronized.
      */
     SYNCHRONIZED(Statement::isSynchronizedStmt),
 
     /**
      * Throw.
      */
     THROW(Statement::isThrowStmt),
 
     /**
      * Try.
      */
     TRY(Statement::isTryStmt),
 
     /**
      * While.
      */
     WHILE(Statement::isWhileStmt),
 
     /**
      * Yield.
      */
     YIELD(Statement::isYieldStmt);
 
     /**
      * The test.
      */
     private final Predicate<Statement> theTester;
 
     /**
      * Constructor.
      *
      * @param pTester the test method
      */
     ThemisStatement(final Predicate<Statement> pTester) {
         theTester = pTester;
     }
 
     /**
      * Determine type of statement.
      *
      * @param pParser    the parser
      * @param pStatement the statement
      * @return the StatementType
      * @throws OceanusException on error
      */
     public static ThemisStatement determineStatement(final ThemisParserDef pParser,
                                                      final Statement pStatement) throws OceanusException {
         /* Loop testing each statement type */
         for (ThemisStatement myType : values()) {
             if (myType.theTester.test(pStatement)) {
                 return myType;
             }
         }
 
         /* Unrecognised statementType */
         throw pParser.buildException("Unexpected Statement", pStatement);
     }
 }