Context.Builder

java.lang.Object
- org.graalvm.polyglot.Context.Builder

Enclosing class:

Context
```
public final class Context.Builder
extends Object
```
Builder class to construct Context instances. A builder instance is not thread-safe and must not be used from multiple threads at the same time.

Since:

1.0

See Also:

Context

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Context.Builder`	`allowAllAccess(boolean enabled)` If `true` grants the context the same access privileges as the host virtual machine.
`Context.Builder`	`allowCreateThread(boolean enabled)` If `true` allows guest languages to create new threads.
`Context.Builder`	`allowHostAccess(boolean enabled)` Allows guest languages to access the host language by loading new classes.
`Context.Builder`	`allowHostClassLoading(boolean enabled)` If host class loading is enabled then the guest language is allowed to load new host classes via jar or class files.
`Context.Builder`	`allowIO(boolean enabled)` If `true` allows guest language to perform unrestricted IO operations on host system.
`Context.Builder`	`allowNativeAccess(boolean enabled)` Allows guest languages to access the native interface.
`Context.Builder`	`arguments(String language, String[] args)` Sets the guest language application arguments for a language `context`.
`Context`	`build()` Creates a new context instance from the configuration provided in the builder.
`Context.Builder`	`engine(Engine engine)` Explicitly sets the underlying engine to use.
`Context.Builder`	`err(OutputStream err)` Sets the error output stream to be used for this context.
`Context.Builder`	`fileSystem(FileSystem fileSystem)` Installs a new `FileSystem`.
`Context.Builder`	`hostClassFilter(Predicate<String> classFilter)` Sets a class filter that allows to limit the classes that are allowed to be loaded by guest languages.
`Context.Builder`	`in(InputStream in)` Sets the input stream to be used for this context.
`Context.Builder`	`logHandler(Handler logHandler)` Installs a new logging `Handler`.
`Context.Builder`	`option(String key, String value)` Set an option for this `context`.
`Context.Builder`	`options(Map<String,String> options)` Shortcut for setting multiple `options` using a map.
`Context.Builder`	`out(OutputStream out)` Sets the standard output stream to be used for this context.
`Context.Builder`	`serverTransport(MessageTransport serverTransport)` Take over transport of message communication with a server peer.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - engine
```
public Context.Builder engine(Engine engine)
```
    Explicitly sets the underlying engine to use. By default every context has its own isolated engine. If multiple contexts are created from one engine, then they may share/cache certain system resources like ASTs, optimized code by specifying a single underlying engine; see Engine for more details about system resource sharing.
    
    Since:
    
    1.0
  - out
```
public Context.Builder out(OutputStream out)
```
    Sets the standard output stream to be used for this context. If not set then the standard output stream configured for the engine is used or standard error stream.
    
    Since:
    
    1.0
  - err
```
public Context.Builder err(OutputStream err)
```
    Sets the error output stream to be used for this context. If not set then either the error stream configured for the engine is used or standard error stream.
    
    Since:
    
    1.0
  - in
```
public Context.Builder in(InputStream in)
```
    Sets the input stream to be used for this context. If not set then either the input stream configured for the engine is used or standard in stream.
    
    Since:
    
    1.0
  - allowHostAccess
```
public Context.Builder allowHostAccess(boolean enabled)
```
    Allows guest languages to access the host language by loading new classes. Default is false. If all access is set to true then then host access is enabled if not allowed explicitly.
    
    Since:
    
    1.0
  - allowNativeAccess
```
public Context.Builder allowNativeAccess(boolean enabled)
```
    Allows guest languages to access the native interface.
    
    Since:
    
    1.0
  - allowCreateThread
```
public Context.Builder allowCreateThread(boolean enabled)
```
    If true allows guest languages to create new threads. Default is false. If all access is set to true then the creation of threads is enabled if not allowed explicitly. Threads created by guest languages are closed when the context is closed.
    
    Since:
    
    1.0
  - allowAllAccess
```
public Context.Builder allowAllAccess(boolean enabled)
```
    If true grants the context the same access privileges as the host virtual machine. If not explicitly specified then all access is false. If the host VM runs without a security manager enabled, then enabling all access gives the guest languages full control over the host process. Otherwise, the Java security manager is in control of restricting the privileges of the polyglot context. If new privilege restrictions are added to the polyglot API then they will default to full access if all access is set to true. If all access is enabled then certain privileges may still be disabled by configuring it explicitly using this builder.
    Grants full access to the following privileges by default:
    - The creation and use of new threads.
    - The access to public host classes.
    - The loading of new host classes by adding entries to the class path.
    - Exporting new members into the polyglot bindings.
    - Unrestricted IO operations on host system.
    Parameters:
    
    enabled - true for all access by default.
    
    Since:
    
    1.0
  - allowHostClassLoading
```
public Context.Builder allowHostClassLoading(boolean enabled)
```
    If host class loading is enabled then the guest language is allowed to load new host classes via jar or class files. If all access is set to true then the host class loading is enabled if it is not disallowed explicitly. For host class loading to be useful IO operations and host access need to be allowed as well.
    
    Since:
    
    1.0
  - hostClassFilter
```
public Context.Builder hostClassFilter(Predicate<String> classFilter)
```
    Sets a class filter that allows to limit the classes that are allowed to be loaded by guest languages. If the filter returns true then the class is accessible, else it is not accessible and throws an guest language error when accessed. In order to have an effect Context.Builder.allowHostAccess(boolean) or Context.Builder.allowAllAccess(boolean) needs to be set to true.
    
    Parameters:
    
    classFilter - a predicate that returns true or false for a java qualified class name.
    
    Since:
    
    1.0
  - option
```
public Context.Builder option(String key,
                              String value)
