Module java.scripting
Package javax.script

# Interface ScriptEngineFactory

public interface ScriptEngineFactory
`ScriptEngineFactory` is used to describe and instantiate `ScriptEngines`.
Each class implementing `ScriptEngine` has a corresponding factory that exposes metadata describing the engine class.
The `ScriptEngineManager` uses the service-provider loader mechanism described in the `ServiceLoader` class to obtain instances of `ScriptEngineFactory` instances. See `ScriptEngineManager()` and `ScriptEngineManager(java.lang.ClassLoader)`.

Since:
  1.6

- ## Method Summary

  Modifier and Type
  Method
  Description
  `String`
  `getEngineName()`
  Returns the full name of the `ScriptEngine`.
  `String`
  `getEngineVersion()`
  Returns the version of the `ScriptEngine`.
  `List<String>`
  `getExtensions()`
  Returns an immutable list of filename extensions, which generally identify scripts written in the language supported by this `ScriptEngine`.
  `String`
  `getLanguageName()`
  Returns the name of the scripting language supported by this `ScriptEngine`.
  `String`
  `getLanguageVersion()`
  Returns the version of the scripting language supported by this `ScriptEngine`.
  `String`
  `getMethodCallSyntax(String obj, String m, String... args)`
  Returns a String which can be used to invoke a method of a Java object using the syntax of the supported scripting language.
  `List<String>`
  `getMimeTypes()`
  Returns an immutable list of mimetypes, associated with scripts that can be executed by the engine.
  `List<String>`
  `getNames()`
  Returns an immutable list of short names for the `ScriptEngine`, which may be used to identify the `ScriptEngine` by the `ScriptEngineManager`.
  `String`
  `getOutputStatement(String toDisplay)`
  Returns a String that can be used as a statement to display the specified String using the syntax of the supported scripting language.
  `Object`
  `getParameter(String key)`
  Returns the value of an attribute whose meaning may be implementation-specific.
  `String`
  `getProgram(String... statements)`
  Returns a valid scripting language executable program with given statements.
  `ScriptEngine`
  `getScriptEngine()`
  Returns an instance of the `ScriptEngine` associated with this `ScriptEngineFactory`.

