Class SecFlatMap

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.lang.lambda.ReturnSection<Object>
io.github.syst3ms.skriptparser.sections.SecFlatMap
All Implemented Interfaces:
Finishing, SelfReferencing, SyntaxElement
public class SecFlatMap extends ReturnSection<Object> implements SelfReferencing
This section maps the returned value(s) to the values of a given expression, one by one. This means that this sections loops over each value of the expression and replaces it with the returned value(s) from the function. Note that unlike a normal map, the returned expression can contain multiple values. These values will all be concatenated into one list and will replace the given expression. Note that the mapped expression will be changed, hence why it can't be a literal list.
Since:
ALPHA

  • Constructor Details

    • SecFlatMap

      public SecFlatMap()

  • 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

    • step

      public void step(Statement item)
      Description copied from class: ArgumentSection
      After execution has stopped, because a statement has forcefully ended the execution, this consumer is fed with the last Statement that has been processed on the next iteration.
      Note that this function only needs to be called for iterative sections, like loops and maps, that need to execute certain actions after each iteration, instead of only when the execution has finished (see ArgumentSection.finish() for that)
      By default, does nothing.
      Overrides:
      step in class ArgumentSection
      Parameters:
      item - the last statement
      See Also:

    • 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:

    • getReturnType

      public Class<?> getReturnType()
      Specified by:
      getReturnType in class ReturnSection<Object>
      Returns:
      the Class of the values that should be returned from inside this section

    • isSingle

      public boolean isSingle()
      Specified by:
      isSingle in class ReturnSection<Object>
      Returns:
      the number of values that should be returned from inside this section

    • 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

    • 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