MMBase

The implementation of MMBase, an open source content management system.

The main interface to MMBase, also known as `MMCI' (MMBase Cloud Interface). One of the core interfaces of this package is indeed `Cloud', which gives direct access to MMBase data.

Script languages can access MMBase in this way. JSP can e.g. do this rather directly, or a little less directly by use of the MMBase Taglib.

This package contains several bridge related classes which can be used independently of the rest of MMBase.

This package contains also some implementation of bridge interfaces. In contradiction to implemenations in org.mmbase.bridge.implementation, these classes do not depend on MMBase core classes, and have public constructors.

Contains utility functions that perform XML functionaly on MMBase bridge objects. This normally means a connection between org.w3.dom.* and org.mmbase.bridge.*

The goal of this package is to centralize the MMBase caches. Every cache extends the abstract 'Cache' class, which also contains the static methods to obtain a list of al caches.

All caches which are based on the Cache class can also be configured (activity, size) by <config>/caches.xml.

Provides the caches which can be used when doing XSLT conversions. Like a cache for Templates and a cache for Factories.

There is also a cache for XSLT results.

Plugins into set- and getValue methods on Node (Setting and getting Fields).

In this directory the framework for putting functionality there is implemented. The basic agent is 'ValueIntercepter' which reads an XML and provides the set- and get-Value implemntation with the specified 'Processor'.

When functionality is added to a certain field type then a Processor must be implemented and turned on in datatypes.xml or the builder xml.

Processors can be parameterized in two ways. Using a {@link ParameterizedProcessorFactory} or {@link ParameterizedCommitProcessorFactory} or simply by using bean-like setting on the instance. Both ways are recognized in builder xml's.

The package contains the component framework of MMBase.

Key classes in this package are:

• Framework
• State. The render state. The framework is responsible for calling State.getState(request). See BasicFramework.
• The ComponentRepository. There is one instance of this in every MMBase, and all Components, can be found in here.
• UrlConverter. The framework is also responsible for producingURL's. This can be implemented seperately (BasicFramework maintains a list of external UrlConverters to implement it's own url-conversion functionalilty)

The modules used to load MMBase and optional MMBase functionality.

The classes in this package consist of a number of base classes that define the module structure. Module and ProcessorModule define basic module functionality, while ModuleProbe can be used to trigger periodic maintenance.

The remaining classes are specific implementations of the Module. These modules can be used to add fucntionality to MMBase. This includes support modules for the scripting language SCAN, and modules for caching, email, communication, statistics, polls, user and session maintenance and transactions ('TCP').

Note that a number of essential modules, in particular MMBase, MMAdmin and JDBC, are located in their own packages.

The MMBase standard and optional builders.

The classes in this package are extensions of MMObjectBuilder, or support classes for these builders (such as probes and exceptions).

Each class implements some additonal Functionality. A number of these builders work together to form an application.

The default (featureless) builder used by MMBase is Dummy. Note that a number of essential buidlers (core buidlers) are located in a separate package.

The core classes for MMBase. These classes define core functionality and the building stones of the MMBase cloud.

The main classes defined here are MMBase, which is module that loads and initializes the MMBase cloud, MMObjectBuilder, which represents collections of objects of a specific type, and MMObjectNode, which represents individual objects in the cloud.

Other classes define code for handling inter-server-communication, virtual and temporary objects, transaction handling, and MMbaseObservers - classdes that 'observe' and react to events in MMBase.fc

The MMBase core builders.

The classes in this package are extensions of MMObjectBuilder that implement essential functionality for MMBase. The builders are directly instantiated by MMBase and are (with the exception of OALias) mandatory.

The classes and interfaces that arrange the actual connection to JDBC database.

It contains the JDBC module, which implements the JDBCInterface and is the main entrypoint when retrieving a connnection to a selected database layer (defined in the support package).

It also contains code for the implementation of a connection pool, for use with JDBC2.

The security infrastructure of MMBase. MMBase has a pluggable security system, which is currently called from within the bridge implementation. The core of this setup are the abstract classes `Authorization' and `Authentication', which are connected with 'UserContext' implementations.

There are several interesting security implementations available in a standard MMBase installation, but you can always implement your own. The implementations can be found in subpackages of org.mmbase.bridge.implementation.

• The most powerful implementation is the 'context' implementation which supplies a a system of user, groups and 'contexts', which is configured by a sophisticated xml file.
• Another implementation is the 'cloud' implementation which is a simpler system with only users (no groups) which are stored as MMBase objects, so you can administrate this with the normal MMBase edit tools.
• There is also a 'context' implementation available which is completely in cloud. This one is shipped as an MMBase 'application'.
• more..?