```
    Set an option for this context. By default any options for the engine, language or instrument can be set for a context. If an explicit engine is set for this context then only language options can be set. Instrument and engine options can be set exclusively on the explicit engine instance. If a language option was set for the context and the engine then the option of the context is going to take precedence.
    If one of the set option keys or values is invalid then an IllegalArgumentException is thrown when the context is built. The given key and value must not be null.
    
    Since:
    
    1.0
    
    See Also:
    
    To specify an option for the engine.
  - options
```
public Context.Builder options(Map<String,String> options)
```
    Shortcut for setting multiple options using a map. All values of the provided map must be non-null.
    
    Parameters:
    
    options - a map options.
    
    Since:
    
    1.0
    
    See Also:
    
    To set a single option.
  - arguments
```
public Context.Builder arguments(String language,
                                 String[] args)
```
    Sets the guest language application arguments for a language context. Application arguments are typically made available to guest language implementations. It depends on the language if and how they are accessible within the evaluated guest language scripts. Passing no arguments to a language is equivalent to providing an empty arguments array.
    
    Parameters:
    
    language - the language id of the primary language.
    
    args - an array of arguments passed to the guest language program.
    
    Throws:
    
    IllegalArgumentException - if an invalid language id was specified.
    
    Since:
    
    1.0
  - allowIO
```
public Context.Builder allowIO(boolean enabled)
```
    If true allows guest language to perform unrestricted IO operations on host system. Default is false. If all access is set to true then IO is enabled if not allowed explicitly.
    
    Parameters:
    
    enabled - true to enable Input/Output
    
    Returns:
    
    the Context.Builder
    
    Since:
    
    1.0
  - fileSystem
```
public Context.Builder fileSystem(FileSystem fileSystem)
```
    Installs a new FileSystem.
    
    Parameters:
    
    fileSystem - the file system to be installed
    
    Returns:
    
    the Context.Builder
    
    Since:
    
    1.0
  - serverTransport
```
public Context.Builder serverTransport(MessageTransport serverTransport)
```
    Take over transport of message communication with a server peer. Provide an implementation of MessageTransport to virtualize a transport of messages to a server endpoint. MessageTransport.open(java.net.URI, org.graalvm.polyglot.io.MessageEndpoint) corresponds to accept of a server socket.
    
    Parameters:
    
    serverTransport - an implementation of message transport interceptor
    
    Since:
    
    1.0
    
    See Also:
    
    MessageTransport
  - logHandler
```
public Context.Builder logHandler(Handler logHandler)
```
    Installs a new logging Handler. The logger's Level configuration is done using the Context's options. The level option key has the following format: log.languageId.loggerName.level or log.instrumentId.loggerName.level. The value is either the name of pre-defined Level constant or a numeric Level value. If not explicitly set in options the level is inherited from the parent logger.
    Examples of setting log level options:
    builder.option("log.level","FINE"); sets the FINE level to all TruffleLoggers.
    builder.option("log.js.level","FINE"); sets the FINE level to JavaScript TruffleLoggers.
    builder.option("log.js.com.oracle.truffle.js.parser.JavaScriptLanguage.level","FINE"); sets the FINE level to TruffleLogger for the JavaScriptLanguage class.
    
    If the logHandler is not set on Engine nor on Context the log messages are printed to Context's error output stream.
    
    Parameters:
    
    logHandler - the Handler to use for logging in built Context.
    
    Returns:
    
    the Context.Builder
    
    Since:
    
    1.0
  - build
```
public Context build()
```
    Creates a new context instance from the configuration provided in the builder. The same context builder can be used to create multiple context instances.
    
    Since:
    
    1.0

Class Context.Builder

Method Summary

Methods inherited from class java.lang.Object

Method Detail

engine

out

err

in

allowHostAccess

allowNativeAccess

allowCreateThread

allowAllAccess

allowHostClassLoading

hostClassFilter

option

options

arguments

allowIO

fileSystem

serverTransport

logHandler

build