BufferedReader: This is a reader which
is backed by a buffer which can read a larger block of characters at
once which should increase the efficiency of operations, it
additionally allows for marking.
BufferedWriter: This class buffers
characters into an internal buffer so that they can be written in bulk
to the underlying stream.
ByteArrayInputStream: This is a
class which reads from an input byte array and returns its data.
ByteArrayOutputStream: This an
output stream which outputs any written bytes to a byte array.
Character: This is a boxed representation
of {@link char}.
Class: This class is the in-language
representation of a Java class, the CLDC allows for minimal reflection
via {@link Class#forName(String)} and {@link Class#newInstance()}.
ClassCastException: This is thrown
when a class cannot be cast to another class.
Deprecated: This is a flagging annotation
which may be attached to classes, fields, and methods to indicate that
it should no longer be used in the future and alternatives should be
searched for and used instead.
FunctionalInterface: This is not
used by Java ME 8 or SquirrelJME, however it is needed by newer
versions of the Java compiler in order to compile modules correctly as
it will attempt to annotate interfaces that meet the criteria for
functional interfaces automatically.
Runtime: This class contains information
about the host memory environment along with providing methods to
perform garbage collection and exit the virtual machine.
EventListener: This class must be
implemented by anything that listens for events.
EventObject: The class which all event
objects shall be derived from.
Formatter: This class implements C-style
{@code printf()} formatted for text, it is inspired by the C language
but it does not match it exactly and this is far more strict in what
it requires.
Documented: This indicates that
the specified annotation should be documented by the Java
documentation tool whenever it is used.
ElementType: Specifies the
type of element that the annotation is permitted to be attached to in
the source code.
Inherited: Indicates that the
annotation type should automatically be inherited so that the subclass
type appears to have this annotation when it is requested.
Retention: This is used to
indicate how far into the compilation and runtime process should keep
a visible mark on an annotation.
RetentionPolicy: Specifies
how far through compilation and running of code that an annotation
should be visible.
Target: Specifies the context in
which the annotation is valid.
ObjectShelf: This shelf
supports object anything that has to do with objects.
PencilShelf: This shelf is
responsible for accelerated graphics drawing.
RawJarPackageBracketInputStream
: This is an input stream over the raw representation of a {@link
JarPackageBracket} which might not be in the form of a JAR or any
actual readable data.
ReferenceShelf: This
provides the interface for references which are used to weakly refer
to them, so that they may be collected or act as a cache.
ReflectionShelf:
SquirrelJME specific reflection oriented methods.
RuntimeShelf: Run-time
shelf which contains system information.
TaskShelf: This shelf allows
for the management of tasks and otherwise.
TerminalShelf: This
contains the shell for printing to the console and otherwise.
ThreadShelf: This shelf
handles everything regarding threading and otherwise.
TypeShelf: Provides the shelf
for types that exist within the JVM.
UIFormShelf: This is the
shelf which manages all the form based user interface that LCDUI uses
and such.
cc.squirreljme.jvm.pack
HeaderStruct: Common
header structure that is shared for all ROM formats.
JarRom: This represents a Jar,
or some other abstract file, within the ROM.
PackRom: This class is used to
access the pack ROM.
TableOfContents: This
represents a table of contents which is used to provide a mapping of
repeating keys to values, for each various entry.
TableOfContentsMemory
: Represents a {@link TableOfContents} which is stored in the standard
format to be read via memory using a memory mapped file that is
properly aligned.
Configuration: This
represents a configuration such as CLDC which specifies which base
classes are available.
DependencyInfo: This
contains the information which specifies all of the dependencies which
and application depends on.
EntryPoint: This represents
an entry point of a JAR.
EntryPoints: This parses
the entry points which are available for usage.
InternalName: This
represents an internal project name which is used by SquirrelJME.
InvalidSuiteException
: This is thrown when a midlet has an invalid property or is otherwise
not valid.
MarkedDependency:
This interface is used for anything which represents a dependency and
as such can be used to check if a provided meets the conditions for a
match.
MarkedProvided: This
interface is associated with anything which can be a provided detail
for a dependency.
MatchResult: This class
contains the results of a dependency match.
Profile: This represents a
profile that may be implemented, such as MIDP.
ProvidedInfo: This
contains all of the information for dependencies which are provided by
an application or library.
Standard: This represents a
standard which is provided by an API.
StandardName: This
represents the name of a standard.
SuiteDependency: This
represents a dependency that a LIBlet or MIDlet may depend on.
SuiteVersionRange:
This is used to handle version ranges that may be used for
dependencies.
TypedSuite: This represents
a suite with an associated type.
cc.squirreljme.runtime.cldc
DubiousImplementationError
: This is thrown when the implementation is based on documentation
where an assumption is made on what happens but where the
documentation and implementation are both suspect and lacking
information.
UIFormBracket:
This represents a form as a whole, it is displayed with {@link
UIDisplayBracket} and contains {@link UIItemBracket}.
UIItemBracket:
This represents an item within a {@link UIFormShelf}, it has one of
the {@link UIItemType} for its type.
UIWidgetBracket
: A widget that can be displayed for forms and such.
VMThreadBracket
: This bracket represents extra information regarding threads and
otherwise.
cc.squirreljme.jvm.mle.callbacks
NativeImageLoadCallback
: Callback to be used with {@link PencilShelf#nativeImageLoadRGBA(int,
byte[], int, int, NativeImageLoadCallback)}, for the purpose of
expanding native image loading in the future for various types of
images and otherwise.
ShelfCallback:
This is the base class for shelf callbacks.
UIDisplayCallback
: This callback is used for any calls the display system makes to
applications and otherwise.
UIDrawableCallback
: Base interface for any callbacks which have a paint operation for
drawing a display, form, or item.
UIFormCallback:
Interface that is used a callback on a user-interface form is to be
done.
VMType: This represents
the type of SquirrelJME virtual machine that is currently being used,
this is used for example to see which set of MLE calls are valid and
otherwise.
PackProperty:
Represents a property of a pack file.
PackTocFlag:
Flags for {@link TableOfContents} in {@link PackRom}.
PackTocProperty
: Properties for the pack file table of content entries.
StaticClassProperty
: Static class information properties, these are properties that are
stored within minimized class files.
cc.squirreljme.jvm.pack.mem
AbstractReadableMemory
: This is a class which handles reading of memory by using pure
integers instead of forcing all implementations to implement short and
byte readers.
HasByteOrder:
Interface used to describe any memory that has a byte order.
Api: This indicates
an actual API that is available for usage.
ApiDefinedDeprecated
: The API defines this as being deprecated however we do not use
{@link Deprecated} as that would emit warnings and interfere with
SquirrelJME needing to use such annotation.
ProgrammerTip
: This is a tip to the programmer (along with the developers of
SquirrelJME) so things can be remembered easier.
SquirrelJMEVendorApi
: This represents an exported SquirrelJME API, one which is intended
to be used by third parties and otherwise on specifically SquirrelJME.
VendorSpecificApi
: This is used to indicate vendor specific API for places where an API
should not be changed or otherwise.
MarkableInputStream
: This is an input stream which allows for marking input.
NamedCodec: This is
used to get the name of the encoder or decoder that was used.
NonClosedOutputStream
: This is an output stream which does not carry over {@link #close()}.
NonClosedWeakAppendable
: This is an {@link Appendable} which does not implement {@link
Closeable} but refers to the argument via a weak reference.
PrintStreamWriter
: This is a class which takes input characters and writes to the given
print stream.
SecureByteArrayOutputStream
: This is a {@link ByteArrayOutputStream} which does not expose the
internal buffer field via the {@link #writeTo(OutputStream)} method.
FDMLMath: This class
contains math methods which are derived from the Freely Distributed
Math Library, which is written in C which is then translated into
Java.
FloatArrayList:
Provides a list view of a {@code float} array.
IntegerArray:
This interface represents integer arrays.