- ## Method Details

  - ### getEngineName

    String getEngineName()
    Returns the full name of the `ScriptEngine`. For instance an implementation based on the Mozilla Rhino Javascript engine might return Rhino Mozilla Javascript Engine.
    Returns:
      The name of the engine implementation.

  - ### getEngineVersion

    String getEngineVersion()
    Returns the version of the `ScriptEngine`.
    Returns:
      The `ScriptEngine` implementation version.

  - ### getExtensions

    List<String> getExtensions()
    Returns an immutable list of filename extensions, which generally identify scripts written in the language supported by this `ScriptEngine`. The array is used by the `ScriptEngineManager` to implement its `getEngineByExtension` method.
    Returns:
      The list of extensions.

  - ### getMimeTypes

    List<String> getMimeTypes()
    Returns an immutable list of mimetypes, associated with scripts that can be executed by the engine. The list is used by the `ScriptEngineManager` class to implement its `getEngineByMimetype` method.
    Returns:
      The list of mime types.

  - ### getNames

    List<String> getNames()
    Returns an immutable list of short names for the `ScriptEngine`, which may be used to identify the `ScriptEngine` by the `ScriptEngineManager`. For instance, an implementation based on the Mozilla Rhino Javascript engine might return list containing {"javascript", "rhino"}.
    Returns:
      an immutable list of short names

  - ### getLanguageName

    String getLanguageName()
    Returns the name of the scripting language supported by this `ScriptEngine`.
    Returns:
      The name of the supported language.

  - ### getLanguageVersion

    String getLanguageVersion()
    Returns the version of the scripting language supported by this `ScriptEngine`.
    Returns:
      The version of the supported language.

  - ### getParameter

    Object getParameter(String key)
    Returns the value of an attribute whose meaning may be implementation-specific. Keys for which the value is defined in all implementations are:
    - ScriptEngine.ENGINE
    - ScriptEngine.ENGINE_VERSION
    - ScriptEngine.LANGUAGE
    - ScriptEngine.LANGUAGE_VERSION
    - ScriptEngine.NAME

    The values for these keys are the Strings returned by `getEngineName`, `getEngineVersion`, `getLanguageName`, `getLanguageVersion` for the first four keys respectively. For NAME, one of the Strings returned by `getNames` is returned.
    A reserved key, `THREADING`, whose value describes the behavior of the engine with respect to concurrent execution of scripts and maintenance of state is also defined. These values for the `THREADING` key are:

    - `null` - The engine implementation is not thread safe, and cannot be used to execute scripts concurrently on multiple threads.
    - `"MULTITHREADED"` - The engine implementation is internally thread-safe and scripts may execute concurrently although effects of script execution on one thread may be visible to scripts on other threads.
    - `"THREAD-ISOLATED"` - The implementation satisfies the requirements of "MULTITHREADED", and also, the engine maintains independent values for symbols in scripts executing on different threads.
    - `"STATELESS"` - The implementation satisfies the requirements of `"THREAD-ISOLATED"`. In addition, script executions do not alter the mappings in the `Bindings` which is the engine scope of the `ScriptEngine`. In particular, the keys in the `Bindings` and their associated values are the same before and after the execution of the script.
    Implementations may define implementation-specific keys.
    Parameters:
      `key` - The name of the parameter
    Returns:
      The value for the given parameter. Returns `null` if no value is assigned to the key.
    Throws:
      `NullPointerException` - if the key is null.

  - ### getMethodCallSyntax

    String getMethodCallSyntax(String obj, String m, String... args)
    Returns a String which can be used to invoke a method of a Java object using the syntax of the supported scripting language. For instance, an implementation for a Javascript engine might be;

         public String getMethodCallSyntax(String obj,
                                           String m, String... args) {
              String ret = obj;
              ret += "." + m + "(";
              for (int i = 0; i < args.length; i++) {
                  ret += args[i];
                  if (i < args.length - 1) {
                      ret += ",";
                  }
              }
              ret += ")";
              return ret;
         }

    Parameters:
      `obj` - The name representing the object whose method is to be invoked. The name is the one used to create bindings using the `put` method of `ScriptEngine`, the `put` method of an `ENGINE_SCOPE` `Bindings`,or the `setAttribute` method of `ScriptContext`. The identifier used in scripts may be a decorated form of the specified one.
      `m` - The name of the method to invoke.
      `args` - names of the arguments in the method call.
    Returns:
      The String used to invoke the method in the syntax of the scripting language.
    Throws:
      `NullPointerException` - if obj or m or args or any of the elements of args is null.

  - ### getOutputStatement

    String getOutputStatement(String toDisplay)
    Returns a String that can be used as a statement to display the specified String using the syntax of the supported scripting language. For instance, the implementation for a Perl engine might be;

         public String getOutputStatement(String toDisplay) {
              return "print(" + toDisplay + ")";
         }

    Parameters:
      `toDisplay` - The String to be displayed by the returned statement.
    Returns:
      The string used to display the String in the syntax of the scripting language.

  - ### getProgram

    String getProgram(String... statements)
    Returns a valid scripting language executable program with given statements. For instance an implementation for a PHP engine might be:

         public String getProgram(String... statements) {
              String retval = "<?\n";
              int len = statements.length;
              for (int i = 0; i < len; i++) {
                  retval += statements[i] + ";\n";
              }
              return retval += "?>";
         }

    Parameters:
      `statements` - The statements to be executed. May be return values of calls to the `getMethodCallSyntax` and `getOutputStatement` methods.
    Returns:
      The Program
    Throws:
      `NullPointerException` - if the `statements` array or any of its elements is null

  - ### getScriptEngine

    ScriptEngine getScriptEngine()
    Returns an instance of the `ScriptEngine` associated with this `ScriptEngineFactory`. A new ScriptEngine is generally returned, but implementations may pool, share or reuse engines.
    Returns:
      A new `ScriptEngine` instance.