Package net.ontopia.utils

Contains utility classes and generic interfaces.

See:
          Description

Interface Summary
CachedIF INTERNAL: Interface that objects containing cached information should implement.
ClearableIF INTERNAL: A marker interface implemented by objects which can be cleared.
ClosureIF INTERNAL: Interface to represent some closure, a block of code which is executed from inside some block, function or iteration which operates on an input object.
CmdlineOptions.ListenerIF INTERNAL: A listener interface that must be implemented by object that are interested in options found by the CmdlineOptions instance.
CollectionFactoryIF INTERNAL: Factory that creates collection objects.
DeciderIF PUBLIC: Interface for classes that decides whether an object is acceptable or not.
FilterIF INTERNAL: Filters the objects in an iterator.
GrabberIF INTERNAL: Grabs an object from another object.
LookupIndexIF INTERNAL: An interface implemented by objects which can be used to look up information, but which can do no more.
PoolableSetFactoryIF INTERNAL: Factory interface used by SetPoolIF to create new PoolableSetIF instances.
PoolableSetIF INTERNAL: Interface implemented by sets that can be pooled by a SetPoolIF.
SetPoolIF INTERNAL: Interface implemented by all set pools.
StringifierIF PUBLIC: Stringifies objects.
 

Class Summary
AndDecider INTERNAL: Decider that checks all subdeciders and returns true if all of them gives a positive decision.
ArrayUtils INTERNAL: Class that contains useful array methods.
CachedDecider INTERNAL: Decider that maintains a cache of decisions made on a set of objects.
CachedGrabber INTERNAL: Grabber that maintains a cache of previously grabbed objects.
CachedIndex INTERNAL: A LookupIndexIF which uses another, slower, LookupIndexIF as a fallback and caches the values attached to the most commonly requested keys using an LRU strategy.
CachedStringifier INTERNAL: Stringifier that maintains a cache of previously stringified objects.
CacheManager INTERNAL: A manager class that manages cached objects.
ChainedIndex INTERNAL: A lookup index that delegates LookupIndexIF calls to chains of LookupIndexIFs.
CharacterSet INTERNAL: Represents a set of Unicode characters, and provides a method to quickly determine whether or not a particular character is in the set.
CmdlineOptions INTERNAL: A class that parses command line options.
CmdlineUtils INTERNAL: Class that contains useful stuff for command line utilities.
CollectionCollection INTERNAL: A collection that works as a facade for multiple collections.
CollectionFactory INTERNAL: A collection factory that returns non-synchronized standard java.util collection objects.
CollectionMap INTERNAL: A map which stores entries containing Collection values.
CollectionSortedMap INTERNAL: A sorted map which stores entries containing Collection values.
CollectionStringifier INTERNAL: Stringifier that stringifies collections.
CollectionUtils INTERNAL: Class that contains useful collection methods.
CompactHashSet INTERNAL: Implements the Set interface more compactly than java.util.HashSet by using a closed hashtable.
CompactIdentityHashSet INTERNAL: This class is a specialization of the CompactHashSet class, and uses the == operator to compare objects.
ContainmentDecider INTERNAL: Decider that returns true if the object is contained in the referenced collection.
DebugUtils INTERNAL: Useful debugging methods.
DeciderFilter INTERNAL: Filter that filters a collection using a decider.
DeciderIterator INTERNAL: An iterator that uses a decider to filter the elements of another iterator.
DeciderUtils INTERNAL: Utility methods for creating various kinds of useful deciders.
DefaultStringifier INTERNAL: Stringifier that calls the toString method on the object.
EmptyEnumerator INTERNAL: Implements an Enumeration that contains nothing.
EncryptedInputStream INTERNAL: Input stream for reading in a encrypted input stream (for example from a file) and giving back the decrypted values.
EncryptedOutputStream INTERNAL: Output stream for reading in a encrypted input stream (for example from a file) and giving back the decrypted values.
EncryptionUtils INTERNAL: Utilities for encrypting files.
EnumerationIterator INTERNAL: A wrapper class for traversing enumerations as iterators.
EqualsDecider INTERNAL: Decider whether the reference object is equal the given object.
FileUtils INTERNAL: Class that contains useful file operation methods.
FileWatchdog INTERNAL: Check every now and then that a certain file has not changed.
GrabberCollection INTERNAL: A collection that uses a grabber to populate itself by grabbing the individual objects of the nested collection.
GrabberComparator INTERNAL: Comparator that compares grabbed objects using a comparator.
GrabberDecider INTERNAL: Decider that grabs an object and passes it to the subdecider.
GrabberGrabber INTERNAL: Grabber that makes the second grabber grab what the first grabber grabs and so on.
GrabberIterator INTERNAL: An iterator that uses a grabber to grab object from another iterator.
GrabberMap INTERNAL: An implementation of Map that uses a key grabber and a value grabber to extract its content.
GrabberStringifier INTERNAL: Stringifies the object that the grabber grabs.
HashMapIndex INTERNAL: A lookup index that extends HashMap.
HistoryMap INTERNAL: Helper class for storing elements up to a certain amount, lower most elements will be removed to ensure a fixed size of the collection.
IteratorCollection INTERNAL: A wrapper class for presenting a collection view on iterators.
IteratorComparator INTERNAL: Comparator for Iterators.
IteratorIterator INTERNAL: An iterator that works as a facade for multiple iterators.
LexicalComparator INTERNAL: Comparator that performs a lexical comparison.
LowerCaseGrabber INTERNAL: Grabber that lowercases the String object given to it.
MapIndex INTERNAL: A non-synchronized lookup index adapter for Map instances.
MapWrapper INTERNAL: Abstract Map implementation that delegates all its method calls to the other map instance.
NotDecider INTERNAL: Decider that negates the decision of the nested decider.
NullObject INTERNAL: A singleton null object for use where null cannot be used, and an object is required.
ObjectUtils INTERNAL: Class that contains useful methods.
OrDecider INTERNAL: Decider that checks all subdeciders and returns true of one of them gives a positive decision.
PoolableSet INTERNAL: The default PoolableSet implementation.
PropertyUtils INTERNAL: Utility class for handling properties and their values.
QueryProfiler INTERNAL: Statistics collector for profiling queries, whether tolog or SQL.
ReaderInputStream INTERNAL: An InputStream stream that turns a Reader into an InputStream given an encoding.
RingBuffer INTERNAL: Utility for storing objects in a ring buffer.
SameGrabber INTERNAL: Grabber that grabs the object given to it, i.e.
SetPool INTERNAL: The default SetPool implementation.
SimpleFileFilter INTERNAL: Description: a simple file filter
SoftHashMap INTERNAL: A Map implementation that uses SoftReferences to reference keys.
SoftHashMapIndex INTERNAL: A lookup index implementation that uses soft references for the keys, in order to allow them to be garbage-collected.
SoftHashMapIndex.SoftEntry  
SoftValueHashMapIndex INTERNAL: A lookup index implementation that uses soft references for the values, in order to allow them to be garbage-collected.
SoftValueHashMapIndex.SoftEntry  
StreamUtils INTERNAL: Utilities for working with streams and readers.
Stringified INTERNAL: Utility class that wraps an object and a stringifier for use with the Object.toString() method.
StringifierComparator INTERNAL: Comparator that stringifies the arguments and compares them using another comparator.
StringifierDecider INTERNAL: Decider that stringifies an object and passes it to the subdecider.
StringifierGrabber INTERNAL: Grabber that grabs a stringified version of the object given to it.
StringTemplateUtils INTERNAL: Utilities for processing string templates containing %param% references.
StringUtils INTERNAL: Class that contains useful string operation methods.
SubstringGrabber INTERNAL: Grabber that grabs a substring from the String object given to it.
SynchronizedCollectionFactory INTERNAL: A collection factory that returns synchronized standard java.util collection objects.
SynchronizedCompactHashSet INTERNAL: Extends CompactHashSet to make it synchronized.
SynchronizedLookupIndex INTERNAL: Synchronized wrapper class for LookupIndexIF instances.
TimeMeasureUtils INTERNAL: Helper class for providing some more convenience for time measurement.
TimeSamples INTERNAL: Store a set a time samples for easier calculation of minimum, maximum and average times.
TraceUtils INTERNAL: Useful tracing methods.
UniqueSet INTERNAL:
UpperCaseGrabber INTERNAL: Grabber that uppercases the String object given to it.
URIUtils INTERNAL: Utilities for working with URIs.
URLChecker INTERNAL: Tries to establish a connection to URL and check whether it could be retrieved or is not reachable.
WeakHashMapIndex INTERNAL: A lookup index that extends WeakHashMap.
WrappedInputStream  
 

Exception Summary
CmdlineOptions.OptionsException INTERNAL: An exception that is thrown when there are problems with the options specified on the command line.
OntopiaException PUBLIC: An exception class that can be used to wrap other exceptions with.
OntopiaLicenseException INTERNAL: An exception class that is thrown when licence related issues occur.
OntopiaRuntimeException PUBLIC: A runtime exception class that can be used to wrap other exceptions with.
OntopiaUnsupportedException INTERNAL: Thrown to indicate that the requested operation is not supported.
 

Package net.ontopia.utils Description

Contains utility classes and generic interfaces. The classes and interfaces in this package are very general and independent from other packages.



Copyright © 2000-2009 Ontopia.