MMBase is based on servlets. To start MMBase you have to have at least one servlet which extends MMBaseServlet. It could be MMBaseServlet itself (which can't do much by itself - it will give back the version only - but MMBase then is availabe in your JSP-pages).

The abstract 'BridgeServlet' can be used to base new servlets upon in which the MMBase 'cloud' is to be used.

A very normal servlet to have it a an image servlet. There are two now: ImageServlet and 'servdb'. The latter used to be the 'all purpose' MMBase servlet, but as soon as all purposes are migrated to stand alone, more clean, servlets this class will be deprecated.

There are also a few servlet presents in the package which are mere `test' or `demo' servlets.

The interfaces that define the classes for persistent storage of objects.

This package contains classes that define the Transaction and Storage interfaces, and exceptions that may be thrown by the implementation of these classes.

Provides interfaces for retrieval of data from {@link org.mmbase.storage.search.SearchQuery SearchQuery} objects.

The function framework is all about the creation of {@link org.mmbase.util.functions.Function} instances, from which then, subsequently, function values can be acquired. To do that you need to supply the {@link org.mmbase.util.functions.Parameters} to the function.

Functions come in several different variants. There are completely stand alone functions, e.g. {@link org.mmbase.util.functions.Functions} (of which a limited number of instances can exists), but they can also be associated with some object (in OO speak: they mimic instance member functions of that object then). {@link org.mmbase.util.functions.NodeFunction} Function objects can e.g. be associated with {@link org.mmbase.bridge.Node} objects. Such function objects can exists very many (for every possible node, for every function on it, there can be a Function object). Other object instance related functions may be associated with Modules and NodeManager.

How to use functions

Taglib users would use the function tags. Those are documented in the taglib reference documentation (and a bit of small example code can be found in javadoc of {@link org.mmbase.util.functions.ExampleBuilder}). More taglib examples for functions can be found in /mmexamples/taglib/functions.jsp of the distro.

A programmer needs to know several things.

• Functions are basically bridge things. So nodes are bridge Nodes.
• FunctionProviders have {@link org.mmbase.util.functions.FunctionProvider#addFunction(Function)}
• {@link org.mmbase.util.functions.AbstractFunction} is available to quickly define a function.
• {@link org.mmbase.util.functions.NodeFunction} is available to quickly define a function on a Node.
• An example of a node and builder function implementation can be found in {@link org.mmbase.util.functions.ExampleBuilder}.
• You can also add functions to a builder in the builder XML. E.g. based on a method in another class, or other FunctionProvider.

The MMBase logging infrastructure. The main classes of this package are `Logger', which provides the interface for logging implementations (because the precise implementation is pluggable), and 'Logging', which takes care of the configuration and setting up of the logging system.

Another import class is 'Level' which describes the possible logging levels currently known by MMBase.

SimpleImpl is the most basic implementation of `Logger' but a more sophisticated one, based on log4j, can be found in a subpackage.

Classes related to the java.util.logging package (new in java 1.4). There are two things which you may want:

• Make MMBase log with java.util.logging.Logger's. This is possible with the 'Impl' class of this package, which can be configured in log.xml. So, this wraps java.util.logging.Logger in org.mmbase.util.logging.Logger.
• You have some class which asks for a java.util.logging.Logger where it will log to, and you want it to log to the MMBase log. For this, the 'MMBaseLogger' class is meant. So, this wraps org.mmbase.util.logging.Logger in java.util.logging.Logger.

This package contains the classes needed by org.mmbase.util.magicfile.MagicFile. A complete package is dedicated to this because it is quite a lot of code to put in one file.

The core class is `Detector'. MagicXMLReader creates the Detectors using an XML configuration file 'magic.xml'. 'MagicParser' contains the functions to generate a magic.xml from a UNIX 'file' file.

`Tranformers' define tranformations of Strings, byte arrays and streams.

Transformers are devided in three species. CharTransformers which transform some String to another String (or Reader to a Writer). Then there are transformation which take a byte array (or an InputStream) and transform that to a String (or a Writer), these are called ByteToCharTransformers. And the last type are are the ByteTranformers, which tranform a byte array to another byte array (or an InputStream to an OutputStream).

All Transformers can be specialized to 'ConfigurableTransformers'.

Several Abstract implemenations are present too. E.g. the 'ReaderTransformer' is nearly a complete CharTransformer, only the function wich pipes a Reader to a Writer is abstract. StringTranformer is a CharTransformer which' only abstract function is the one taking a String argument.