All Classes and Interfaces
Class
Description
HACK: Had to make a copy of org.apache.wicket.markup.html.link.BookmarkablePageLink because the getPageClass() method was final.
INTERNAL: Common superclass for or clauses and other kinds of clauses.
INTERNAL:
INTERNAL: Common code-sharing superclass for dynamic predicates.
INTERNAL: An abstract field info class containing the common
behaviour for FieldInfoIFs.
INTERNAL: Abstract implementation of FunctionIF, which should be the
superclass for customized functions.
INTERNAL: An abstract index class.
INTERNAL: Common superclass for the two instance-of predicates.
INTERNAL: A transactional storage cache implementation.
INTERNAL: The abstract locator class.
INTERNAL: Common abstract superclass for sources that support what
Ontopoly needs, which is full-text indexing and creation of new
topic maps.
INTERNAL: Common abstract superclass for references from sources
that support what Ontopoly needs.
INTERNAL: Abstract class implementing TopicMapSourceIF; locates
topic map file references from a given directory on the local file
system.
INTERNAL: A collection of utility methods used by classes which need
to evaluate queries.
INTERNAL: An abstract PersistentIF implementation that handles most
of the machinery needed to implement persistent objects.
INTERNAL: An abstract PersistentIF implementation that handles most
of the machinery needed to implement persistent objects.
PUBLIC: Abstract SearcherIF convenience superclass used to get the
default implementation of the four set methods.
PUBLIC: Abstract SearchResultIF superclass.
INTERNAL: Class used to build SQL queries from JDO queries.
INTERNAL: Class that maintains indexes for use with the TopicMapIF locator
lookup methods.
INTERNAL: Code-sharing abstract superclass for GetTag and PutTag.
Abstract topic generator.
INTERNAL: Abstract SAX2 content handler used for reading various
kinds of topic map documents.
INTERNAL: Abstract class providing common operations used by XML
exporters.
PUBLIC: Base class for topic map listeners.
INTERNAL: Common abstract superclass for topic map readers.
INTERNAL: An abstract topic map reference class that contains
methods that handles the id and title properties.
INTERNAL: An abstract TopicMapStoreIF implementation.
INTERNAL: An abstract TopicMapTransactionIF implementation.
INTERNAL: The default proxy transaction implementation.
INTERNAL: Common superclass for all typing topics, like association types,
topic types, role types, etc.
INTERNAL: An abstract topic map reference class that retrieves
topic maps referenced through URLs.
INTERNAL: Abstract class which provides access to filtering themes
out which are not relevant to the user context.
INTERNAL: Abstract class which provides access to filtering themes
out which are not relevant to the user context.
INTERNAL: A common base class for Reader implementations that can
read XML-based syntaxes.
INTERNAL: Interface for receiving notification when data is being
read from database storage.
AddFragmentRequest bean class
Factory class that keeps the parse method
AddFragmentResponse bean class
Factory class that keeps the parse method
INTERNAL: A field that references an aggregate class.
Subclass of Check that notifies an AjaxParentFormChoiceComponentUpdatingBehavior when
it is being rendered.
This is variant of AjaxFormChoiceComponentUpdatingBehavior that allows
nested AjaxParentRadioChild and AjaxParentCheckChild instances to update
the parent RadioGroup or CheckGroup.
Subclass of Radio that notifies an AjaxParentFormChoiceComponentUpdatingBehavior when
it is being rendered.
INTERNAL: This class is used to wrap Jena Literal objects in the
ARP ALiteral interface so that they can be streamed through the ARP
StatementHandler interface without requiring new objects to be
created.
INTERNAL: Exception used to wrap other exceptions so that they can
be thrown from inside ANTLR-generated code.
INTERNAL: Exception used to wrap other exceptions so that they can
be thrown from inside ANTLR-generated code.
EXPERIMENTAL: Application context for the Vizlet.
INTERNAL: Decider that decides whether the ScopedIF's scope is
applicable in the user context.
EXPERIMENTAL: Common methods for all application contexts.
EXPERIMENTAL: Interface to define the application context.
INTERNAL: This class is used to wrap Jena Resource objects in the
ARP AResource interface so that they can be streamed through the ARP
StatementHandler interface without requiring new objects to be
created.
INTERNAL: Represents one argument in the signature checked by
ArgumentValidator.
INTERNAL: Instances of this class represent a signature of some
predicate/function/object that takes a positional list of arguments
and can validate whether a given list of arguments are valid
according to the signature.
INTERNAL: Immutable Map implementation that stores its keys and
values in two arrays.
INTERNAL: Value producing tag that finds all the topics associated
with this the topics in the input collection, subject to some
constraints.
INTERNAL: The basic association implementation.
INTERNAL: The rdbms association implementation.
PUBLIC: A helper class that makes it easier to build associations.
INTERNAL: A Comparator for ordering AssociationIFs alphabetically
after their type.
Represents an association field.
INTERNAL: A Comparator for ordering AssociationIFs after their ID.
PUBLIC: Implemented by objects representing associations in the
topic map model.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: Implements the 'association' predicate.
INTERNAL: Implements the 'association($association)' predicate.
INTERNAL: The basic association role implementation.
INTERNAL: The rdbms association role implementation.
INTERNAL: A comparator for ordering AssociationRoleIFs
alphabetically by role player and role type.
PUBLIC: Implemented by objects representing association roles in
the topic map model.
INTERNAL: Implements the 'association-role' predicate.
INTERNAL: Implements the 'association-role' predicate.
INTERNAL: A comparator for ordering AssociationRoleIFs alphabetically
by role type and role player.
Topic map sanity controller.
INTERNAL: Value Producing Tag for finding all the associations
of all the topics or association roles in a collection.
Represents an association type.
INTERNAL: Special Tag for iterating over a sorted collection of
triples (Association Type, Association Role Type, Association),
creating new content for each iteration.
PUBLIC: Computes the transitive closure of a relation characterized by
two specific roles within a specific association type.
PUBLIC: This interface defines a listener to the
AssociationWalker.
INTERNAL: Helper class for storing one triple consisting of
(Association Type, AssociationRoleType, Associations).
INTERNAL: Specialized comparator for AssocInfoStorage objects.
INTERNAL: Class used for representing data store object identities
with only a single key.
INTERNAL: A custom JSP tag which allows to create an attribute
name-value pair and assign it to the parent element tag, which is
responsible for the output.
INTERNAL: Experimental auto suggest servlet.
PUBLIC: This exception is used to indicate that there is something
wrong with the query, whether syntactically or semantically.
INTERNAL: Implements the 'base-locator' predicate.
INTERNAL: Implements the 'base-locator(address)' predicate.
INTERNAL: Abstract class which provides access to filtering themes
out which are not relevant to the user context.
INTERNAL: Abstract class which provides access to filtering themes
out which are not relevant to the user context.
INTERNAL: Abstract super-class of an Output-Producing Tag.
INTERNAL: Abstract super-class of an Output-Producing Tag.
INTERNAL: Abstract Base class for value producing and accepting tags
which are taking the context filter into account.
INTERNAL: Abstract super-class of a tag that is both value-producing
and value-accepting.
INTERNAL: Abstract super-class of an Value-Producing Tag.
INTERNAL: Query component that is used to perform the count
operation for QueryMatches instances.
INTERNAL: An abstract dynamic index superclass.
INTERNAL: Represents a predicate in the basic implementation.
INTERNAL: Query component that is used to fully execute basic tolog
clauses.
INTERNAL: Query component that is used to perform the reduce
operation for QueryMatches instances.
INTERNAL: Query component that is used to perform the sort
operation for QueryMatches instances.
PUBLIC: Utilities for treating objects as beans.
INTERNAL.
INTERNAL: Bind Tag for turning map keys into variables.
INTERNAL:
INTERNAL: Query result representating queries have no variables and
evaluate to either true or false.
INTERNAL: Class used to build SQL queries from JDO queries.
INTERNAL: Created when there are XML parse errors in the
configuration file so that we can report these errors in a proper
way.
INTERNAL: The event handler which actually builds the topic map.
INTERNAL: Class used by storage caches to hold field values for a
single object.
INTERNAL: Simple interface used by innermost caches.
INTERNAL:
INTERNAL: Logic Tag for calling a template function and instantiates
its contents.
PUBLIC: Reads a topic map and writes it out in ISO CXTM.
INTERNAL: SAX document handler that prints canonical XML.
PUBLIC: A topic map writer that writes topic maps out to Ontopia's
Canonical XTM topic map format.
PUBLIC: A topic map writer that writes topic maps out to the format
defined in ISO 13250-4: Topic Maps -- Canonicalization.
Represents a cardinality that can be assigned to a field.
INTERNAL: Data carrier holding the information about a change log
table from the mapping file.
INTERNAL: A change log reader is a tuple reader that is used to
read a change log relation.
INTERNAL: This tuple reader wraps an underlying tuple reader, and
collapses a sequence of actions for the same key into a single
final action.
INTERNAL: We used to have five change types (declared as static
ints in ChangelogReaderIF), but reduced that to the current two.
INTERNAL:
INTERNAL: Characteristic processing utilities.
INTERNAL: Represents a set of Unicode characters, and provides a
method to quickly determine whether or not a particular character
is in the set.
INTERNAL: Provides various argument constraint checks.
INTERNAL: Defines the names and types of variables
used by the
CheckUserTag.INTERNAL: Framework related tag for checking if a valid user object
exists in the session scope, otherwise creates a new one.
PUBLIC: Command-line tool for extracting keywords from a document.
INTERNAL: Tolog Tag for evaluating a sequence of child WhenTags.
INTERNAL: Interface for accessing class instances in the
database.
INTERNAL: Class used for holding object relational mapping class
declarations.
INTERNAL: Value Producing Tag for finding all the classes
of all the objects in a collection.
INTERNAL: Value Producing Tag for finding all topics that define classes,
either in general, or of a specific kind of object.
INTERNAL:
INTERNAL: Interface that holds the identifier and the actual
content of a classifiable resource.
INTERNAL: Interface implemented by code that is able to locate
classifiable content for topics.
INTERNAL:
INTERNAL: A class descriptor-like class that is used by the RDBMS
proxy implementation to access the information it needs about the
object relational class descriptor in an optimized manner.
INTERNAL: A interface for class descriptor-like object types that
is used by the proxy implementation to access the information it
needs about the object relational class descriptor in an optimized
manner.
INTERNAL: The basic dynamic class instance index implementation.
INTERNAL: The rdbms class instance index implementation.
PUBLIC: Interface implemented by objects providing quick lookup
facilities to find topics used as types, and the instances of those
types, within a topic map.
INTERNAL: Utilities for working with class-instance relationships.
INTERNAL: CacheIF implementation that wraps a Map and notified the
cluster about removals.
INTERNAL: Cluster implementation interface.
INTERNAL: A class that parses command line options.
INTERNAL: A listener interface that must be implemented by object
that are interested in options found by the CmdlineOptions
instance.
INTERNAL: An exception that is thrown when there are problems
with the options specified on the command line.
INTERNAL: Class that contains useful stuff for command line utilities.
INTERNAL: Implements the 'coalesce' predicate.
INTERNAL: Implements the coalesce predicate.
INTERNAL: A collection factory that returns non-synchronized standard
java.util collection objects.
INTERNAL: Factory that creates collection objects.
INTERNAL: A map which stores entries containing Collection
values.
INTERNAL: Parameter processor that embeds collection parameters
inside SQL statements.
INTERNAL: A sorted map which stores entries containing Collection
values.
INTERNAL: Class that contains useful collection methods.
INTERNAL: Represents the definition of a relational database column.
INTERNAL: Implements the Set interface more compactly than
java.util.HashSet by using a closed hashtable.
INTERNAL: This class is a specialization of the CompactHashSet
class, and uses the == operator to compare objects.
INTERNAL:
INTERNAL:
INTERNAL: SAX entity resolver that makes sure that doctypes
referencing the XTM 1.0 DTD is ignored.
INTERNAL: An interface for creating/requesting new JDBC connection
object.
INTERNAL: Consistifies a topic map by merging topics based on the
TNC, removing duplicate associations, and so on.
PUBLIC: Thrown when an object model constraint is violated.
INTERNAL:
INTERNAL: InputStream that knows its length.
INTERNAL: Reader that knows its length.
INTERNAL: Thrown when problems occur in content store
implementations.
INTERNAL: A simple content store interface that stores chunks of
data associated with an integer key.
INTERNAL: A servlet implementation that returns content stored in a
content store.
INTERNAL: Utility methods for accessing the content store.
INTERNAL: Output Producing Tag for writing out the content of an
occurrence or a string.
INTERNAL: Object used to hold contextual information while
processing tuples.
INTERNAL: Used to make the topic map repository and its references
available as a request attribute.
INTERNAL: Defines the names and types of variables used by the
ContextTag.INTERNAL: Default Implementation of ContextManagerIF.
INTERNAL: Interface which have to be implemented by classes
managing the context of a complete sub-hierarchy.
INTERNAL: Used to make the OKS variables available as request
attributes.
INTERNAL: Helper class used when creating QueryProcessors.
INTERNAL: Grabber that grabs the most appropriate basename from a
topic and then the most appropriate variant name, if one can be
found.
INTERNAL: Logic Tag for establishing the outermost lexical scope in
which all computation happens and the embedded tags are executed.
PUBLIC: Utility methods for working with the variable bindings in
the Navigator context.
PUBLIC: Provides model, view and skin information for the application
PUBLIC: Interface for ControlConfig.
INTERNAL: Value Producing Tag for copying another collection.
INTERNAL: Utilities for copying topic map data.
INTERNAL: Output-Producing Tag, which writes out the number
of objects in a collection.
Represents the edit mode of a field.
INTERNAL: Expected input is a map with arbitrary keys and values of Object[] type.
PUBLIC: Thrown when a topic map object is attempted used in more
than a single topic maps.
INTERNAL: Data source that reads CSV files from a directory.
INTERNAL: Command line tool for exporting comma- or semicolon
separated files into a database.
INTERNAL: Command line tool for importing comma- or semicolon
separated files into a database.
INTERNAL: Command line tool for importing comma- or semicolon
separated files into a database.
INTERNAL: An encoding sniffer for CTM.
A CTM lexer, to be used with the Antlr-generated parser.
INTERNAL: Parser for the CTM syntax.
INTERNAL: Source that locates CTM topic map files in a directory on
the file system.
PUBLIC: This TopicMapReader can read topic maps from the ISO-standard
CTM syntax.
INTERNAL: An CTM file topic map reference.
INTERNAL: Stringifier that stringifies TopicNameIFs and VariantNameIFs
by calling their getValue() method.
INTERNAL: Class that can read a database schema definition from an
XML representation.
INTERNAL: Experimental data integration servlet.
INTERNAL: A
ConnectionFactoryIF backed by a DataSource.INTERNAL: A data source interface.
INTERNAL: Represents the definition of a relational database datatype.
Represents a datatype which can be assigned to an occurrence type.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL:
INTERNAL: Implements the 'datatype' predicate.
INTERNAL: Implements the 'datatype(occ|var, datatype-uri)' predicate.
PUBLIC: Enumeration of common data types.
INTERNAL: Class that generates DDL statements for the IBM db2
universal database platform.
PUBLIC: The driver class used to do conversions with DB2TM.
INTERNAL: Thrown when configuration errors are detected by DB2TM.
INTERNAL: Thrown when runtime errors occur inside DB2TM.
INTERNAL: Thrown when data input errors are detected by DB2TM.
INTERNAL: A datasource wrapping the DBCP2 connection pooling.
INTERNAL: Command line tool for creating and dropping database
schemas directly in a database.
INTERNAL: Command line tool for producing DDL files for creating
and dropping database schemas.
INTERNAL: Output-producing tag used for debugging.
INTERNAL: Filter that filters a collection using a decider.
INTERNAL: A NavigatorDeciderIF implementation which wraps DeciderIF,
so that they can work with the navigator decider interface.
PUBLIC: Represents a set of parsed query declarations.
INTERNAL: Tolog Tag for making a set of tolog declarations
available within the nearest ancestor ContextTag.
INTERNAL: CacheIF implementation that wraps a Map.
INTERNAL: Default caches.
INTERNAL: The default field handler implementation that is able to
read values from result sets and bind values in prepared statements
without any particular knowledge about fields.
INTERNAL: class which implements interface NavigatorDeciderIF.
Fake the JspWriter, needed for execution of a JSP.
PUBLIC: The default data carrier for models.
INTERNAL: The default data carrier for models.
INTERNAL: Parameter processor that binds parameters to SQL
statements without any special preprocessing.
INTERNAL:
INTERNAL: This is the plugin implementation that is used if no
other implementation is requested in the plugin.xml file.
PUBLIC: The default data carrier for skin.
INTERNAL: The default data carrier for skin.
INTERNAL:
INTERNAL: The default topic map document generator that generates
DocumentIFs for topic map objects.
INTERNAL: A convenience class that that maintains an arbitrary
collection of topic map references.
INTERNAL: Default link generator which produces links to any kind
of topic map object.
PUBLIC: The default data carrier for views.
INTERNAL: The default data carrier for views.
INTERNAL: An XML reader factory that uses a JaxpXMLReaderFactory
unless the 'org.xml.sax.driver' system property is set, in that
case SaxXMLReaderFactory is used.
INTERNAL: Represents a parsed DELETE statement.
DeleteTopicRequest bean class
Factory class that keeps the parse method
DeleteTopicResponse bean class
Factory class that keeps the parse method
INTERNAL: Topic map object deletion utilities.
INTERNAL:
EXPERIMENTAL: Information for the VizDesktop version of Vizigator
INTERNAL: Interface for representing shared queries.
INTERNAL: Value Producing Tag for computing
the set difference of two collections.
INTERNAL: Implements the 'direct-instance-of' predicate using the indexes.
INTERNAL: Implements the 'direct-instance-of' predicate.
INTERNAL: Used by the Omnigator to create the collapsible tree view
of hierarchical association types.
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL: Represents an indexable unit of information.
INTERNAL: Interface for processing a document.
INTERNAL:
INTERNAL:
INTERNAL: A datasource creating connections from a
DriverManagerConnectionFactory.Used to report all duplicate occurrences(same locator, same occurrence roletype)
on a single topic.
INTERNAL: Thrown when a reifiable object is reified by a topic that
already reifies another reifiable object.
PUBLIC: A helper class that can remove duplicate objects from a topic map.
INTERNAL: PRIVATE: EXPERIMENTAL: Description: Dynamic proxy for associations
INTERNAL: Implements association type predicates.
INTERNAL: Implements dynamic association predicates.
INTERNAL:
PRIVATE:
INTERNAL: Special predicate used when a topic is used as a
predicate but the topic is neither an association type nor an
occurrence type.
INTERNAL: Implements dynamic association predicates.
INTERNAL: Implements occurrence predicates.
INTERNAL: Implements dynamic occurrence predicates.
EXPERIMENTAL: This class can output a nice collapsing/expanding
tree view of a topic map implemented with DHTML, which uses tolog
queries to produce the tree.
Represents the edit mode of a field.
INTERNAL: A custom JSP tag which allows to output an element
(ie.
INTERNAL: An InputSource factory that creates input sources with no
content.
INTERNAL: An object which can guess the encoding of an input stream
by peeking into its contents.
INTERNAL: Input stream for reading in a encrypted input stream (for
example from a file) and giving back the decrypted values.
INTERNAL: Utilities for encrypting files.
INTERNAL: Relation mapping concept that represents topic or
association definitions.
EXPERIMENTAL: Sample filter implementation that returns true if all
arguments are equal.
INTERNAL: Implements the '=' predicate.
INTERNAL: Implements the '=' predicate.
INTERNAL: SQL optimizer that removes A = A and A !
INTERNAL: A generalized error dialog which displays an exception by
showing the error message, but with support for showing the
traceback if necessary.
INTERNAL: Logic Tag to allow JSP pages to signal errors.
INTERNAL: An event listener interface.
INTERNAL: An event manager listener interface.
INTERNAL: Simple interface used by helper objects for invalidation purposes.
INTERNAL: Command-line driver for DB2TM.
INTERNAL: Represents an <expression-column> element in the
mapping file.
TGPanel contains code for drawing the graph, and storing which nodes are
selected, and which ones the mouse is over.
ExtensionMapper class
INTERNAL: Logic Tag for loading and registering an external function.
PUBLIC: An interface that can be implemented by handlers that would
like to intercept external references in topic map documents.
INTERNAL: Fake body content for use with the ontopia fake jsp
environment.
INTERNAL: Fake the ServletContext, needed for execution of servlets
INTERNAL: Fake the PageContext, needed for execution of a JSP.
INTERNAL: Fake the ServletContext, needed for execution of servlets.
Fake the ServletRequest, needed for execution of a servlet/JSP.
INTERNAL: Fake the ServletResponse, needed for execution of a servlet/JSP.
EXPERIMENTAL: An implementation that looks up topics in all
the given TopicIndexIFs and returns them.
INTERNAL: Relation mapping concept that refers to a field
definition belonging to an entity.
INTERNAL: Interface for reading and updating object field
values.
Represents a field as assigned to a topic type.
Represents a field type, which may be a name type, an occurrence type, an
identity field, or a combination of an association role and an association
type.
INTERNAL: Class used for holding object relational mapping field
declarations.
INTERNAL: Interface for use by classes that retrieve field values
from result sets and bind values in prepared statements.
INTERNAL: Represents a name value pair that can be attached to a
document.
INTERNAL: A field descriptor-like class that is used by the RDBMS
proxy implementation to access the information it needs about the
object relational field descriptor in an optimized manner.
Represents a populated field attached to an instance topic.
Represents a fields view.
INTERNAL: Class containing utility methods for processing
descriptor information.
INTERNAL: A content store implementation based on the file system.
INTERNAL: Filters the objects in an iterator.
EXPERIMENTAL: Base predicate that provides a simple interface for
implementing predicate filters.
INTERNAL: Class used to build SQL queries from JDO queries.
INTERNAL: Value Producing Tag for taking an input collection
and filtering it, passing only some of the elements on
to its parent (could be a set tag or another filter element).
INTERNAL: Class that generates DDL statements for the firebird /
interbase database platform.
INTERNAL: Iterator which returns each object returned by the query,
checking each row against the previous to avoid duplicates.
INTERNAL: Interface implemented by data repository accessors that
needs to be informed when changes to the repository needs to be
performed.
Behaviour that uses JavaScript to assign focus to component on page load.
INTERNAL: Logic Tag for iterating over each object in a collection,
creating new content for each iteration.
INTERNAL:
Tolog Tag for executing a query, iterating over each object in a result
collection and creating new content for each iteration.
INTERNAL:
INTERNAL: Interface that encapsulates the support for a given
document format.
INTERNAL: Framework related utility class providing some helper
methods needed to easier for examples access user information.
INTERNAL: A frequency table giving the frequency with which a
particular word is used in a particular language.
Interface that describes a fulltext indexation service for use in
InMemoryTopicMapStore.INTERNAL: The indexer manager will keep track of base names,
variants and occurrences that are changed in the topic map.
INTERNAL: Tag used for executing fulltext queries and producing
ranked list of topic map objects.
INTERNAL: A FunctionIF implementation used by the XML-based
ModuleIF reader code.
INTERNAL: Implemented by an object which represents a executable
function within the navigator framework.
INTERNAL: A collection of DB2TM functions intended to be used in
the function-column element.
INTERNAL: Virtual column that uses a function to map from old value
to new value.
INTERNAL: A General Configuration frame for the VizDesktop
INTERNAL: The default document implementation.
INTERNAL: A generic document field.
INTERNAL: A generic locator class.
INTERNAL: Generic SQL statement generator.
INTERNAL: Class that generates DDL statements for the generic
database platform.
INTERNAL: The implementation of <framework:getcontext>.
INTERNAL: Gets a string for use in a JSP template (view) via a key
defined in a "put" tag on the original JSP (model).
GetTologRequest bean class
Factory class that keeps the parse method
GetTologResponse bean class
Factory class that keeps the parse method
GetTopicPageRequest bean class
Factory class that keeps the parse method
GetTopicPageResponse bean class
Factory class that keeps the parse method
GetTopicRequest bean class
Factory class that keeps the parse method
GetTopicResponse bean class
Factory class that keeps the parse method
INTERNAL: Represents the global immutable context of all tolog
queries.
INTERNAL: Plugin implementation for a Google search Link resp.
INTERNAL: Stringifies the object that the grabber
grabs.
INTERNAL: Implements the '>=' predicate.
INTERNAL: Implements the 'gteq' predicate.
INTERNAL: Implements the '>' predicate.
INTERNAL: Implements the 'gt' predicate.
INTERNAL: Implementation of FunctionIF interface for testing
purposes.
INTERNAL:
INTERNAL: A key generator using the HIGH/LOW key generator
algorithm.
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.
INTERNAL: Class that holds search hit data.
INTERNAL:
INTERNAL: Wrapper class for HttpServletRequest; needed because Tomcat
does not let us use the standard one.
EXPERIMENTAL: HTTP searcher implementation.
INTERNAL: Interface implemented by ClassifyPluginIFs that want
access to the current HTTP request in a servlet environment.
PUBLIC: Index that holds information about identifiers in the
topic map.
INTERNAL: Class used for representing data store object identities
with more than a single key.
INTERNAL: A set implementation that wraps an identity collection
and presents the underlying collection as if it had PersistentIF
instances inside.
Represents an identify field.
INTERNAL: A field that represents the identity of instances of a
class.
INTERNAL: Interface used to represent data store object
identity.
INTERNAL: Thrown when an object was not found in the database.
Represents an identity type.
INTERNAL: Utilities for working with identities of topic map
objects.
INTERNAL: Logic Tag: The else part of the if tag.
INTERNAL: Logic Tag for iterating over each object in a collection,
creating new content for each iteration.
INTERNAL: Tolog Tag for testing if a variable is bound and non-null
or if a query gives a non-empty result.
INTERNAL: Logic Tag: the then part of the if tag.
INTERNAL: SAX entity resolver that makes sure that doctype
declarations referencing the ISO 13250 and XTM 1.0 DTDs using
public ids are ignored.
Service definition for services that provide format reader and writers.
PUBLIC: Utilities for importing and exporting topic maps.
INTERNAL: Marker interface used to indicate that the generateHTML
method returns a local URI reference that is to be included and
used to render the plug-in.
INTERNAL: Logic Tag for creating template functions specified by a
module file, which may be called from elsewhere in the JSP page
using the
call tag.INTERNAL: SAX entity resolver that makes sure that doctype
declarations referencing the XTM 1.0 DTD using public ids are given
the correct DTD.
INTERNAL: Represents the definition of a relational table index.
INTERNAL: Represents a search engine indexer.
PUBLIC: A marker interface for all indexes.
INTERNAL: The basic index manager implementation.
INTERNAL: The rdbms index manager.
Deprecated.
Use the TopicMapIF.getIndex(String) method instead.
INTERNAL: The indicator field handler implementation that is able
to...
INTERNAL: Value Producing Tag for finding all the subject indicators
(as LocatorIF objects) of all the topics in a collection.
INTERNAL: Content store implementation that saves everything in memory.
PUBLIC: The in-memory TopicMapStoreFactoryIF implementation.
PUBLIC: The in-memory TopicMapStoreIF implementation.
INTERNAL: The in-memory transaction implementation.
INTERNAL: Implements the 'in(var, e1, ..., eN)' predicate.
INTERNAL: The implementation of the 'in(var, e1, ..., eN)' predicate.
INTERNAL: A factory interface for creating SAX InputSources.
INTERNAL: Represents a parsed INSERT statement.
INTERNAL: Defines the template JSP to forward the request to, once
all of the PutTag strings have been stored.
INTERNAL: Implements the 'instance-of' predicate using the indexes.
INTERNAL: Implements the 'instance-of' predicate.
INTERNAL: Value Producing Tag for finding all the instances of all
the objects in a collection.
INTERNAL: Shared metrics across Datasources.
INTERNAL.
Represents a datatype which can be assigned to an association field.
INTERNAL: Decider that decides whether the ScopedIF's scope is an
intersection of the user context or not.
INTERNAL: Value Producing Tag for computing
the intersection of two collections.
PUBLIC: This exception is used to indicate that there is something
wrong with the query, whether syntactically or semantically.
PUBLIC: Thrown when an invalid topic map is processed.
INTERNAL: A special generator that's used when an IRI is passed as
an argument to a template because this can be either a topic
reference or an IRI literal, and we don't know which.
INTERNAL: Implements the 'item-identifier(thing, locator)' predicate.
INTERNAL: Implements the 'item-identifier(tmobject,locator)' predicate.
INTERNAL: Comparator for Iterators.
Extension of the default jackson converter that allows the use of @JsonView.
EXPERIMENTAL: A query module that is able to instantiate predicates
when given a java class name.
INTERNAL: Abstract predicate class that works as a common
superclass for the real predicate classes.
EXPERIMENTAL: Java searcher predicate.
INTERNAL:
INTERNAL: Content store implementation on top of JDBC that uses a
non-native sequence generator to generate keys.
INTERNAL: Data source that reads tables via JDBC.
INTERNAL: Content store implementation on top of JDBC that uses
native database sequences to generate keys.
INTERNAL: Data source that reads tables via JDBC.
INTERNAL: JDOQL aggregate function.
INTERNAL: Represents an aggregate function in a JDO query.
INTERNAL: JDOQL logical expression: and (&&).
INTERNAL: A predicate wrapper that delegates all it's method calls
to the nested basic predicate.
INTERNAL: JDOQL boolean expression value: true or false.
INTERNAL: JDOQL value: collection.
INTERNAL: JDOQL method: Collection.contains(Object).
INTERNAL: JDOQL method: String.endsWith(String).
INTERNAL: JDOQL method: Object.equals(Object) (==).
INTERNAL: Methods for reducing JDOExpressionIF, so that expressions
that require no input data can be removed from the query.
INTERNAL: Represents an expression in a JDO query.
INTERNAL: JDOQL value: instance field.
INTERNAL: JDOQL method: Object.<operator>(Object,...).
INTERNAL: JDOQL method: Collection.isEmpty().
INTERNAL: JDOQL method: String.like(String).
INTERNAL: JDOQL value: native value expression.
INTERNAL: JDOQL logical expression: not (!).
INTERNAL: JDOQL method: !
INTERNAL: JDOQL value: null.
INTERNAL: JDOQL value: object.
INTERNAL: JDOQL logical expression: or (||).
INTERNAL: JDOQL order by statement.
INTERNAL: JDOQL value: parameter.
INTERNAL: Represents a predicate in the rdbms implementation.
INTERNAL: JDOQL value: primitive.
INTERNAL: JDOQL complete query.
INTERNAL: Query component that executes JDO queries and wraps the
resulting QueryResultIF in a QueryMatches instance..
INTERNAL: JDOQL set operation.
INTERNAL: JDOQL method: String.startsWith(String).
INTERNAL: JDOQL value: string.
INTERNAL: JDOQL boolean expression value: true or false.
INTERNAL: Represents a value in a JDO query.
INTERNAL: JDOQL value: variable.
INTERNAL: Visitor interface
INTERNAL: Exception used to wrap other exceptions so that they can
be thrown from inside JFlex-generated code.
INTERNAL: Caches used by JGroups cluster.
INTERNAL: Class that represents a cluster of OKS instances.
INTERNAL:
INTERNAL: A JNDI datasource wrapper to allow metrics.
PUBLIC: A JSON serializer.
INTERNAL: A Content Handler that reads a JSP file and builds a
JSP tree of JSPTreeNodeIF objects from a XML instance.
INTERNAL: The Ontopia JSPTreeNode class.
INTERNAL: This class is used to hide the differences between the
JSP 1.1 and JSP 1.2 APIs so that the OKS can support both.
INTERNAL: A class that executes a jsp page from a given root node.
INTERNAL: Class that reads a jsp file and builds a JSPTree from it.
INTERNAL: An interface for a custom JSP tag generating factory.
INTERNAL: Tree node representing a JSP tag.
INTERNAL: Interface for classes which implement the Ontopia
JSPTreeNodeIF.
INTERNAL: An encoding sniffer for JTM.
INTERNAL: Exception used to indicate errors while importing JTM topic maps.
PUBLIC: This TopicMapReader can read topic maps in JTM 1.0 notation.
PUBLIC: Exports topic maps to the JTM 1.0 interchange format.
INTERNAL:
PUBLIC: Utilities for generating keys from complex topic map
objects.
INTERNAL: Interface for generating new object identities.
INTERNAL: Object representing a particular language.
INTERNAL: OKS->TMAPI object wrapper.
INTERNAL: Implements the '<=' predicate.
INTERNAL: Implements the 'lteq' predicate.
INTERNAL: Implements the '<' predicate.
INTERNAL: Implements the 'lt' predicate.
INTERNAL: Comparator that performs a lexical comparison.
INTERNAL: interface for classes which
implement generating URI links.
INTERNAL: Output Producing Tag for writing out the
URI of an object.
Implementation of the
LiteralIndex
INTERNAL: OKS->TMAPI 2 object wrapper.INTERNAL: Represents the local context in which a tolog query or
rule file is being parsed.
PUBLIC: Locators that refer to resources.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: This class keeps an interning table of LocatorIF objects,
allowing implementations to get rid of duplicate locators to save
memory.
INTERNAL: Non-shared locator lookup index.
INTERNAL: Output Producing Tag for writing out the URI of the
resource that is an occurrence, a variant name, or a locator.
INTERNAL: Value producing and value accepting tag of retrieving the
locators of OccurrenceIF and VariantNameIF instances.
INTERNAL: Class used for representing data store object identities
with only a single long key.
INTERNAL: Value Producing Tag for looking up objects by their
subject address,
subject indicator,
source locator,
or object id.
INTERNAL: An encoding sniffer for LTM.
INTERNAL: Lexer for LTM syntax.
INTERNAL: Parser for the LTM syntax.
INTERNAL: Source that locates LTM topic map files in a directory on
the file system.
PUBLIC: Imports an LTM fragment with references to parameter values
specified externally.
PUBLIC: This TopicMapReader can read topic maps from LTM files.
INTERNAL: An LTM file topic map reference.
PUBLIC: Exports topic maps to the LTM 1.3 interchange format.
INTERNAL: DocumentIF wrapper for Lucene's own internal document class.
INTERNAL: FieldIF wrapper for Lucene's own internal field class.
FulltextImplementationIF implementation that is based on Lucene indexing.
INTERNAL: The Lucene indexer implementation.
INTERNAL: Lucene search result wrapper implementation.
INTERNAL: Virtual column that used a hash table to map from old
value to new value.
INTERNAL: Framework related tag for logging information about
memory and CPU time usage to log channel.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: This component can produce a model representing a menu
structure.
Parses menu configuration files.
Class for representing a menu item for our application.
INTERNAL: Helper methods for Menu.
PUBLIC: Merges two topic map documents.
INTERNAL: A topic map reference that uses a TopicMapRepositoryIF to
retrieve a list of topic maps and create a new merged topic map
from them.
INTERNAL: Represents a parsed MERGE statement.
PUBLIC: Utilities for merging topics and topic maps.
INTERNAL.
Bean that is set to every node of tree as user object.
PUBLIC: An interface representing a model.
INTERNAL: An interface representing a model.
INTERNAL: class which implements interface LinkGeneratorIF.
INTERNAL: Represents an UPDATE or DELETE statement, since these are
the ones that can have functions.
INTERNAL: Common abstract superclass for all tolog updates
statements (INSERT, DELETE, MERGE, UPDATE).
INTERNAL: Framework related tag for modifying (means right now:
adding and removing) an object at the user object which is bound to
the session scope.
INTERNAL: ModuleIF implementation that reads functions from an XML
resource.
INTERNAL: A content handler for module specification files (root
element "module" which consists of an arbitrary number of
"function" elements.
INTERNAL: Implemented by an object which represents a module.
INTERNAL: Represents a tolog module.
INTERNAL: Default implementation of the interface ModuleReaderIF
INTERNAL: Class that reads a module from an input stream and builds
for each function a JSPTree from it.
Stops the motion of the nodes in Vizigator at certain intervals.
INTERNAL: Expected input is an array of maps with arbitrary keys and values of Object[] type.
INTERNAL: A carrier class which provides configuration information
about the Model-/View/Skin-Settings used by the web-application.
INTERNAL: MySQL SQL statement generator.
INTERNAL: Class that generates DDL statements for the mysql
database platform.
INTERNAL: A Comparator for ordering TopicNameIFs and VariantNameIFs
alphabetically (case-independent).
INTERNAL: A Comparator for ordering TopicNameIFs and VariantNameIFs
first after their generality (determined by the number of themes in
their scopes, which means that the name in the unconstrained scope
would always appear first) and second alphabetically
(case-independent).
Represents a name field.
INTERNAL: Grabber that grabs the most suitable name from a topic,
measured by whether it contains a particular theme in its scope.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: The basic dynamic name index implementation.
INTERNAL: The rdbms name index implementation.
Helper class to index the
TopicNameIF to there Name wrapper.PUBLIC: Index that holds information about the names of topics in
the topic map.
INTERNAL: The implementation of the 'name(topic, name-string)' predicate.
INTERNAL: The implementation of the 'name(topic, name-string)' predicate.
INTERNAL: Value Producing Tag for finding all the base names
of all the topics in a collection.
INTERNAL: Stringifier that stringifies TopicNameIFs and VariantNameIFs
by calling their getValue() method.
INTERNAL: Output Producing Tag for selecting the name of an object
and writing it out.
INTERNAL: Value Producing Tag for finding the most appropiate name
for each of all the topics in a collection.
Represents a name type.
INTERNAL.
INTERNAL: Basic Implementation of interface NavigatorApplicationIF to
store all handles to application-wide configuration holders needed
by the navigator framework.
INTERNAL: Implemented by an object which stores all information and
also all handles to configuration holders needed by the
navigator web application.
INTERNAL: Exception for a problem occurring when
using the Navigator Tag Library.
INTERNAL: Provide easy access for reading in an action
configuration file and generating an action registry object from
it.
INTERNAL: A configuration holder class for storing
and providing information about the application
configuration.
INTERNAL: A Content Handler for reading in an application
configuration file (default name:
application.xml,
default location: WEB-INF/config).INTERNAL: Implemented by an object which stores configuration
information needed by the navigator.
INTERNAL: interface for classes which
implement some calculation on an object
an come to a binary decision.
INTERNAL: Interface which should be implemented by root-ish tags
handling the outermost lexical scope in which all further
computation happens.
INTERNAL: Exception for a problem occurring when using the Navigator
Tag Library.
INTERNAL: NavigatorSetupServlet initializes and finalizes
the management of the topicmaps available to the web-application.
INTERNAL: base class for a generic problem occurring when
using the Navigator Tag Library.
INTERNAL: Exception for a problem occurring when
using the Navigator Tag Library.
INTERNAL: A utility class with miscellaneous helper methods used by
the navigator tag-libraries and the framework.
INTERNAL: Stringifier that stringifies occurrences to their internal
string value and all other objects using obj.toString().
PUBLIC: An implementation of ExternalReferenceHandlerIF that
prevents the traversal of external topic references.
Finds all Topics with:
- No names
INTERNAL: This exception is thrown when the navigator framework is
passed a topic map object ID that does not belong to any actual
topic map object.
INTERNAL:
INTERNAL: Used to represent not clauses in tolog queries.
INTERNAL: Implements the '/=' predicate.
INTERNAL: Implements the '/=' predicate.
PUBLIC: Thrown when an object is attempted removed, but cannot.
PUBLIC: An implementation of ExternalReferenceHandlerIF that
prevents the traversal of external references by returning null
from all methods.
INTERNAL: A object access implementation for manipulation of
identifiable objects.
INTERNAL: Comparator that compares object ids of TMObjectIF objects.
INTERNAL: Implements the 'object(thing, id)' predicate.
INTERNAL: Implements the object-id predicate.
INTERNAL: Output Producing Tag for selecting the ID
of an object and writing it out.
INTERNAL: Output Producing Tag for selecting the ID
of an object and writing it out.
INTERNAL: The generic object relational mapping definition class.
INTERNAL: An object relational mapping wrapper class used by the
RDBMS proxy implementation.
PUBLIC: Thrown when a deleted topic map object is attempted
reassigned to a property in a topic map.
INTERNAL: A data structure that keeps track of the objects that has
been touched within the transaction boundaries.
INTERNAL: Collection of toString implementations for the various
topic map object implementations.
INTERNAL: Event manager that fires object added and removed
events for children of added or removed objects.
INTERNAL: Class that contains useful methods.
INTERNAL: The basic occurrence implementation.
INTERNAL: The rdbms occurrence implementation.
INTERNAL: A Comparator for ordering OccurrenceIFs alphabetically.
Represents an occurrence field.
PUBLIC: Implemented by objects representing occurrences in the
topic map model.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: The basic dynamic locator index implementation.
INTERNAL: The rdbms occurrence index implementation.
INTERNAL: Index that holds information about occurrences in the
topic map.
INTERNAL: Implements the 'occurrence' predicate.
INTERNAL: Implements the 'occurrence($topic, $occurrence)' predicate.
Provides a rest point for
TopicIF.getOccurrences(),
TopicIF.getOccurrencesByType(TopicIF) and
ClassInstanceIndexIF.getOccurrences(TopicIF).INTERNAL: Value Producing Tag for finding all the occurrences
of all the topics in a collection.
Represents an occurrence type.
INTERNAL:
INTERNAL: Class for representing information about a the Ontopia
product and a method for testing if the product is correctly
installed.
OntopiaErrorHandler implements the SAX
ErrorHandler interface and defines callback
behavior for the SAX callbacks associated with an XML
document's errors.PUBLIC: An exception class that can be used to wrap other
exceptions with.
PUBLIC: A runtime exception class that can be used to wrap other
exceptions with.
INTERNAL: Thrown to indicate that the requested operation is not
supported.
Default access strategy implementation used by OntopolyApplication.
The set of Privileges that a user can have.
INTERNAL: Utility class for getting hold of the current threads
repository and topic map.
INTERNAL: Represents the system topic map describing all the topic
maps in the Ontopoly topic maps repository.
INTERNAL: A format module for the OOXML PresentationML format.
INTERNAL: A format module for the OOXML WordProcessingML format.
INTERNAL: A General Configuration frame for the VizDesktop.
INTERNAL: Oracle SQL statement generator.
INTERNAL: Class that generates DDL statements for the oracle
database platform.
INTERNAL: Used to represent or clauses in tolog queries.
INTERNAL: Description: OSpinner is introduced to replace JSpinner so that we
could compile under JRE_1.3
INTERNAL: Like a WhenTag with no condition.
INTERNAL: Implemented by a tag which produces
output from an input collection somehow.
INTERNAL: Tolog Tag for outputting content.
INTERNAL: Data carrier class used to pass data between tags.
INTERNAL: Used to represent a : b pairs in tolog queries.
INTERNAL: Used to represent parameter references in tolog queries.
INTERNAL: Object wrapper class for query parameter array.
INTERNAL: Parameter processor makes sure that query parameters gets
properly bound to statements.
INTERNAL: Represents an interpretation context for tolog queries.
PUBLIC: Represents a parsed modification statement, such as DELETE,
INSERT, UPDATE, and QUERY.
INTERNAL: Class used to represent parsed queries.
INTERNAL: Class used to represent parsed queries.
PUBLIC: Used to represent parsed queries.
INTERNAL: Represents a parsed rule.
PUBLIC: Common super-interface for parsed tolog statements of all
kinds.
INTERNAL: Interface implemented by event handlers which build the
actual topic map, based on events received by the parser.
INTERNAL: Represents a stored parse event, ready to be replayed.
INTERNAL: Carrier for variables used during parsing to keep track
of context such as current topic, current topic name, current
statement (scoped/reifiable) etc.
INTERNAL:
INTERNAL: Thrown when persistence related problems occur.
INTERNAL: Thrown when persistence related problems occur.
INTERNAL: Interface implemented by all data objects used by the
proxy framework.
INTERNAL: Iterator that iterates over an iterator of IdentityIF
values and looks up the objects in the transaction.
INTERNAL: Object access for objects implementing the PersistentIF
interface.
INTERNAL: Thrown when a phantom object is being accessed in a way
that is not allowed.
INTERNAL: Class that represents the association object which a
deleted role might have belonged to.
INTERNAL:
INTERNAL: Compares two objects which are classes that implement the
PluginIF interface.
INTERNAL.
INTERNAL: A Content Handler for reading in a Plug-in Configuration
file (plugin.xml) which contains detailed information about one (or
more) Plug-in(s).
INTERNAL: The common interface for all navigator plugin objects.
INTERNAL: Framework related tag for listing all activated plugins
available in the navigator configuration.
INTERNAL: Framework related tag for listing all activated plugins available
in the navigator configuration.
INTERNAL: Helper class for providing convenience methods to access
plugin and plugin group members.
INTERNAL: Servlet that returns a PNG image.
INTERNAL: PostgreSQL SQL statement generator.
INTERNAL: DDL statement generator for the PostgreSQL database
platform.
INTERNAL:
INTERNAL: Used to represent clauses in tolog queries.
INTERNAL: The basic predicate factory implementation.
INTERNAL: The rdbms predicate factory implementation.
INTERNAL: Implemented by classes which can create PredicateIF objects.
INTERNAL: Represents a predicate.
INTERNAL: Used as a special, "magic", argument to predicates,
inserted by the query optimizer to tell them to behave differently.
INTERNAL: Shared utilities for the predicate implementations.
INTERNAL: Prefetching utility
INTERNAL: Represents a prefix declaration.
INTERNAL: SAX document handler that writes pretty-printed XML to a
Writer.
INTERNAL: A field that references a primitive value class.
Manages probability values for given keys, so that all probability values
always add up to 1.
INTERNAL: Class that performs the actual db2tm processing.
EXPERIMENTAL: Base predicate that provides a simple interface for
implementing predicates.
INTERNAL: Class that holds a database schema definition.
INTERNAL:
PRIVATE:
Description: A properties frame for topics
INTERNAL: PRIVATE: Description: A properties dialog for topics
INTERNAL: Output-Producing Tag which retrieves the value of a given
property from the application configuration file and writes it out.
INTERNAL: Utility class for handling properties and their values.
INTERNAL: This class collects core PSIs in a single place as a
convenience for topic map developers.
INTERNAL: Labels a string on a JSP content (model) page which can be
used by GetTag for use on a template (view) page.
INTERNAL: Used to represent qualified name references in tolog queries.
PUBLIC: A utility class for producing full URIs from QNames.
PUBLIC: A utility class for producing full URIs from QNames.
INTERNAL: Analyzes the types of variables in the query.
INTERNAL: Class used to hold context information when building JDO
queries from tolog queries.
INTERNAL: A storage access implementation accessing relational
databases using JDBC.
INTERNAL: Immutable Collection implementation that delegates its
data retrieval to QueryIFs.
INTERNAL: Represents a tolog query component.
INTERNAL: Object used to hold the global query execution context;
that is, the context beginning with the start of the execution of a
query and ending with the completion of its execution.
INTERNAL: Used during traversal of queries to represent the context
at any given point in the query.
INTERNAL: Class that is able to read named query definitions from an XML representation.
INTERNAL: Class used for loading and managing SQL query
declarations.
PUBLIC: Common super-exception for all exceptions thrown by the
query engine.
INTERNAL: This interface is implemented by QueryProcessorIFs.
INTERNAL: Generic Tolog Tag that has support for executing one query.
Represents a query field.
INTERNAL: Interface for representing queries.
INTERNAL: Non-shared locator lookup index.
INTERNAL: Object used to hold query results during computation.
INTERNAL: A set implementation that wraps an QueryMatches instance
and presents the values in one of the columns as a collection.
INTERNAL: Various utility methods for working with QueryMatches
objects.
INTERNAL: An optimizer class that knows how to rewrite queries to
equivalent, but more efficient queries.
INTERNAL:
Replaces simple recursive rules with a more efficient custom
implementation that just wraps the recursive step.
INTERNAL: Optimizes queries that look for the next or the
previous value in a sequence from a given start value to not load
all values and then do it the hard way, but instead to use a
sorted index.
This optimizer adds RemoveDuplicatesPredicate on both sides of
recursive calls within predicate rules.
INTERNAL: Optimizes the query by reordering the clauses into the
optimal order for evaluation.
INTERNAL: Optimizes the query by inlining all rules which are simple
aliases for a single predicate.
INTERNAL: Optimizes queries that do lookup of occurrences by
string value, then filter the string value by a prefix.
Finds cases of conflicting variables and resolves them by
replacing predicates which can never succeed with
DynamicFailurePredicate.
INTERNAL: Implemented by classes that know how to optimize tolog queries.
INTERNAL: This query processor implementation can be used to query any topic
map implementation; it makes no assumptions about the stored form of the
topic map.
INTERNAL: This is the front-end to the RDBMS-specific query
processor.
PUBLIC: Interface for query language implementations.
PUBLIC: This is the interface that must be implemented by tolog
query processors.
INTERNAL: Statistics collector for profiling queries, whether tolog
or SQL.
INTERNAL: The query result representation used by the basic implementation.
INTERNAL: The query result representation used by the basic implementation.
INTERNAL: Interface for representing two-dimensional (or
potentially even N-dimensional) query results.
PUBLIC: Used to represent the results of queries.
INTERNAL: Interator wrapper class for QueryResultIFs.
INTERNAL: Iterator that iterates over a QueryResultIF and returns a
new immutable Map instance for each query result row.
INTERNAL: Collection of QueryResult wrapper classes.
INTERNAL.
INTERNAL: Used for testing and timing of queries.
INTERNAL: Used for testing and timing of queries.
PUBLIC: Utility methods for getting QueryProcessorIFs for a topic
map.
INTERNAL: Generic Tolog Tag that has support for executing one query.
EXPERIMENTAL: Class a la Spring's JDBC templates to simplify use of
the tolog query engine API.
INTERNAL: Utility for randomly populating topic maps.
EXPERIMENTAL: Implements the TMRAP protocol.
INTERNAL: A storage access implementation accessing relational
databases using JDBC.
INTERNAL: RDBMS query implementation that performs queries that
return a collection of object instances, ie. an instance of
java.util.Collection.
EXPERIMENTAL: A tool that generates a report of the database
metadata as reported by the JDBC driver
PUBLIC: Checks an RDBMS database holding topic map data for referential
integrity and for uniqueness of source-locators, subject-indicators
and subject-locators.
PUBLIC: Command line utility for deleting topic maps in a
relational database system.
INTERNAL: RDBMS DocumentIF class implementation.
PUBLIC: Command line utility for exporting topic maps from a
relational database system to files.
INTERNAL: RDBMS FieldIF class implementation.
PUBLIC: Command line utility for importing topic map files into a
relational database system.
INTERNAL: An abstract super class used by the rdbms indexes.
EXPERIMENTAL: A tool that inspects a database to see if the proper
indexes has been created.
INTERNAL: An abstract locator implementation used for representing
locators within the rdbms implementation.
INTERNAL: An object relational mapping wrapper class used by the
RDBMS proxy implementation.
INTERNAL: RDBMS query implementation that performs queries that
return a map of key-value pairs, ie. an instance of java.util.Map.
INTERNAL: RDBMS query implementation that performs queries that
return an instance of QueryResultIF.
PUBLIC: Provides metrics regarding RDBMS proxy connections.
INTERNAL: RDBMS query implementation that performs queries that
return a single object instance.
PUBLIC: A topic map source that refers to single reference that is
located by pattern.
INTERNAL:
INTERNAL: QueryResultIF implementation that wraps a ResultSet.
INTERNAL: A generic RDBMS fulltext searcher implementation.
EXPERIMENTAL: RDBMS searcher implementation that executes a SQL
query in the same database as the topic map is stored in.
INTERNAL: RDBMS search result implementation.
PUBLIC: A topic map source that holds a reference to a single rdbms
topic map.
PUBLIC: Command line utility for generating statistics about the topic map
INTERNAL: A storage definition implementation for relational
databases.
PUBLIC: The RDBMS TopicMapStoreFactoryIF implementation.
INTERNAL: Topic map reader that reads topic maps from the RDBMS
backend connector.
INTERNAL: RDBMS database topic map reference.
PUBLIC: A topic map source that holds the list of all topic
map references accessible by a rdbms session.
PUBLIC: The rdbms topic map store implementation.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: The rdbms topic map transaction implementation.
INTERNAL: Simple implementation of the RDF2TM plug-in.
PUBLIC: An RDF fragment exporter which produces RDF/XML.
ImportExportServiceIF service providing RDF import and export functionality.
INTERNAL: Used by the RDF2TM plugin.
PUBLIC: Thrown when an error occurs during RDF-to-topic maps
conversion.
INTERNAL: Source that locates RDF files in a directory on the file
system.
INTERNAL: Represents the mapping of a single RDF property.
PUBLIC: Converts an RDF model to a topic map using a
schema-specific mapping defined using RDF.
INTERNAL: An RDF file topic map reference.
PUBLIC: A topic map writer that can convert topic maps to RDF.
EXPERIMENTAL: Converts an RDF model to a topic map using a
schema-specific mapping defined using RDF.
INTERNAL: Various utilities for working with RDF.
This artifact has no sources.
This artifact has no sources.
This artifact has no sources.
This artifact has no sources.
This artifact has no sources.
This artifact has no sources.
This artifact has no sources.
INTERNAL: The read-only rdbms association implementation.
INTERNAL: The read-only rdbms association role implementation.
PUBLIC: Thrown when changes are attempted made on read-only objects.
INTERNAL: The read-only rdbms occurrence implementation.
INTERNAL: A set implementation that track the changes performed on
it.
INTERNAL:
INTERNAL: The read-only rdbms topic implementation.
INTERNAL: The read-only rdbms topic map implementation.
INTERNAL: The read-only rdbms topic name implementation.
INTERNAL: Thrown when modifications are attempted on a read-only
transaction.
INTERNAL: The read-only rdbms variant name implementation.
INTERNAL: Parser for the tolog query language.
INTERNAL: SQL optimizer that removes table- and column references
that are redundant.
INTERNAL: A field that references objects.
INTERNAL: An exception that is thrown when a topic map reference is
accessed after the reference has been close.
INTERNAL: A term analyzer which recognizes certain kinds of terms
using regexps and adjusts their scores accordingly.
INTERNAL:
INTERNAL:
EXPERIMENTAL: An implementation that looks up topics in all currently open
topic maps in the given registry.
PUBLIC: Implemented by topic map objects that can be
reified.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: Finds the topic map objects which are reified by topics in
the input collection.
INTERNAL: Finds the reifying topic of each topic map object in a
collection.
INTERNAL: Implements the 'reifies(reifier, reified)' predicate.
INTERNAL: Implements the 'reifies(reifier, reified)' predicate.
PUBLIC: This component can produce a model representing the
associations of a given topic.
INTERNAL: Relation mapping concept that represents a relation
definition.
INTERNAL: DB2TM relation mapping definition.
INTERNAL:
INTERNAL: Plugin implementation for a Reload Link resp.
INTERNAL: The remote topic implementation.
EXPERIMENTAL: An implementation that looks up topics on remote
servers using the TM RAP protocol.
INTERNAL: The remote (remote in the sense that it deals with remote topics -
and not that the transactions work in a remote or distributed
fashion) implementation of a topicMapBuilder.
INTERNAL: The remote (remote in the sense that it deals with remote
topics - and not that the transactions work in a remote or
distributed fashion) extension of AbstractTopicMapStore.
INTERNAL: The remote (remote in the sense that it deals with remote topics -
and not that the transactions work in a remote or distributed
fashion) implementation of TopicMapTransaction.
INTERNAL: Implements the 'remove-duplicates()' predicate.
INTERNAL: A utility class that analyzes a file content store
directory and repairs the key file.
INTERNAL: Servlet filter that creates a new topic map store for
each request.
INTERNAL: Implements the 'resource' predicate.
INTERNAL: Implements the 'resource' predicate.
This is a helper class that is used to reference wicket resources through.
INTERNAL: TopicMapSourceIF that can reference individual topic map documents
that contained in the classpath and can be loaded by a ClassLoader.
INTERNAL: Framework related tag used for setting response headers.
EXPERIMENTAL: Interface used by process predicates to add new
result rows.
Represents a role field.
Interface.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: Implements the 'role-player' predicate.
INTERNAL: Implements the 'role-player(role, player)' predicate.
INTERNAL: Value Producing Tag for finding all the association
roles of all the topics and associations in a collection.
Represents a role type.
INTERNAL:
INTERNAL:
INTERNAL: A transactional read-only storage cache
implementation.
INTERNAL: The read-only proxy transaction implementation.
EXPERIMENTAL: Interface to be implemented by row mappers used by
the queryForList method on QueryWrapper.
INTERNAL: Implements rule predicates.
INTERNAL: Implements rule predicates.
INTERNAL: A transactional storage cache implementation.
INTERNAL: The read-write proxy transaction implementation.
PUBLIC: A store factory that always returns the store given to it
via its constructor.
PUBLIC: Checks a topic map for dubious constructs.
INTERNAL: A helper base class for SAX applications that makes it
much easier to write SAX applications, since it helps applications
keep track of the element stack and preserve the contents of
various elements.
INTERNAL: Filters out Ontopoly constructs from topic maps.
INTERNAL: Filters out instances from the topic map so that only the
Ontopoly meta-ontology and the ontology remain.
INTERNAL: Utility class that tracks ontological information.
PUBLIC: Implemented by topic map objects that have scope.
INTERNAL: Comparator that compares ScopedIF objects based on their
applicability in the specified scope.
INTERNAL: OKS->TMAPI 2 object wrapper.
This is the implementation for the TMAPI2
ScopedIndex interface.INTERNAL: The basic dynamic scope index implementation.
INTERNAL: The rdbms scope index implementation.
PUBLIC: Implemented by objects holding information about topics
used as themes in scopes, and about topic map objects that have
scope.
INTERNAL: Implements the 'scope(scoped, theme)' predicate.
INTERNAL: Implements the 'scope(scoped, theme)' predicate.
INTERNAL: Interface which defines basic properties (like constants)
needed by classes that implement scope access.
INTERNAL: Value Producing Tag for finding all themes
in the scope of all the objects in a collection.
INTERNAL: Framework related utility class providing some helper
methods needed to easier for access to scope information.
INTERNAL: Scope processing utilities.
INTERNAL: Represents a search engine.
PUBLIC: Simple searcher interface that one can implement and
refer to by name through a java module import declaration.
INTERNAL: A search result containing a list of ranked hits.
PUBLIC: Search result interfaced used by implementations of the
SearcherIF interface.
INTERNAL: Experimental data integration search servlet.
INTERNAL: Tag which gathers all the values it receives into a
sequence.
Utility to load dynamic services from classpath.
INTERNAL: ...
INTERNAL: Logic Tag for establishing the outermost
lexical scope in which computation happens.
INTERNAL: Tolog Tag for executing a query,
iterating over each object in a result collection and
creating new content for each iteration.
INTERNAL: A shared storage cache implementation.
INTERNAL: Non-shared locator lookup index.
INTERNAL: Non-shared locator lookup index.
INTERNAL: Registry of topicmap repositories that are to be shared
between web applications.
PUBLIC: This component can produce a list of topics similar to the
input topic by finding other topics with similar associations as
the input topic.
PUBLIC: A simple top-level API for classifying content.
INTERNAL:
Description: a simple file filter
INTERNAL: Used to get a trace from a specific query into a writer
for ease of display.
INTERNAL: Iterator that iterates over a QueryResultIF and returns
an immutable Map instance for each query result row.
PUBLIC: An interface representing a skin.
INTERNAL: An interface representing a skin.
INTERNAL: SAX2 error handler implementation that uses slf4j to log
warnings, errors and fatal errors.
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL: A locator class used for representing topic map object
source locators.
INTERNAL: Value Producing Tag for finding all the source locators
(as LocatorIF objects) of all the topic map objects in a collection.
INTERNAL:
INTERNAL: Tag used to indicate where a nested template is to be split.
INTERNAL: Value Producing Tag for creating a collection of strings
(which are representing the first character of a TopicNameIF object)
of all the objects in a collection of TopicNameIF objects.
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL.
INTERNAL: Represents an aggregate function in a SQL query.
INTERNAL: Represents an aggregate function in a SQL query.
INTERNAL: Represents a set of columns from a given table.
INTERNAL: SQL logical expression: and
INTERNAL: Class that performs the task of accessing and
manipulating M:M reference fields in the database.
INTERNAL: Class that performs the task of creating new objects in
the database.
INTERNAL: Class that performs the task of accessing and
manipulating 1:M aggregate fields in the database.
INTERNAL: Class that performs the task of accessing and
manipulating 1:M reference fields in the database.
INTERNAL: Class that performs the task of accessing and
manipulating 1:1 fields in the database.
INTERNAL: Class used to build SQL queries from JDO queries.
INTERNAL: Class that performs the task of accessing and
manipulating "collection" type instances in the database.
INTERNAL: Represents a set of columns from a given table.
INTERNAL: SQL condition: equals (=)
INTERNAL: Command line tool for executing SQL statements in a
database referenced by a database properties file.
INTERNAL: SQL condition: exists.
INTERNAL: Represents an expression in a SQL query.
INTERNAL: SQL condition: expression that always evaluates to false
INTERNAL: SQL condition: any function; fn(arg1, ... argN)
INTERNAL: Utility class that can generate SQL statements.
INTERNAL: Interface for generating SQL statements.
INTERNAL: SQL condition: in.
INTERNAL: SQL condition: is null
INTERNAL: SQL expression: join.
INTERNAL: SQL condition: like
INTERNAL: Class that performs the task of accessing and
manipulating M:M reference fields in the database.
INTERNAL: SQL logical expression: not
INTERNAL: SQL condition: not equals (!
INTERNAL: SQL value: null.
INTERNAL: Class that performs the task of accessing and
manipulating "identifiable object type" instances in the database.
INTERNAL: Class that performs the task of accessing and
manipulating 1:M aggregate fields in the database.
INTERNAL: Class that performs the task of accessing and
manipulating 1:M reference fields in the database.
INTERNAL: Class that performs the task of accessing and
manipulating 1:1 fields in the database.
INTERNAL: SQL logical expression: or
INTERNAL: SQL order by statement.
INTERNAL: SQL value: parameter.
INTERNAL: SQL value: primitive.
INTERNAL: Represents an abstract SQL query.
INTERNAL: Reader that knows its length.
INTERNAL: Microsoft SQL Server SQL statement generator.
INTERNAL: Class that generates DDL statements for the sqlserver
database platform.
INTERNAL: SQL set operation.
INTERNAL: The default SQL statement implementation.
INTERNAL: Represents a concrete SQL query.
INTERNAL: Represents a reference to a table in a relation
database.
INTERNAL: SQL value: tuple.
INTERNAL: Utility class for handling access to columns by proper
SQL type.
INTERNAL: SQL condition: equals (=)
INTERNAL: Represents a SQL value.
INTERNAL: A reference to another SQLValueIF.
INTERNAL: Represents a verbatim SQL expression value.
INTERNAL: Represents a verbatim SQL expression.
INTERNAL: A transactional storage cache implementation.
INTERNAL: The basic implementation of the statistics index.
INTERNAL: The RDBMS implementation of the statistics index.
PUBLIC: Interface implemented by objects providing quick lookup
facilities to find topics used as types, and the instances of those
types, within a topic map.
PUBLIC: Prints various kinds of statistics for topic maps.
INTERNAL: An internal utility class that generates statistics based on
the data that exists in the topic map.
INTERNAL: A set of words considered "stop words" in a particular
language.
INTERNAL: Interface that encapsulates the access to the actual data
repository.
INTERNAL: Interface used by the transaction to get hold of objects
and object field values.
INTERNAL: Interface for accessing storage definitions.
PUBLIC: An exception that is thrown when a store has been
deleted.
INTERNAL: A topic map reference that uses a topic map store factory
to create stores.
PUBLIC: An exception that is thrown when parts of a store is
accessed without the store being open.
INTERNAL: A commons-pool PoolableObjectFactory that uses a
TopicMapStoreFactoryIF to create TopicMapStoreIF objects.
INTERNAL: Utilities for working with streams and readers.
INTERNAL: Utility class to provide easy access to a stringified
representation of given topic map objects using the page context to
make use of the user defined scope.
INTERNAL: Value Producing Tag for generating a string value.
INTERNAL: Utilities for processing string templates containing
%param% references.
INTERNAL: Class that contains useful string operation methods.
INTERNAL: Value Producing Tag for finding all the subclasses
of the topics in a collection.
INTERNAL: Value Producing Tag for finding the subject address (as
LocatorIF objects) of all the topics in a collection.
INTERNAL: Implements the 'subject-identifier(topic, locator)' predicate.
INTERNAL: Implements the 'subject-identifier(topic,locator)' predicate.
INTERNAL: Class that maintains indexes for use with the TopicMapIF
locator lookup methods.
INTERNAL:
INTERNAL: Decider that decides whether the object is an instance of a
topic with the given subject identifier.
INTERNAL:
INTERNAL:
INTERNAL: Implements the 'subject-locator(topic, locator)' predicate.
INTERNAL: Implements the 'subject-locator(topic,locator)' predicate.
INTERNAL: Decider that decides whether the ScopedIF's scope is a
subset of the user context or not.
INTERNAL: Value Producing Tag for finding all the superclasses
of the topics in a collection.
INTERNAL: Decider that decides whether the ScopedIF's scope is a
superset of the user context or not.
This is the 3rd version of SwingWorker (also known as SwingWorker 3), an
abstract class that you subclass to perform GUI-related work in a dedicated
thread.
INTERNAL: Outputs a stable identifier to the object if possible,
if not outputs the object ID.
INTERNAL: Outputs a stable identifier to the object if possible,
if not outputs the object ID.
PUBLIC: Servlet that sets up and schedules DB2TM synchronization
at regular intervals.
INTERNAL: TimerTask that runs DB2TM synchronization.
INTERNAL: A collection factory that returns synchronized standard
java.util collection objects.
INTERNAL: Extends CompactHashSet to make it synchronized.
INTERNAL: Represents the definition of a relational database table.
INTERNAL: A TaglibTagFactory that creates the correct tags from the
net.ontopia.nav2.taglibs packages.INTERNAL: Represents a CTM template.
INTERNAL: An event handler which produces a template object,
containing recorded events ready to be replayed when the template
is invoked.
PUBLIC: Represents a concept which occurs in the classified
content.
INTERNAL:
PUBLIC: A collection of terms representing the result of
classifying a piece of content.
INTERNAL:
INTERNAL: A stemmer produces the stem of a word from a form of the
word.
INTERNAL:
INTERNAL: Callback interface used by format modules to tell the
classification framework about the structure of classifiable
content.
INTERNAL: Plugin that returns the a text snippet.
INTERNAL: Class for categorizing a collection of themes according to
their theme class.
INTERNAL: Value Producing Tag for finding all topics that are used as
themes in scopes, either in general, or of a specific kind of
topic map object.
INTERNAL: Servlet filter that creates a new topic map store for
each request thread.
INTERNAL: A simple ticket interface.
INTERNAL: Framework related tag for logging information about
CPU time usage to log4j.
INTERNAL: Common abstract superclass for all edges representing
Topic Maps constructs.
INTERNAL: Common abstract superclass for all nodes representing
Topic Maps constructs.
INTERNAL: Edge class representing binary associations as edges.
INTERNAL: Node class representing n-ary associations as nodes.
INTERNAL: Edge class used to represent "Class - Instance"
associations.
INTERNAL: Accepts or rejects topic map constructs based on their
relations to other topic map constructs and a filter that makes
decisions on an individual basis.
INTERNAL: TMLoginModule provides authentication to web applications by
checking user credentials against information stored in a topicmap.
INTERNAL: The abstract basic topic map object implementation.
INTERNAL:
PUBLIC: The base topic map object interface that all topic map
objects implement.
PUBLIC: A component for including links to relevant pages from
other web sites via TMRAP.
INTERNAL: Used to hold the TMRAP configuration settings.
INTERNAL: Thrown to show that there was an error at the TMRAP level.
PRIVATE: A generic implementation of the TMRAP protocol,
independent of any particular way of invoking the services.
TMRAPServiceMessageReceiverInOut message receiver
TMRAPServiceSkeletonInterface java skeleton interface for the axisService
INTERNAL: Interface implemented by objects able to revitalize
themselves with another topic map transaction.
INTERNAL: Default implementation of the TMRevitalizerIF interface.
INTERNAL: Interface implemented by a class that is able to
revitalize objects.
INTERNAL: Edge class representing association roles as edges in
n-ary associations connecting role player with the association
node.
INTERNAL: Node class representing topics.
INTERNAL: Source that locates TM/XML files in a directory on the
file system.
PUBLIC: A reader importing topic maps (or fragments) from the
TM/XML syntax.
INTERNAL: A TM/XML file topic map reference.
PUBLIC: A writer exporting topic maps (or fragments) to the TM/XML
syntax.
INTERNAL: Index providing lookups from base name value + scope to
the topic that has such base name characteristics.
INTERNAL:
INTERNAL:
INTERNAL:
EXPERIMENTAL: This is a servlet filter that pushes a tolog context
onto the stack.
INTERNAL: Command-line that deletes topic map objects returned by
one or more tolog queries.
A tolog lexer, to be used with the Antlr-generated parser.
INTERNAL: Represents the properties set in a given tolog processing
context.
INTERNAL: The tolog query parser.
PUBLIC: Runs tolog queries against a given topic map.
INTERNAL: Used to represent parsed SELECT queries.
PUBLIC:
INTERNAL: TologQueryTag evalutes a tolog query and returns a
collection of maps.
INTERNAL:
PUBLIC: Query profiler for tolog.
INTERNAL: Common abstract superclass for all kinds of tolog
statements, including SELECT and the update statements.
INTERNAL: The basic topic implementation.
INTERNAL: The rdbms topic implementation.
INTERNAL: Common superclass for all topics, like instances, association
types, topic types, role types, etc.
Class used for locating associations and their types.
INTERNAL: A convenience class for creating grabbers that grab
specific topic characteristics, using various criteria, including
scope.
INTERNAL: A Comparator for ordering topics alphabetically.
INTERNAL: Stringifier that stringifies TopicNameIFs and VariantNameIFs.
INTERNAL: A collection of topic related comparators.
INTERNAL: Classifier plugin which produces content from the topic
itself.
Topic Map count methods
INTERNAL: Internal event listener class that handles topic events.
INTERNAL: Internal event listener class that handles topic events.
PUBLIC: This interface is implemented by objects representing
topics in the topic map model.
INTERNAL: OKS->TMAPI 2 object wrapper.
EXPERIMENTAL: An index through which information about topics with
a particular subject can be located, irrespective of where these
topics happen to be stored.
INTERNAL: The basic topic map implementation.
INTERNAL: The rdbms topic map implementation.
INTERNAL: Represents an Ontopoly topic map.
INTERNAL:
INTERNAL: The default topic map builder implementation.
INTERNAL: The default topic map builder implementation.
PUBLIC: A helper for building topic map object structures.
INTERNAL:
PUBLIC: Holds configuration information for topicmap configuration
PUBLIC: Converts topic maps into a given format.
INTERNAL: A class that extends GenericDocument to add an appropriate
toString implementation for topic map documents.
INTERNAL: A document generator interface that can be implemented to
generate DocumentIFs for topic map objects.
INTERNAL: SAX entity resolver that only follows doctype
declarations referencing the ISO 13250 and XTM 1.0 DTDs using
public ids if the references actually point to something that can
be accessed.
PUBLIC: Utility class for registering topic map life cycle
events.
PUBLIC: Implementations of this interface can export fragments of
topic maps to some Topic Maps syntax given a collection of topics
to include.
INTERNAL: Output Producing Tag for selecting the ID of the topicmap
the specified object belongs to and writing it out.
PUBLIC: Represents an entire topic map.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: A topic map event generator that iterates the objects in a
topic map and produces documents for an indexer.
INTERNAL: Plug-in that creates link to Omnigator topic map page.
PUBLIC: Event callback interface for topic map objects.
INTERNAL: Implements the 'topicmap' predicate.
INTERNAL: Implements the 'topicmap(topicmap)' predicate.
PUBLIC: A topic map reader is used to read topic maps from an
implementation specific, implicit source.
INTERNAL: Represents a topic map in the Ontopoly topic map
repository.
INTERNAL: A Comparator for ordering TopicMapReferences lexically.
PUBLIC: Represents a reference to a topic map.
INTERNAL: Value Producing Tag for generating a collection of
TopicMapReferenceIF objects containing information about topicmaps
available to this application.
PUBLIC: Class used to provide easy access to references from one or
more topic map sources.
PUBLIC: The primary access point to your topic maps.
INTERNAL: A List implementation that wraps a SearchResultIF to
present the actual topic map objects referenced in the search
result.
INTERNAL: Represents a source in the Ontopoly topic map repository.
PUBLIC: Topic map sources collect references to topic maps.
INTERNAL: This is the primary implementation of the
TopicMapRepositoryIF interface.
PUBLIC: Factory interface for creating new topic map store
objects.
PUBLIC: A topic map store is used to represent the connection
between one topic map and a repository where the data instantiating
that topic map is held (in an implementation-specific form).
PUBLIC: Implementation of the TMSync algorithm.
INTERNAL: OKS->TMAPI object wrapper.
EXPERIMENTAL: An implementation that looks up topics in all the given topic
map.
Deprecated.
All the useful methods have been moved to
TopicMapStoreIF and TopicMapIF.
INTERNAL: Maintains the TouchGraph view of the topic map.
PUBLIC: A topic map writer is used to write/export topic maps in an
implementation dependent way to an implicit destination.
INTERNAL: Event manager that fires TopicIF.modified events.
INTERNAL: The basic topic name implementation.
INTERNAL: The rdbms topic name implementation.
INTERNAL: A Comparator for ordering TopicNameIFs alphabetically
(case-independent).
INTERNAL: Comparator that first sorts by type then by scope,
where untyped base names are ordered before typed ones.
INTERNAL: Grabber that grabs the most appropriate basename from a topic.
PUBLIC: Implemented by an object which represents a topic name, which
is a topic characteristic.
INTERNAL: Implements the 'topic-name(topic, name)' predicate.
INTERNAL: Implements the 'topic-name' predicate.
EXPERIMENTAL: Represents a topic page (that is, the primary page
for a topic in a web interface to a topic map).
INTERNAL: Implements the 'topic(topic)' predicate.
INTERNAL: Implements the 'topic(topic)' predicate.
INTERNAL: Prompter for selecting a specific topic from a given list
INTERNAL: Value Producing Tag for finding all the topics of all the
topic map objects (allowed instances are TopicMapIF, TopicIF,
AssociationRoleIF, AssociationIF, TopicNameIF, VariantNameIF and
OccurrenceIF) in a collection.
PUBLIC: Creates stringifiers that extract strings representing
names from topics, according to various criteria, including scope.
EXPERIMENTAL.
INTERNAL: Represents a topic type.
INTERNAL: Grabber that grabs the most highest ranked variant name by
scope from a topic, ignoring the scope of the base names.
INTERNAL: Interface used by Collection implementations that track
the changes performed on them.
INTERNAL: A set implementation that track the changes performed on
it.
INTERNAL: A set implementation that track the changes performed on
it.
INTERNAL: Interface shared by the lookup indexes that look up data
in the backend storage.
INTERNAL:
INTERNAL:
INTERNAL: Interface for receiving notification when transaction
life-cycle events occur.
INTERNAL: Interface that manages object transactions using the
proxy framework.
INTERNAL: Thrown when persistence related problems occur.
PUBLIC: An exception that is thrown when a transaction is
accessed without the transaction being active.
INTERNAL: Command line utility for translating the source locators
in an imported topic map from their original base to the new base.
PUBLIC: This class can output a nice collapsing/expanding tree view
of a topic map which uses tolog queries to produce the tree.
INTERNAL: A tuple reader is an iterator-like interface for looping
through the tuples from a given relation.
PUBLIC: Implemented by topic map objects that are instances of a
single type, such as occurrences, associations, association roles,
and topic names.
INTERNAL: Comparator that grabs the type of the comparable objects
using TypedIF.getType() , and passes those two topics to it's
subcomparator.
INTERNAL: Grabber that grabs the type property of the TypedIF object
given to it.
INTERNAL: This class provides utility functions for traversing class
hierarchies which are expressed using the Published Subject
Indicators (PSIs) defined by the XTM 1.0 Specification.
Implementation of the
TypeInstanceIndex interface
INTERNAL: OKS->TMAPI 2 object wrapper.INTERNAL: Implements the 'type(typed, type)' predicate.
INTERNAL: Implements the 'type(typed, type)' predicate.
This class provides a display to allow the user to define which colours are
used when displaying associations of this type.
INTERNAL: A General Configuration frame for the VizDesktop
INTERNAL: Value Producing Tag for computing
the union of two collections.
PUBLIC: Thrown when a uniqueness constraint is violated.
INTERNAL:
INTERNAL: Represents an UPDATE statement.
UpdateTopicRequest bean class
Factory class that keeps the parse method
UpdateTopicResponse bean class
Factory class that keeps the parse method
INTERNAL.
PUBLIC: A Uniform Resource Identifier locator.
INTERNAL: Utilities for working with URIs.
INTERNAL: TopicMapSourceIF that can reference individual topic map
documents by their URL address.
INTERNAL: implementation of UserIF for holding data relevant to one
user session.
INTERNAL: Storage of four different sets of scoping
themes in dependance of a topicmap.
INTERNAL: interface for classes which implement user data management
usually stored in the session.
Interface for defining a method which filters out themes
which are not relevant to the user context.
INTERNAL: Helper class used by DB2TM internals.
INTERNAL: An internal utility class that contains various utility
operations on the topic map implementation from this package.
INTERNAL: SAX2 content handler used for validating XML documents
using Jing.
INTERNAL: Implemented by tags which accept values through some means
(for example from value producing and/or manipulating tags).
Simple generator storing values to be generated.
Common interface for generating both literal values and topics.
INTERNAL: Interface for extracting values from tuples.
INTERNAL: Implements the 'value-like' predicate.
INTERNAL: Implements the 'value-like' predicate.
INTERNAL: Implements the 'value' predicate.
INTERNAL: Implements the 'value-like' predicate.
INTERNAL: Implemented by tags whose functionality is such that they
process a single input collection to produce their output value.
INTERNAL: Virtual column that used a hash table to map from old
value to new value.
INTERNAL: Used to represent variable references in tolog queries.
INTERNAL: Exception for a problem occurring when using the Navigator
Tag Library.
PUBLIC: Represents a form of a term as it occurred in classified
content.
INTERNAL: OKS->TMAPI 2 object wrapper.
INTERNAL: The basic variant name implementation.
INTERNAL: The rdbms variant name implementation.
INTERNAL: Grabber that grabs the most highest ranked variant name by
scope from a basename.
PUBLIC: Implemented by objects representing variant names for
topics.
INTERNAL: Implements the 'variant(topicname, variantname)' predicate.
INTERNAL: Implements the 'variant' predicate.
INTERNAL: Value Producing Tag for finding all variant names related
to the objects in a collection (can be either objects of classes
TopicNameIF, TopicIF or TopicMapIF).
PUBLIC: An interface representing a view.
INTERNAL: An interface representing a view.
Indicator of whether a menu item has been checked, unchecked or
used default (the default being checked or unchecked).
INTERNAL: Abstract configuration manager class.
INTERNAL: The VizController manages the interaction between the
gui, model and configuration manager.
INTERNAL: The top-level class for the VizDesktop.
EXPERIMENTAL: Interface to abstract the Vizigator front ends, and
allow for future front end implementations without changes to the
base code (i.e. eclipse plugin) (VizDesktop and Vizlet).
PUBLIC: Description: Configuration Manager for General options
INTERNAL: Reports known error conditions, that can typically be corrected by
the user.
PUBLIC: Visualization applet.
EXPERIMENTAL: A panel in which topic map visualization can be shown.
INTERNAL: Simple extension of the DefaultPlugin used to block
vizigation of certain topic maps that don't vizigate well.
INTERNAL:
PRIVATE:
PRIVATE.
INTERNAL: Stores and manages configuration.
INTERNAL: Helper methods.
INTERNAL:
INTERNAL: Variant of IfTag, which sets a parent alerts a parent ChooseTag,
if it's body is evaluated.
PUBLIC: This component can render wiki formatting a la MediaWiki
into HTML.
INTERNAL: Decider that decides whether the scoped object is broader
than the context.
INTERNAL: A format module for the old binary Word format.
INTERNAL: Class used for wrapping other identities.
INTERNAL: SAX2 content handler used for importing XFML documents.
PUBLIC: A topic map reader that is capable of reading the XFML format
for faceted hierarchical metadata.
PUBLIC: Reads store configuration parameters from an XML
file.
INTERNAL:
PUBLIC: A topic map writer that can write topic maps out into the
interchange syntax defined by the 2010-03-02 draft of XTM 2.1,
as published at http://www.itscj.ipsj.or.jp/sc34/open/1378.htm
INTERNAL: Reads both XTM 2.0 and XTM 2.1.
INTERNAL: Exports topic maps to the XTM 2.0 or 2.1 interchange format.
PUBLIC: A topic map writer that can write topic maps out into the
interchange syntax defined by XTM 2.0.
INTERNAL: SAX2 content handler used for importing XTM 1.0 topic map
documents.
PUBLIC: Exports partial topic maps using an approach inspired
by the XTM Fragment Interchange 0.1 specification, but different.
EXPERIMENTAL: Handler class used for processing locators.
INTERNAL: Source that locates XTM topic map documents in a directory
on the file system.
INTERNAL: This content handler is used to detect whether the XTM
event stream being read is an XTM 1.0 or 2.x document.
INTERNAL: Exports topic maps to the XTM 1.0 interchange format.
PUBLIC: A fragment writer for XTM 1.0.
PUBLIC: A topic map reader that reads the XTM 1.0 interchange
syntax.
INTERNAL: An XTM document topic map reference.
PUBLIC: A topic map writer that can write topic maps out as either
XTM 1.0, 2.0 or 2.1.
INTERNAL: SAX2 content handler used for validating XTM documents
using Jing.
PUBLIC: A topic map validator that is capable of reading the
interchange syntax defined by XTM 1.0 (TopicMaps.org) or XTM 2.0.
PUBLIC: This class provides constants for XML Topic Maps (XTM) versions.
PUBLIC: This component can create a two-level view of the top of a
tree, similar to the old Yahoo directory taxonomy that's still used
by dmoz.