Class ConvertedExpression<F,T>

java.lang.Object
io.github.syst3ms.skriptparser.lang.base.ConvertedExpression<F,T>
Type Parameters:
F - The type of the source expression
T - The new, converted type of this expression
All Implemented Interfaces:
Expression<T>, SyntaxElement
public class ConvertedExpression<F,T> extends Object implements Expression<T>
An expression that has been converted to another type. Type conversion is only being done at runtime, since the values of the source expression aren't known until runtime.
See Also:

  • Method Details

    • newInstance

      public static <F,T> Optional<? extends ConvertedExpression<F,T>> newInstance(Expression<F> v, Class<T> to)
      Creates a new instance that converts the result by using the registered converters.
      Type Parameters:
      F - the original return type
      T - the converted return type
      Parameters:
      v - the source Expression
      to - the Class to convert to
      Returns:
      an optional ConvertedExpression instance

    • newInstance

      public static <F,T> ConvertedExpression<F,T> newInstance(Expression<F> v, Class<T> to, Function<?, Optional<? extends T>> converter)
      Creates a new instance that converts the result by using the given converter.
      Type Parameters:
      F - the original return type
      T - the converted return type
      Parameters:
      v - the source Expression
      to - the Class to convert to
      converter - the converter to use
      Returns:
      an optional ConvertedExpression instance

    • getValues

      public T[] getValues(TriggerContext ctx)
      Description copied from interface: Expression
      Retrieves all values of this Expression, accounting for possible modifiers. This means that if this is an or-list, it will choose a random value to return.
      Specified by:
      getValues in interface Expression<F>
      Parameters:
      ctx - the event
      Returns:
      an array of the values
      See Also:

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

    • 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

    • isSingle

      public boolean isSingle()
      Specified by:
      isSingle in interface Expression<F>
      Returns:
      whether this expression returns a single value. By default, this is defined on registration, but it can be overridden.

    • getReturnType

      public Class<T> getReturnType()
      Specified by:
      getReturnType in interface Expression<F>
      Returns:
      the return type of this expression. By default, this is defined on registration, but, like Expression.isSingle(), can be overriden.

    • isLoopOf

      @Contract("_ -> false") public boolean isLoopOf(String loop)
      Description copied from interface: Expression
      When this expression is looped, returns what the loop reference (as in loop-<reference>) should be in order to describe each element of the values of this expression.
      Specified by:
      isLoopOf in interface Expression<F>
      Parameters:
      loop - the loop reference
      Returns:
      whether the given reference describes this expression's elements. By default, returns true if the parameter is "value"
      See Also:

    • getSource

      public Expression<? extends F> getSource()
      Specified by:
      getSource in interface Expression<F>

    • iterator

      public Iterator<? extends T> iterator(TriggerContext context)
      Specified by:
      iterator in interface Expression<F>
      Parameters:
      context - the event
      Returns:
      an iterator of the values of this expression