All Classes and Interfaces
Class
Description
This exception is thrown when the current request is aborted.
Abstract Cache Provider for BoxLang
This is an optional base class for all cache providers.
A BoxLang abstract Function.
Parser abstract class
An abstract requet.
Abstract base class to aid in modeling response types
The base implementation of a cache store in BoxLang.
Abstract Transformer class
Implements common functionality used by all the transformer sub classes
Performs Logical "and"
true && trueI represent an Application in BoxLang
This context represents an Application in BoxLang
I represent an Application listener that wraps an Application class instance, delegting to it, where possible and providing default
implementations otherwise
I represent a default Application listener
represents boxlang application scope container
I handle managing Applications
I represent an Application listener that wraps an Application template
Represents an argument to a function or BIF
Variables scope implementation in BoxLang
Represents an argument to a function or BIF
The primary array class in BoxLang.
I handle casting anything to a Array
Performs an assertion check on an incoming expression value.
An interceptor that captures the AST and outputs it to the console or a file
The BoxLang Async Service is a service that allows you to create and manage executors.
Executor types we support
This allows any key-value pair of attachable data to be attached to a Box object.
An abstract requet.
This class is a fluent class inspired by Java optionals.
Represents an attribute to a Component
I represent an Application listener.
This context represents the context of ANYTHING that can execute in BoxLang
An abstract base class for interceptors with many helper methods useful during interceptions
This is a BoxLang proxy class for functional interfaces so we can use them in BoxLang
via type casting and coercion.
This class is the base class for all resolvers.
The Async Scheduler is in charge of registering scheduled tasks, starting them, monitoring them and shutting them down if needed.
Base scope implementation.
A base service class that all services should extend.
Base class for all BIFs.
This class is used to describe a BIF
as it can be a global BIF or a member BIF or both or coming from a module
It also lazily creates the BIF instance and caches it upon first use
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/BiFunction.html
I handle casting anything
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/BinaryOperator.html
Performs BitwiseAnd
z = x b& yPerforms BitwiseComplement
x = b~ yPerforms BitwiseOr
z = x b| yPerforms BitwiseSignedLeftShift
z = x b<< yPerforms BitwiseSignedRightShift
z = x b>> yPerforms BitwiseUnsignedRightShift
z = x b>>> yPerforms BitwiseXor
z = x b^ yA black hole store that does nothing but simulate a cache store.
I handle casting anything to a boolean
Abstract class representing Aceess Operations
There are two methods of adding annotations to BoxLang methods and arguments.
AST Node representing an argument.
AST Node representing a function/method argument definition
Transform a BoxArgumentDeclarationTransformer Node the equivalent Java Parser AST nodes
Transform a BoxArgument Node the equivalent Java Parser AST nodes
AST Node representing access with a square bracket like:
variables['a'] or a[10]AST Node representing an array literal.
Transform a BoxArrayLiteral Node the equivalent Java Parser AST nodes
The array type in BoxLang is represented by the ortus.boxlang.runtime.types.Array
class, which implements the Java List interface,
and provides several methods of construction:
AST Node representing an assigment statement
Transform a BoxAssert Node the equivalent Java Parser AST nodes
Assigment as expression
The way Java does multiple annotations, with verbosity to another annotation
AST Node representing access binary operation
Transform a BoxBinaryOperation Node the equivalent Java Parser AST nodes
AST Node representing a boolean value
Transform a BoxBooleanLiteral Node the equivalent Java Parser AST nodes
AST Node representing a break statement
AST Node representing an Expression statement
Transform a String Interpolation the equivalent Java Parser AST nodes
The base implementation of a cache entry in BoxLang.
The BoxCacheProvider class is a cache provider for BoxLang that
can use a variety of object stores to store cache data:
- ConcurrentHashMap
- ConcurrentSoftReference
- Disk
- Custom
This exception is thrown when an attempt to cast a value to a specific Java type fails.
Root node for a Class
This class provides JSON Serialization of a BoxLang Class
The methods in this class are an extension of IClassRunnable.
Represent A closure declaration
abstract class for comments
Transform a BoxComparisonOperation Node the equivalent Java Parser AST nodes
The BoxCompiledScript is the compiled representation of a BoxScript that can
be executed by the BoxScriptingEngine.
Represents a tag or script component
The way Java does multiple annotations, with verbosity to another annotation
AST Node representing a continue statement
AST Node representing a decimal value
Transform a BoxBooleanLiteral Node the equivalent Java Parser AST nodes
AST Node representing a Do loop statement
Documentation comment
Represent a javadoc style documentation
AST Node representing access with a dot like:
object.property or object.method()These are all the core BoxLang interception events that can be intercepted by the BoxLang runtime.
Abstract class representing Expressions
AST Node representing an invoked expression
AST Node representing an Expression statement
AST Node representing a for statement
AST Node representing a for statement like:
for(variable;expression;expression) bodyTransform a BoxForIndex Node the equivalent Java Parser AST nodes
Transform a BoxForIn Node the equivalent Java Parser AST nodes
AST Node representing a fully qualified name
I represent functional static access to a BIF
myArray.map( ::UCase )
I represent functional access to an instance member method
myArray.map( .UCase )
AST Node representing a function definition
Transform a Function Declaration in the equivalent Java Parser AST nodes
AST Node representing a fully qualified name
This is the BoxLang version of a CompletableFuture to allow for more
dynamic goodness and fluent features.
AST Node representing a switch case statement
Transform a BoxIdentifier Node the equivalent Java Parser AST nodes
AST Node representing a if statement
AST Node representing an import statement
AST Node representing an integer literal value
Transform a BoxIntegerLiteral Node the equivalent Java Parser AST nodes
Root node for an Interface
This exception is thrown when an IO operation fails.
This class provides a JSON provider for BoxLang using our lib: Jackson JR
Represent A lambda declaration
Transform a Lambda in the equivalent Java Class
This is a BIF that is used to proxy from a BoxLang script to a Java method
This is the root exception for all exceptions thrown by BoxLang.
Listens on the provided port to allow connections from a debug tool.
This enum represents the types that are supported by BoxLang.
This is a base class for all meta types
AST Node representing a method invocation like:
object.method(1,"a")class for multi line comments
AST Node representing new statement
Base class for the BoxLang AST Nodes
Class representing a key in the Java Parser Node data collection
AST Node representing a string literal value
Transform a BoxIntegerLiteral Node the equivalent Java Parser AST nodes
AST Node representing a param whose syntax won't fit in the generic component node
This is usually for the script syntax that uses an FQN for the variable name
AST Node representing and expression within parenthesis
Root node for a property
This resolver deals with BoxLang classes only.
AST Node representing a rethrow statement
Transform a Rethrow statement in the equivalent Java Parser AST nodes
AST Node representing a return statement
Transform a Return Statement in the equivalent Java Parser AST nodes
AST Node representing a function return type
This class is in charge of executing templates/classes with a
BoxLang runtime.
Command-line options for the BoxLang runtime.
Represents the top level runtime container for box lang.
This is the base exception thrown by the BoxLang runtime.
Our own custom scheduled executor service
AST Node representing a scopes
Scopes are identified with the following keywords:
APPLICATION
ARGUMENTS
LOCAL
REQUEST
THIS
THREADA Bindings implementation that wraps an IScope for our scripting engine
contexts.
Root node for a script (program) cfs/bxs
The BoxScriptingContext is an implementation of the JSR-223 ScriptContext
interface that provides a context for executing BoxLang code.
The BoxScriptingEngine is the JSR-223 implementation for BoxLang.
BoxScriptingFactory is used to describe and instantiate
ScriptEngines for BoxLang based on JSR-223.An island of script code within a template
I extend the generated ANTLR lexer to add some custom methods for getting unpopped modes
so we can perform better validation after parsing.
Parser for Box scripts
class for single line comments
Supported files
Abstract Node class representing statements
AST Node representing a Statement Block
AST Node representing access of static members like:
object::propertyStatic Initializer block for a Class
AST Node representing a static method invocation like:
object::method(1,"a")AST Node representing a string literal value
Transform a String Interpolatiion the equivalent Java Parser AST nodes
AST Node representing a string literal value
Transform a String Interpolatiion the equivalent Java Parser AST nodes
AST Node representing a string literal value
Transform a BoxStringLiteral Node the equivalent Java Parser AST nodes
A struct literal comes in two forms, ordered and unordered (default).
Transform a BoxStructUnorderedLiteral Node the equivalent Java Parser AST nodes
A struct literal comes in two forms, ordered and unordered (default).
AST Node representing a switch statement
AST Node representing a switch case statement
Transform a SwitchStatement Node the equivalent Java Parser AST nodes
Root node for a templating (program) cfm/bxm
An island of script code within a template
I extend the generated ANTLR lexer to add some custom methods for getting unpopped modes
so we can perform better validation after parsing.
AST Node representing a Ternary operator
AST Node representing an throw statement
AST Node representing a if statement
AST Node representing a catch statement
AST Node representing a unary operator
Transform a BoxUnaryOperatorTransformer Node the equivalent Java Parser AST node
This is exception is thrown when an attempt to validate inbound attributes or arguments fails.
AST Node representing a while loop statement
Models a breakpoint record sent from the debug tool.
Models the Breakpoint event for the Debug Protocol
I am a CLI tool for pre-compiling code to class files
TODO: Not sure where this class should eventually live.
I handle casting anything
Enumeration of all possible `type` attribute values.
A BoxLang cache configuration
This is a configuration segment for a cache engine
The default name is 'default'
The default provider is 'BoxCacheProvider'
The default properties are based on the DEFAULTS struct
I ensure that the passed cachename is a valid registered cache.
This is a service that provides caching functionality to BoxLang.
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/concurrent/Callable.html
Casts input to Java type
A container object which may or may not contain the result of a cast attempt
This allows you to attempt a cast, getting the casted value if it was successfull, but not
throwing an exception if it fails.
This context represents the context of a template execution in BoxLang
I extend the generated ANTLR lexer to add some custom methods for getting unpopped modes
so we can perform better validation after parsing.
Parser for CF scripts
I extend the generated ANTLR lexer to add some custom methods for getting unpopped modes
so we can perform better validation after parsing.
I am a CLI tool for transpiling ColdFusion code to BoxLang
TODO: Not sure where this class should eventually live.
Pretty print BoxLang AST nodes
I handle casting anything
A child transaction object used for implementing nested JDBC transactions.
This context represents the pseduo constructor of a Box Class
The
ClassDiscovery class is used to discover classes in a given package at runtime
- getClassFilesAsStream will return a stream of fully qualified class names
- getClassFiles will return an array of fully qualified class names
- loadClassFiles will return an array of loaded classesA Record that represents the information about a class to be compiled
This is a Class Loader is in charge of locating Box classes in the lookup algorithm
and also Java classes in the classloader paths.
This record represents a class location in the application
This class represents generic BoxLang metadata for a an object which has no object-specifc properties
I generate metadata for a class or interface based on the AST without needing to instantiate or even compile the code
This exception is thrown when a class cannot be found in the BoxLang runtime.
I'm just like a normal Variables scope, but I know I belong to a class
Represents a closure, which is a function, but has less data than a UDF and also retains a reference to the declaring context.
This context represents the execution of a closure.
I handle casting anything to a Closure
I handle casting anything to a collection
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/Comparator.html
Performs EQ, GT, and LT comparisons
Compares numbers as numbers, compares strings case insensitive
Base class for all Components.
The result of a body processing
A functional interface for the body of a component which can be a lambda
This class is used to describe a component
as it can be a component or a member component or both or coming from a module
It also lazily creates the component instance and caches it upon first use
The
ComponentService is in charge of managing the runtime's built-in components.Performs String Concat
a = "Hello" & "World" This object store keeps all objects in heap using Concurrent classes.
This object store keeps all objects in heap using Concurrent classes.
This class is responsible for loading the core configuration file from the `resources` folder
and parsing it into the Configuration class.
The BoxLang configuration object representing the core configuration.
Models the command that the debug tool has finished configuration.
This exception is thrown when an error is encountered during the configuration of the BoxLang runtime or its modules
Manages the active JDBC Connection for the current request/thread/BoxLang context.
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/Consumer.html
This context provides a "container" to run some code in where we want to have our own
variables scope, but otherwise want to inherit the rest of the requests' scopes
Performs String Contains check
a = "hello" contains "lo" or a = "hello" ct "LO" Models the Continued event for the Debug Protocol
Models the command to initialize a debug session.
Models a SetBreakpoint response in the DAP
This is the base exception class for all custom exceptions thrown by the user.
This context represents the context of any function execution in BoxLang
It encapsulates the arguments scope and local scope and has a reference to the function being invoked.
This driver type enum is used to determine the type of driver to use for a datasource
The available driver types are:
MYSQL
MARIADB
POSTGRES
SQLSERVER
ORACLE
DB2
DERBY
SQLITE
HYPERSONIC
GENERIC
Each type is represented by a
Key objectThis exception is the base exception for all database-related errors in the BoxLang runtime.
This utility class is a fluent class that can navigate
data structures from many incoming sources.
The Data Navigator Fluent Goodness Class
Encapsulates a datasource configuration and connection pool, providing methods for executing queries (transactionally or single) on the datasource.
A BoxLang datasource configuration.
The datasource manager which stores a registry of configured datasources.
The primary DateTime class that represents a date and time object in BoxLang
All temporal methods in BoxLang operate on this class and all castable date/time representations are cast to this class
I cast to DateTime objects
We represent a static date/time helper class that assists with time units on date/time conversions
It doesn't hold any date/time information.
Implements Microsoft's Debug Adapter Protocol https://microsoft.github.io/debug-adapter-protocol/
Test class
Performs Math i--
a = i-- or a = --iI apply a default value to the record if it is not present
Models the command to disconnect a debug session.
Disk Class Loader for our Class Infos
Contains some utilities for working with non-class files in the class generation dir
Performs Math Divide
a = 10 / 2Parser document comments
I handle casting anything to a Double
A JDBC Driver Proxy class to allow registering JDBC Drivers with
java.sql.DriverManager from child class loaders (i.e.This class is used to provide a way to dynamically and efficiently interact with the java layer from the within a BoxLang environment.
This class is used to represent a BX/Java Class and invoke methods on classes using invoke dynamic.
This class provides JSON Serialization of a BoxLang Dynamic Object
Performs elvis operator (null coaslescing)
expr ?: expr
Note: Any deferencing performed in the evaluation of of the left operand must be done safely
So,
foo.bar ?: expr
must be the equivalent of
foo?.bar ?: exprA utility class for encryption and encoding
Performs
EQ or == comparison
Compares numbers as numbers, compares strings case insensitivePerforms
EQ or === comparison
Compares numbers as numbers, compares strings case insensitive but with type checkingPerforms an equivalence check on the two values.
Models the command to evaluate an expression
Models a SetBreakpoint response in the DAP
This exception is thrown when a cast can't be done on any type
This class represents a query that has been executed and contains the results of executing that query.
A BoxLang Executor Configuration Segment
A record for an executor
Models the Exit event for the Debug Protocol
This is the base exception for all expression or evaluation errors in the BoxLang runtime.
I handle interpreting expressions
I am a CLI tool for auditing code to determine BIFs and tags in use
which are not yet supported by BoxLang.
Audit missing functionality
FIFO - Compare by created ascending
This object store keeps all objects in the file system.
I handle casting anything
This class represents a fully qualified name (FQN) for a class or package.
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/Function.html
A BoxLang Function base class
The supported access levels of the function
I wrap up a functional call to a BIF, passing along the arguments passed to me
I represent a functional call to a memeber method on the passed instance.
I represent a functional call to a memeber method on the passed instance with args.
This context represents the context of any function execution in BoxLang
It encapsulates the arguments scope and local scope and has a reference to
the function being invoked.
I handle casting anything to a Function
This class represents BoxLang metadata for a function
Future idea, implement IReferenceable to allow for metadata to be generated on the fly
The
FunctionService is in charge of managing the runtime's built-in functions.A generated getter method
I am a concrete class and will not be extended by a compiled runnable
A generated setter method
I am a concrete class and will not be extended by a compiled runnable
I handle casting anything
This is the generic JDBC driver that can be used to register datasources in the system.
This class represents generic BoxLang metadata for a an object which has no object-specifc properties
A generic proxy allows you to wrap any object and call any method on it from Java/BoxLang
Performs
GT or > comparison
Compares numbers as numbers, compares strings case insensitivePerforms
GTE or >= comparison
Compares numbers as numbers, compares strings case insensitiveI require numberic value greater than zero.
This allows any key-value pair of attachable data to be attached to a Box object.
This represents the interface for all box contexts.
Represents the results of a successful scope hunting expedition.
Root node for a Class
Interface for BoxLangDebuggers.
I represent a litearl value
I represent a simple litearl value
Every cache provider in BoxLang must adhere to this interface.
This interface can be used to filter cache keys when using the cache provider.
The base interface for a cache policy in BoxLang.
A BoxLang cache provider that can talk to any cache implementation.
Every cache provider in BoxLang must adhere to this interface in
order to provide statistics about the cache it manages.
This interface is to implement ways to resolve classes in BoxLang.
Each configuration segment is a part of the configuration file that is
responsible for a specific part of the configuration.
Represents a base type which is immutable
This interface is used to define a Java interceptor.
This interface is used to define a Java interceptor.
This interface is used mostly on the RequestBoxContext and ThreadBoxContext classes to provide access to the ConnectionManager
and other JDBC-related functionality.
This interface is used to define the methods that a JDBC driver must implement
in order to do datasource registrations, population and validation.
Represents a type that can register change listeners
Represents an immutable Array.
Represents an immutable Struct.
Performs an implication check on the two values.
Represents an import in BoxLang
import prefix:package.to.Class as alias
import package.to.Class
import package.to.Class as alias
import package.to.*
Performs Math i++
a = b++ or a = ++bModels the command to initialize a debug session.
Responds to the InitializeRequest.
Performs instance of check.
I handle casting anything
Performs Math Integer Division.
An annotation that marks a method as an interception point
An InterceptorPool is a pool of interceptors that can be used to intercept events
within the BoxLang runtime.
The interceptor service is responsible for managing all events in BoxLang.
An interceptor state is an event state that is used to hold observers that want to listent
to that specific state.
This context represents the initialization of an interface, and is really only here for the registerUDF method
This class represents generic BoxLang metadata for a an object which has no object-specifc properties
I represent the definition of an interface proxy
I handle creating interface proxies
Represents a key that represents an integer
The main interface for object storages for a BoxLangCache.
The base interface for all operators
This represents the most basic box context.
All BoxLang schedulers must implement this interface and
inherit from the
Scheduler class.All scope implementations must implement this interface
Interface for messages that will be sent to the debugger tool.
The BoxLang service interface.
Error generated by the parser, consist of an error message and the position with in the
source code of the offending symbol.
The Available types of structs
A transaction interface which defines transaction management methods for JDBC connections.
BoxLang AST transpiler interface
Represents a base type
Type Hierarchy
- Struct
- sorted, ordered, etc
- Array
- XML
- Query
- Simple
- String
- Numeric
- Boolean
- List
- Date
This class uses the Java compiler to turn a BoxLang script into a Java class
JavaFileObject implementation
i wrap up a Java method, allowing it to be passed around and called like a function.
This resolver deals with Java classes only.
Java Source code as a String
BoxLang AST to Java AST transpiler
The registry maps a AST node to the corresponding Transformer Java class instance.
This wraps up a Value from the com.sun.JDI package to provide a more convenient interface for accessing the state of objects in the VM.
Utility class for JSON operations based on our library of choice.
This context represents the context of a JSR scripting execution
Represents a case-insenstive key, while retaining the original case too.
Represents a case-sensitive key
Implements the Serializable interface in case duplication is requested within a native HashMap or ArrayList
I handle casting anything to a Key
The exception thrown when a key cannot be located within a struct
Represents a Lambda, which is a function, but has less data than a UDF and performs NO scope lookups outside of itself.
This context represents the execution of a Lambda.
Models the request to launch a specific file
Performs LT or
< comparison
Compares numbers as numbers, compares strings case insensitivePerforms LTE or
<= comparison
Compares numbers as numbers, compares strings case insensitiveLeast Frequently Used cache policy
Hit count ascending
LIFO - Compare by created descending
I handle basic list operations.
A Collection of Common Static Properties and Methods to support Localization
Variables scope implementation in BoxLang
This exception is thrown when a locking operation fails - either with a failure to obtain the lock or due to a timeout
A BoxLang interceptor that provides logging capabilities
Configures the bundled SLF4J provider via logback.
I handle casting anything
LRU - Compare by last accessed ascending
I require a numeric record that cannot be greater than the number I'm instantiated with
I require a string record that cannot be of greater length than the threshold I'm instantiated with
This describes a member method and how to invoke it
This immutable record represents an executable method handle and it's metadata.
MFU - Compare by hits descending
I require a numeric record that cannot be greater than the number I'm instantiated with
I require an array, struct, or string record that cannot be of shorter length than the threshold I'm instantiated with
Performs Math minus
a = b - cThis exception is thrown when a an included template file cannot be located.
I look for varibles output in tag based code which are not encoded
I handle casting anything to a Array that needs to be modifiable
This means I reject
- Native Java arrays
- ImmutableLists
- UmmodifiableLists
I handle casting anything to a Struct that needs to be modifiable
This means I reject
- ImmutableMaps
- UmmodifiableMaps
A BoxLang module configuration from the boxlang.json
This is a configuration segment for a module
Each module configuration has the following properties:
- name: The name of the module
- enabled: Whether the module is enabled or not
- settings: The settings for the module as a struct
This class represents a module record
This service is in charge of managing BoxLang modules
Performs Math Modulus
a = b % c, or a = b mod cMRU - Compare by last accessed descending
Performs Math Multiply
a = b * cInterface used to identify symbols
Performs mathematic Negation
a = -numModels the command to initialize a debug session.
Can be used to model any response that is a simple acknowledgement and doesn't transmit any data.
This exception is thrown when no constructor is found on a Dynamic Object
It is most often encountered when attempting to construct a Java class with arguments that do not match any of the constructors
This exception is thrown when a variable is accessed that does not exist
This exception is thrown when a field is requested on a Java class that does not exist.
This exception is thrown when attempting to access a method on a java class that does not exist, is not accessible or does not match the arguments
Performs boolean Negation
a = !boolI ensure this value is not passed yet since we don't implement this feature.
I represent a null value, so we can store it in a ConcurrentHashMap
I am a simple wrapper for a value which allows it to be passed by reference into a method, possibly modified in that method, and then the
modified value accessed without needing to return it from the method.
The enum of available object storages
Each with a name and corresponding Key
Performs Logical "or"
true || falseModels the Output event for the Debug Protocol
This exception is encountered when parsing of a source file fails.
The results returned when parsing code.
Models the request to pause a thread
This class represents a query and any parameters/bindings before being executed.
Phase 2 BoxLang
Example of UDF delcaration and execution
Phase 2 BoxLang
Example of Closure delcaration and execution
Phase 2 BoxLang
Example of UDF delcaration and execution
Phase 2 BoxLang
Example of Lambda delcaration and execution
Phase 2 BoxLang
Example of UDF delcaration and execution
Phase 2 BoxLang
Example of UDF delcaration and execution
A helper class for resolving placeholders in configuration files
Performs Math Plus
a = b + cRepresents a position in the source code with line and column
Represents a region of code within a text
Performs Math Power for BoxLang
a = 2 ^ 3https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/Predicate.html
Pretty print BoxLang AST nodes
TODO Items:
- Add configuration for indent size
- Add any other config settings such as white space inside paren, etc
- Modify AST to track pre annotations and inline annotations separately
- Test!
Represents a class property
This type represents a representation of a database query result set.
I handle casting anything to Query
This class represents the metadata of a BoxLang Query object
A class to hold the options for a query, such as the datasource, return type, and result variable name.
Random - Compare randomly
I handle dereferencing of objects
A filter that uses a regex pattern to filter cache keys case-sensitive
Base class for the BoxLang AST Nodes that allows children to be replaced in-place
A request-type context.
represents boxlang request scope container
Note, this doesn't have to be a "web" request, but could just be a request to execute code
or a template inside a runtime.
I manage the threads for a request.
I require a non-null value
If this record is present, ensure that the required records are also present
I represent the a file path that has been resolved to an absolute path.
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/lang/Runnable.html
This class is responsible for taking a template on disk or arbitrary set of statements
and compiling them into an invokable class and loading that class.
This context represents the context of the entire BoxLang Runtime.
The ScheduledTask class is a
Runnable that is used by the schedulers to execute tasks
in a more human and fluent approach.This service manages all schedulers in the system.
This exception is thrown when a scope is requested that does not exist in the current runtime build
This exception might be encountered, for example, in a non-web runtime when attempting to access web-specific scopes like `URL` or `FORM`
Models a SetBreakpoint response in the DAP
I am decorator/wrapper for a scope that allows you to spoof variables in the wrapped scope.
This context represents the context of a scripting execution in BoxLang
There a variables and request scope present.
Represents the BoxLang "server" scope container
I represent a Session.
This class represents the context of a session in the BoxLang runtime
It is a child of the RuntimeBoxContext and has access to the session scope
and the parent context and its scopes
This filter will match any session that has a prefix which in our case
is the name of the application that the session belongs to.
Represents a BoxLang session scope container
Models the request to add a breakpoint to a line of source code
The arguments of the SetBreakpoint Request
Models a SetBreakpoint response in the DAP
Models the command to initialize a debug session.
Models a SetBreakpoint response in the DAP
I handle casting anything
Abstract Source class to represent the origin of the code
Models the Source type of the DAP
Represent a string as source
Represent a File as source
Models the command that the debug tool has finished configuration.
The arguments of the StackTrace Request
Models a SetBreakpoint response in the DAP
This context represents the static constructor of a box class
I'm the static scope in a class
Models the command to initialize a debug session.
Models the command to initialize a debug session.
Models the Stopped event for the Debug Protocol
I handle casting anything to a string
Operator to compare two strings and bypass any additional cast attempts
A collection of string utility functions
This type provides the core map class for Boxlang.
I handle casting anything to a Struct
I handle casting anything to a Struct, except I'll also cast any Java classes which are not a built in datatype into a struct, using the public
fields as the keys and the values as the values.
This class represents BoxLang metadata for a Struct
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/Supplier.html
The task record holds all the information of a living task in the scheduler.
Models the Exit event for the Debug Protocol
Models the command to initialize a debug session.
Performs logical ternary operator
condition ? ifTrue : ifFalse
represents boxlang this scope container
Models the Thread type of the DAP
This context represents the context of any function execution in BoxLang
It encapsulates the arguments scope and local scope and has a reference to
the function being invoked.
Models the Exit event for the Debug Protocol
Thread scope implementation in BoxLang.
Models the command that the debug tool has finished configuration.
Models a SetBreakpoint response in the DAP
I cast to Time objects
This class is a utility for timing operations.
The time units it supports
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/ToDoubleFunction.html
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/ToIntFunction.html
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/ToLongFunction.html
A transaction object that wraps a JDBC connection and provides transactional operations.
Results of the Java transformation
Contains a Java AST for the entry point and a collection of
AST for each class such as UDF other callables
Transpiler Base class
I require a specific type
If this record is present, ensure it is one of the valid string values (case insensitive)
Represents a UDF.
https://docs.oracle.com/en%2Fjava%2Fjavase%2F21%2Fdocs%2Fapi%2F%2F/java.base/java/util/function/ToDoubleFunction.html
I look for varibles output in tag based code which are not encoded
This exception is thrown when a modification attempt is made upon an unmodifiable (e.g.
Utility class for validating user-level data types such as credit cards, postal codes, phone numbers, and URLs.
I help validate records
If this record is present, ensure it is one of the valid string values (case insensitive)
If this record is present, ensure that the required records are also present
Models the request to launch a specific file
Models a SetBreakpoint response in the DAP
Variables scope implementation in BoxLang
Base class for the BoxLang AST Nodes
A filter that uses globbing style wildcards to filter cache keys case-sensitive or not.
This type represents an XML Object in BoxLang
I handle casting anything to XML
Listener class to synchronize changes between XMLChildren arrays and the native nodes
Performs logical XOR
a = b XOR c