# Package org.eclipse.m2m.atl.emftvm.util

Interface Summary
ModuleResolver: Resolves modules by name.
ModuleResolverFactory: Factory for `ModuleResolver`s.
PluginExtensionUtil: Eclipse plug-in extension utility for `ModelFactory`.
TypeMap<K,​V>: Provides extra functionality for finding supertypes of keys representing types.
VMMonitor: Allows monitoring and controlling a running EMFTVM instance.
WorkspaceUtil: Eclipse workspace utility.

Class Summary
ClassModuleResolver: `ModuleResolver` based on `Class.getResourceAsStream(String)`.
DefaultModuleResolver: Resolves modules based on an EMF URI prefix.
DefaultModuleResolverFactory: `ModuleResolverFactory` for `DefaultModuleResolver`s.
EmftvmAdapterFactory: The Adapter Factory for the model.
EmftvmSwitch<T>: The Switch for the model's inheritance hierarchy.
EMFTVMUtil: EMFTVM static utility methods.
EMFTVMUtil.RegistryTypeSwitch: Returns the registry type of the switched object.
EnumConversionList: Converts `Enumerator`s to `EnumLiteral`s.
EnumConversionListOnList: Converts `Enumerator`s to `EnumLiteral`s.
EnumConversionSetOnSet: Converts `Enumerator`s to `EnumLiteral`s.
EnumLiteral: Generic enumeration literal.
ExecEnvPool: Pool of reusable `ExecEnv`s.
FieldContainer: Reusable class for storage and lookup of `Field`s.
LazyBag<E>: Immutable `Collection` that supports lazy evaluation.
LazyBag.IncludingBag<E>: `LazyBag` that implements the "including" operation.
LazyBag.IntegerRangeBag: `LazyBag` that represents a range running from a first to last `Integer`.
LazyBag.LongRangeBag: `LazyBag` that represents a range running from a first to last `Long`.
LazyBag.UnionBag<E>: `LazyBag` that implements the "union" operation.
LazyBagOnCollection<E>: `LazyBag` that passes method calls through to the underlying `Collection`, where possible, instead of going via `Iterator`s.
LazyCollection<E>: Immutable `Collection` that supports lazy evaluation.
LazyCollection.CollectIterator<T>: `LazyCollection.ReadOnlyIterator` that collects the results of evaluating a function on each of the elements from the underlying collection.
LazyCollection.FlattenIterator: Recursively flattens any nested `Iterable`s by iterating over their elements as well.
LazyCollection.FlattenSetIterator: Recursively flattens any nested `Iterable`s by iterating over their elements as well.
LazyCollection.IntegerRangeListIterator: `LazyCollection.ReadOnlyIterator` for `Integer` ranges.
LazyCollection.LongRangeListIterator: `LazyCollection.ReadOnlyIterator` for `Long` ranges.
LazyCollection.ReadOnlyIterator<E>: `Iterator` without `LazyCollection.ReadOnlyIterator.remove()`.
LazyCollection.ReadOnlyListIterator<E>: `ListIterator` without `LazyCollection.ReadOnlyIterator.remove()`, `LazyCollection.ReadOnlyListIterator.add(Object)`, and `LazyCollection.ReadOnlyListIterator.set(Object)`.
LazyCollections: `LazyCollection`s utility class.
LazyList<E>: Immutable `EList` that supports lazy evaluation.
LazyList.AppendList<E>: `LazyList` that appends an element to the underlying `LazyList`.
LazyList.CollectList<E>: `LazyList` that implements the `LazyList.collect(CodeBlock)` function.
LazyList.InsertAtList<E>: `LazyList` that inserts an element it a given index in the underlying collection.
LazyList.IntegerRangeList: `LazyList` that represents a range running from a first to last `Integer`.
LazyList.LongRangeList: `LazyList` that represents a range running from a first to last `Long`.
LazyList.NonCachingList<E>: Abstract `LazyList` that disables caching of the underlying `LazyList`.
LazyList.PrependList<E>: `LazyList` that prepends an element to the underlying `LazyList`.
LazyList.ReverseList<E>: `LazyList` that reverses the order of the underlying list.
LazyList.SubList<E>: `LazyList` that presents a sub-range of the underlying list.
LazyList.UnionList<E>: `LazyList` that represents a union of the underlying `LazyList` and the added `LazyList`.
LazyListOnCollection<E>: `LazyList` that passes method calls through to the underlying `Collection`, where possible, instead of going via `Iterator`s.
LazyListOnList<E>: `LazyList` that passes method calls through to the underlying `List`, where possible, instead of going via iterators.
LazyOrderedSet<E>: Immutable `Set` and `List` that supports lazy evaluation.
LazyOrderedSet.AppendOrderedSet<E>: `LazyOrderedSet` that appends an element to the underlying `LazyOrderedSet`, except when it already occurs in the underlying `LazyOrderedSet`.
LazyOrderedSet.ExcludingOrderedSet<E>: `LazyOrderedSet` that excludes an element from the underlying `LazyOrderedSet`.
LazyOrderedSet.InsertAtOrderedSet<E>: `LazyOrderedSet` that inserts an object into the underlying `LazyOrderedSet`, except when it already occurs in the underlying `LazyOrderedSet`.
LazyOrderedSet.IntegerRangeOrderedSet: `LazyOrderedSet` that represents a range running from a first to last `Integer`.
LazyOrderedSet.LongRangeOrderedSet: `LazyOrderedSet` that represents a range running from a first to last `Long`.
LazyOrderedSet.NonCachingOrderedSet<E>: `LazyOrderedSet` that disables caching of the underlying `LazyOrderedSet`.
LazyOrderedSet.PrependOrderedSet<E>: `LazyOrderedSet` that prepends an element to the underlying `LazyOrderedSet`, except when it already occurs in the underlying `LazyOrderedSet`.
LazyOrderedSet.ReverseOrderedSet<E>: `LazyOrderedSet` in reverse order.
LazyOrderedSet.SubOrderedSet<E>: `LazyOrderedSet` that represents a sub-range of the underlying `LazyOrderedSet`.
LazySet<E>: Immutable `Set` that supports lazy evaluation.
LazySet.ExcludingSet<E>: `LazySet` that excludes an element from the underlying `LazySet`.
LazySet.IncludingSet<E>: `LazySet` that includes an element into the underlying `LazySet`, except if the element already occurs in the underlying `LazySet`.
LazySet.IntegerRangeSet: `LazySet` that represents a range running from a first to last `Integer`.
LazySet.LongRangeSet: `LazySet` that represents a range running from a first to last `Long`.
LazySet.NonCachingSet<E>: Abstract `LazySet` that disables caching of the underlying `LazySet`.
LazySetOnSet<E>: `LazySet` that passes method calls through to the underlying `Set`, where possible, instead of going via `Iterator`s.
MethodSignature: `Method` signature for EMFTVM method caching.
NativeCodeBlock: `CodeBlock` with empty native Java body.
NativeTypes: Contains a registry of native type names and their Java class implementations, and provides methods to instantiate native types.
OCLOperations: Provides native operations on simple OCL types.
OCLOperations.ResolveList: `LazyList` that resolves default trace links.
OCLOperations.UniqueResolveList: `LazyList` that resolves unique trace links within a given traced rule.
PluginExtensionUtilImpl: Implementation for `PluginExtensionUtil`.
ResourceIterable: Makes the contents of a `Resource` available as an `Iterable`.
SingletonModuleResolverFactory: Returns a singleton `ModuleResolver` instance.
Stack: EMFTVM stack.
StackFrame: EMFTVM stack frame.
TimingData: Records time data during the execution of the EMFTVM.
Tuple: Reflective, immutable implementation of OCL Tuples.
TypeHashMap<K,​V>: `HashMap` implementation of `TypeMap`.
Types: Contains EMFTVM type definitions.
WorkspaceUtilImpl: `WorkspaceUtil` implementation class.

Enum Summary
NativeTypes.NativeType: Enumeration of registered native types.

Exception Summary
DuplicateEntryException: Duplicate entry in `TypeHashMap`.
ModuleNotFoundException: Module not found.
VMException: EMFTVM runtime exception class.