Class SecLoop

java.lang.Object
io.github.syst3ms.skriptparser.lang.Statement
io.github.syst3ms.skriptparser.lang.CodeSection
io.github.syst3ms.skriptparser.lang.lambda.ArgumentSection
io.github.syst3ms.skriptparser.sections.SecLoop
All Implemented Interfaces:
Continuable, Finishing, SelfReferencing, SyntaxElement
public class SecLoop extends ArgumentSection implements Continuable, SelfReferencing
This section iterates over all the values of the given expression, one by one. One can also loop a certain amount of times instead. The looped expression will still be valid in that case.
Since:
ALPHA

  • Constructor Details

    • SecLoop

      public SecLoop()

  • Method Details

    • loadSection

      public boolean loadSection(FileSection section, ParserState parserState, SkriptLogger logger)
      Description copied from class: CodeSection
      This methods determines the logic of what is being done to the elements inside of this section. By default, this simply parses all items inside it, but this can be overridden. In case an extending class just needs to do some additional operations on top of what the default implementation already does, then call super.loadSection(section) before any such operations.
      Overrides:
      loadSection in class CodeSection
      Parameters:
      section - the FileSection representing this CodeSection
      logger - the logger
      Returns:
      true if the items inside of the section were loaded properly, false if there was a problem

    • init

      public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext)
      Description copied from interface: SyntaxElement
      Initializes this SyntaxElement before being used. This method is always called before all the others in an extending class, the only exception being CodeSection.loadSection(FileSection, ParserState, SkriptLogger).
      Specified by:
      init in interface SyntaxElement
      Parameters:
      expressions - an array of expressions representing all the expressions that are being passed to this syntax element. As opposed to Skript, elements of this array can't be null.
      matchedPattern - the index of the pattern that was successfully matched. It corresponds to the order of the syntaxes in registration
      parseContext - an object containing additional information about the parsing of this syntax element, like regex matches and parse marks
      Returns:
      true if the syntax element was initialized successfully, false otherwise.
      See Also:

    • walk

      public Optional<? extends Statement> walk(TriggerContext ctx)
      Description copied from class: Statement
      By default, runs Statement.run(TriggerContext) ; returns Statement.getNext() if it returns true, or null otherwise. Note that if this method is overridden, then the implementation of Statement.run(TriggerContext) doesn't matter.
      Specified by:
      walk in class CodeSection
      Parameters:
      ctx - the event
      Returns:
      the next item to be ran, or null if this is the last item to be executed

    • setNext

      public Statement setNext(@Nullable @Nullable Statement next)
      Description copied from class: Statement
      Sets the Statement that is placed after this Statement in the file. You can assume that the Statement.next statement of the next parameter is known if it has such a statement.
      Overrides:
      setNext in class Statement
      Parameters:
      next - the Statement that is following this one
      Returns:
      this statement

    • finish

      public void finish()
      Description copied from interface: Finishing
      By convention, this method should be fired in one of the following occasions:
      1. The execution of the section is completely done and the (actual) next element is referenced to be walked on.
      2. This method is completely stopped by any means whatsoever.
      An example of this second occasion is EffContinue continuing over multiple loops. If that effect continues 3 loops in one go, this means that the 2 most inner-loops need to be completely reset, since they have the possibility to be looped over again. EffContinue therefore calls this method on those loops.
      Another example is EffExit, which finishes every section that implements this interface, because of the same reasons specified above.
      Specified by:
      finish in interface Finishing
      Overrides:
      finish in class ArgumentSection
      See Also:

    • getContinued

      public Optional<? extends Statement> getContinued(TriggerContext ctx)
      Description copied from interface: Continuable
      This function is called on the section where the EffContinue effect will continue to, taking all Continuable sections into account. Most of the time, this will just return the section it is referring to, but in rare cases, one might want to change this behaviour, hence this method.
      Specified by:
      getContinued in interface Continuable
      Parameters:
      ctx - the context
      Returns:
      the next statement
      See Also:

    • getActualNext

      public Optional<Statement> getActualNext()
      Description copied from interface: SelfReferencing
      This statement returns itself as the next statement to run in getNext().
      This method will return the actual statement that follows this statement. This means, by convention, the next element that is not nested more than this statement.
      Specified by:
      getActualNext in interface SelfReferencing
      Returns:
      the element that is actually after this section

    • toString

      public String toString(TriggerContext ctx, boolean debug)
      Specified by:
      toString in interface SyntaxElement
      Parameters:
      ctx - the event
      debug - whether to show additional information or not
      Returns:
      a String that should aim to resemble what is written in the script as closely as possible

    • getLoopedExpression

      public Expression<?> getLoopedExpression()
      Returns:
      the expression whose values this loop is iterating over