Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

Smarty
AbstractFormat	AbstractFormat maybe used as base class for specialized formats
ActionMapper	ActionMapper is the central class in our implementation of the mvc pattern. It calls the different Controllers based on the referring Controller and the given action
AdminController	AdminController is used as an entry point to the admintool
Adodbseq
AdodbseqBase
AdodbseqRDBMapper
Analyzer
AnonymousUser	Anonymous User
Application	The main application class. Does all the initialization
ApplicationException
ArrayOutputStrategy	This OutputStrategy outputs an object's content into an array
ArrayUtil	ArrayUtil provides support for array manipulation
AssociateController	AssociateController is a controller that (dis-)associates Nodes (by setting the parent/child relations)
AsyncPagingController	AsyncPagingController is a controller that allows to navigate lists
AuthUser	AuthUser provides a storage and methods for user data used for authentication/authorization purposes. This class requires php >= 4.1.0
AuthUserRDB	AuthUser that gets configuration from an database
AuthUserXML	AuthUser that gets configuration from an XML file
BackupController	This Controller creates a backup (action 'makebackup') from a directory and restores (action 'restorebackup') a created one to that directory respectively. It creates a directory named after the 'backupName' parameter in the backup directory whose name is determined by the configuration key 'backupDir' (section 'cms'). Then it copies all files found in the directory given in the 'sourceDir' parameter to that directory. Subclasses may add additional work packages by overriding the BackupController::getAdditionalWorkPackage method
BatchController	BatchController allows to define work packages that will be processed in a sequence. It simplifies the usage of LongTaskController functionality for splitting different bigger tasks into many smaller (similar) tasks where the whole number of tasks isn't known at designtime
BatchDisplayController	BatchDisplayController is a controller that loads a tree of Nodes recursivly and returns the Nodes in lists of a given size. The reconstruction of the tree must be handled by the client
BusyLockManager	BusyLockManager acts as if half of the resources are locked. Use this to simulate heavy concurrency
ChangeListener	ChangeListener defines an interface for classes that want to be notified when a value of an persistent object changes
ChildrenListController	ChildrenListController is a controller that loads chilren of a given node and displays the result in a list
CommitVisitor	The CommitVisitor is used to commit the object's changes to the object storage. The objects must implement the PersistentObject interface
ConcurrencyController	ConcurrencyController is a controller that allows to lock/unlock objects
ConfigController	ConfigController is used to edit configuration files. The controller uses the global variable CONFIG_PATH to locate the configuration files. The global variables CONFIG_EXTENSION and MAIN_CONFIG_FILE are used to determine which files are configuration files and which one is the default one
Controller	Controller is the base class of all controllers. If a Controller has a view it is expected to reside in the directory configured in section smarty.templateDir. Additional smarty directories ('templates_c', 'configs', 'cache') are expected in a subdirectory of the template directory named 'smarty'
ControllerDelegate	ControllerDelegate is used to define an interface to vary the behaviour of the Controller base class. The methods are called by the Controller base class on defined variation points and get the currently executed controller as parameter
ControllerMessage	ControllerMessages are sent between Controllers and are used to transfer data between them. ControllerMessages are dispatched by ActionMapper, which decides upon the message's controller, context and action parameter to which Controller it will be send
CopyController	CopyController is a controller that copies Nodes
CreateInstanceController	This Controller creates a new instance of this application
CSVUtil	CSVUtil provides basic support for csv file functionality. The first line of a csv file is supposed to hold the field names
DataConverter	DataConverter is the base class for all converter classes. It defines the interface for converting data between storage and application
DBUtil	DBUtil provides database helper functions
DefaultControlRenderer	DefaultControlRenderer is responsible for rendering html input controls. Each control is defined in a smarty template, which is configured by the appropriate entry in the configuration section 'htmlform' (e.g. the text input control has the entry 'text'). The templates get a default set of variables assigned. Additional variables, needed only for certain controls, are assigned in the appropriate configure method (e.g. 'configure_text'). which may be overridden by subclasses
DefaultDataConverter	The default dataconverter
DefaultOutputStrategy	This OutputStrategy outputs an object's content to the Log category DefaultOutputStrategy. Classes used must implement the toString() method
DefaultValueRenderer	DefaultValueRenderer is responsible for rendering (Node) values of a given display type. Each display type is defined in a smarty template, which is configured by the appropriate entry in the configuration section 'htmldisplay' (e.g. the image display type has the entry 'image'). The templates get a default set of variables assigned. Additional variables, needed only for certain display types, are assigned in the appropriate configure method (e.g. 'configure_image') which may be overridden by subclasses
DeleteController	DeleteController is a controller that delete Nodes
DisplayController	DisplayController is a simple controller demonstrating how to display a Node using the displaynode.tpl template
DotOutputStrategy	This OutputStrategy outputs an object's content in a dot file
EditRightsController	EditRightsController is used to edit rights on a resource
ElementImageOutputStrategy	This OutputStrategy outputs a tree of objects into an image file. It must be configured with a map that was calculated by a LayoutVisitor
EncodingUtil	EncodingUtil provides helper functions for working with different encodings mainly UTF-8
ExitController	ExitController stops the script execution immediatly by calling the exit function
FailureController	FailureController is a controller that shows an error page to the user
FileUtil	FileUtil provides basic support for file functionality like HTTP file upload
Formatter	Formatter is is the single entry point for request/response formatting. It chooses the configured formatter based on the format property of the message by getting the value XXXFormat from the configuration section 'implementation'
FormUtil	FormUtil provides basic support for HTML forms. It's mainly for creating input controls from definition strings
FTPUtil	FTPUtil provides support for ftp functionality
GraphicsUtil	GraphicsUtil provides support for graphic manipulation
HierarchicalFormat	HierarchicalFormat maybe used as base class for formats that are able to represent hierarchical data like JSON or XML. This format automatically iterates over data when de-/serializing and uses template methods to implement the specific format
HTMLDataConverter	HTMLDataConverter converts data between storage and HTML files
HTMLFormat	HTMLFormat realizes the HTML request/response format. Since all data from the external representation arrives in form fields, grouping of values has to be done via the field names. So Nodes are represented by their values whose field names are of the form value-<datatype>-<name>-<oid>. All of these values will be removed from the request and replaced by Node instances representing the data. The each node is stored under its oid in the data array
HTTPClient	HTTPClient is used to do calls to other wCMF instances over HTTP
I18nUtil	I18nUtil provides support i18n functionality
IFormat	IFormat defines the interface for all formatter classes. Formatter classes are used to map external data representations like JSON, XML/SOAP or HTML to internal ones. All data values are supposed to be scalar or array values except for Nodes, for which each external representation defines a special notation
ImageOutputStrategy	This OutputStrategy outputs a tree of objects into an image file. It must be configured with a map that was calculated by a LayoutVisitor
InifileParser	InifileParser provides basic services for parsing a ini file from the file system
InsertController	InsertController is a controller that inserts Nodes
InternalLink	InternalLink contains static methods for handling internal application links. These links are useful in an scenario, where an object represents a page and several subobjects represent page elements
JSONFormat	JSONFormat realizes the JSON request/response format. All data will be de-/serialized using the json_encode/json_encode method if avalaible or JSON.php as fallback, except for Nodes. Nodes are serialized into an array before encoding (see JSONFormat::serializeValue). On serialization the data will be outputted directly using the print command
JSONUtil	JSONUtil provides helper functions for JSON
LayoutVisitor	The LayoutVisitor is used to position a tree of objects on a plane (the objects must implement the getParent()). It uses a simple algorithm that positions the objects on a discrete array with distance 1 so that all leaves are equal distant from their neighbours. The positions are stored in a map that is provided by the getMap() method
LinkConverter	LinkConverter converts internal absolute urls to relative ones when saving to the database and vice versa. Since StringUtil::getUrls() is used to detect urls, only urls in hmtl elements are detected when converting from storage to application (relative to absolute). If the url is not in an html element (e.g. if the whole data is an url) the conversion works only from application to storage (absolute to relative)
ListboxController	ListboxController is a controller that uses g_getOIDs to retrieve listbox data
Localization	Localization is used to store localized entity instances and retrieve them back. Entity instances are localized value by value, where a translation of a value of one instance into a specific language is represented by one instance of the entity type that is defined in the key 'translationType' in the configuration section 'i18n' (e.g. Translation)
Lock	Lock represents a lock on an object
LockManager	LockManager is used to handle lock requests on objects
LockManagerRDB	LockManagerRDB implements a LockManager for relational databases. Locks are represented by the entity type 'Locktable' with attributes 'sessionid', 'objectid', 'since' (all DATATYPE_ATTRIBUTE). Locktable instances are children of the user entity
Locktable
LocktableBase
LocktableRDBMapper
Log	Log is used to log application events. The implementation is a wrapper over log4php. All methods may be called in a static way
LoggingController	LoggingController is a controller that logs a message
LoginController	LoginController is a controller that handles the login process
LogOutputStrategy	This OutputStrategy outputs an object's content to the logger category LogOutputStrategy, loglevel info Used classes must implement the toString() method
LongTaskController	LongTaskController is a controller that may be used as base class for tasks, that require a long execution time such as construction of a list of pages
Mail	Class to send mails
MapVisitor	The MapVisitor is used to extract data from the visited objects into an associative array. Subclasses define the map structure and content
Message	Use the Message class to output messages. You need not instantiate a Message object because the methods may be called like static class methods e.g. $translated = Message::get('text to translate')
MultipleActionController	MultipleActionController is a controller that executes multiple actions by passing them do the appropriate controllers and returning all results as once
MySQLBackupController	This Controller enhances the file backup defined by BackupController by a backup of a given MySQL database
MySQLDateConverter	MySQLDateConverter converts MySQL dates to a date localized to the users or application settings
NMUserRole
NMUserRoleBase
NMUserRoleRDBMapper
Node	Node is the basic component for building trees (although a Node can have one than more parents). The Node class implements the 'Composite Pattern', so no special tree class is required, all interaction is performed using the Node interface. Subclasses for specialized Nodes must implement this interface so that clients don't have to know about special Node classes. Use the methods addChild(), deleteChild() to build/modify trees
NodeIterator	NodeIterator is used to iterate over a tree/list build of objects using a Depth-First-Algorithm. Classes used with the NodeIterator must implement the getChildren() and getOID() methods. NodeIterator implements the 'Iterator Pattern'. The base class NodeIterator defines the interface for all specialized Iterator classes
NodeListController	NodeListController is a controller that loads nodes of a given type and displays the result in a list
NodeProcessor	NodeProcessor is used to iterate over all values of a Node and apply a given callback function
NodeRDBMapper	NodeRDBMapper maps Node objects to a relational database schema where each Node type has its own table. It defines a persistence mechanism that specialized mappers customize by overriding the given template methods
NodeSerializer	NodeSerializer provides helper functions to de-/serialize Nodes
NodeToSingleTableMapper	NodeToSingleTableMapper maps nodes of different types to the database. It uses a relational database scheme that simulates a xml tree. That means all nodes share one table
NodeUnifiedRDBMapper	NodeUnifiedRDBMapper maps Node objects to a relational database schema where each Node type has its own table. In comparison to NodeRDBMapper it implements almost all template methods from the base classes and defines the sql queries. The newly defined template methods make it easier for application developers to implement own mapper subclasses. The wCMFGenerator uses this class as base class for all mappers. Besides some methods that define table/column names, the main effort lies in implementing the getObjectDefinitionImpl() method wich needs the following extra definitions:
NodeUtil	NodeUtil provides services for the Node class. All methods are static
NodeXMLDBMapper	NodeXMLDBMapper maps Node objects to a xml file using the CXmlDb class. http://sourceforge.net/projects/phpxmldb
NodeXMLMapper	NodeXMLMapper maps nodes to a xml file
NullFormat	NullFormat passes through the original request and response objects without modifying or transforming them
NullLockManager	NullLockManager acts as if no LockManager was installed. Use this to disable locking
NullNode	NullNode is an implementation of the NullObject pattern, It inherits all functionality from Node (acts like a Node) and is only distinguishable from a Node instance by it's class or oid. If a Node's parent is a NullNode instance, than they should be separated in the data store (e.g. the foreign key should be null, if allowed by the database). NullNode child instances should be ignored. The object id is created using the following code: PersistenceFacade::composeOID(array('type' => $this->_type, 'id' => NULL))
NullView	NullView is a stub class that implements all view methods
Obfuscator	This class allows to obfuscate strings. By passing an objuscated string to the method Obfuscator::unveil() the orginal string is returned. This is especially useful, if you want to place a secret string inside a client view as a parameter and want to get the original string back as the request is processed
ObjectFactory	ObjectFactory loads class definitions and instantiates classes
ObjectQuery	ObjectQuery is the base class for object queries. This class provides the user with object templates on which query conditions may be set. Object templates are Node instances whose attribute values are used as conditions on the appropriate attributes. A value inludes the operator to be applied to it. For example $authorTpl->setValue("name", "LIKE '%ingo%'") means searching for authors whose name contains 'ingo'. Operator and value should be separated by a space. If no operator is given LIKE '%...' is assumed
OutputStrategy	OutputStrategy is used to write an object's content to a destination (called 'document') using a special format. OutputStrategy implements the 'Strategy Pattern'. The abstract base class OutputStrategy defines the interface for all specialized OutputStrategy classes
OutputVisitor	The OutputVisitor is used to output an object's content to different destinations and formats. The spezial output destination/format may be configured by using the corresponding OutputStrategy, which is set using the setOutputStrategy() method
PageExportController	PageExportController is an abstract controller that is used as base class for Controller classes that export content to pages defined by templates. Export is triggered by any action except 'preview' and 'continue'. On 'preview' action PageExportController creates a preview corresponding to a given oid and context
PagingController	PagingController is a controller that allows to navigate lists
PagingInfo	PagingInfo contains information about a paged list
PDF	PDF extends FPDF/FPDI
PDFPage	PDFPage instances define the content of a pdf page by using a set of FPDF/FPDI commands inside the PDFPage::render method
PDFTemplate	PDFTemplate is used to output pdf files based on a given pdf template. PDFTemplate uses FPDI/FPDF. PDFPage instances are used to render data onto the template pages
PDOConnection	PDOConnection extends PDO
PersistenceFacade	PersistenceFacade instantiates the PersistenceFacade implementation
PersistenceFacadeImpl	PersistenceFacadeImpl delegates persistence operations to the type-specific PersistenceMappers
PersistenceMapper	PersistenceMapper is the base class for all mapper classes
PersistentIterator	PersistentIterator is used to iterate over a tree/list build of oids using a Depth-First-Algorithm. To persist its state use the PersistentIterator::save() method, to restore its state use the static PersistentIterator::load() method, which returns the loaded instance. States are identified by an unique id, which is provided after saving. PersistentIterator implements the 'Iterator Pattern'
PersistentObject	PersistentObject is the base class of all persistent objects. It implements the basic persistence methods (save(), delete()) which will be delegated to the PersistenceMapper class that contsructed the object. The PersistentObject holds the object data in an associative array of the following structure:
Position	Stores a coordinate tuple for use with the LayoutVisitor
PrincipalController	PrincipalController is used to edit users and roles
RDBMapper	RDBMapper maps objects of one type to a relational database schema. It defines a persistence mechanism that specialized mappers customize by overriding the given template methods
RemoteCapablePersistenceFacade	RemoteCapablePersistenceFacade delegates local persistence operations to the default PersistenceFacadeImpl and remote operations to a remote server
RemoteCapablePersistenceFacadeImpl
RemotingFacade	RemotingFacade is used to communicate with other wCMF instances
Request	Request holds the request values that are used as input to Controller instances. It is typically instantiated and filled by the ActionMapper
ResourceListController	ResourceListController is a controller used to manage resources from the server and displays it using the resourcelist.tpl template. For file resources it uses elFinder
ResourceTreeController	ResourceTreeController allows to browse cms content in a tree view and set links when selecting a resource. It works together with resourcetree.tpl
Response	Response holds the response values that are used as output from Controller instances. It is typically instantiated by the ActionMapper instance and filled during Controller execution
RightsManager	RightsManager is used to handle all authorization requests
Role	Abstract base class for role classes that represent a user role
RoleImpl
RoleRDB
RoleRDBBase
RoleRDBRDBMapper
RoleXML
RPCClient	RPCClient is used to do calls to other wCMF instances on the same maschine
SaveController	SaveController is a controller that saves Node data
SearchController	SearchController is a controller that executes a search for oids and displays them in a paged list. Internally it uses Zend Lucene indexed search
SearchIndexController	SearchIndexController creates a Lucene index from the complete datastore
SearchUtil	This class provides access to the search based on Zend_Search_Lucene. The search index stored in the location that is defined by the configuration key 'indexPath' in the configuration section 'search'. To manage PersistentObjects in the index use the methods SearchUtil::indexInSearch() and SearchIndex::deleteFromSearch() and SearchUtil::commitIndex(). The method SearchUtil::getIndex() offers direct access to the search index for advanced operations
SessionData	This class provides a unified access to session data
SimpleBatchController	SimpleBatchController is a controller demonstrating the use of BatchController for cutting a long task into a fixed number of smaller tasks
SimpleLongTaskController	SimpleLongTaskController is a controller demonstrating the use of LongTaskController for cutting a long task into a fixed number of smaller tasks
SimplePagingController	SimplePagingController is a controller demonstrating the use of PagingController for splitting long lists into several pages
SOAPController	SOAPController is a controller that handles SOAPRequests
SOAPFormat	SOAPFormat realizes the SOAP request/response format. Nodes are serialized into an array (the nusoap library creates the XML)
SortController	SortController is a controller that sorts Nodes of same type
Storable	This class defines the interface for classes that can be stored in the session
StringQuery	StringQuery executes queries from a string representation. Queries are constructed like WHERE clauses in sql, except that foreign key relations between the different types are not necessary. Attributes have to be defined with the appropriate type prepended, e.g. Author.name instead of name
StringUtil	StringUtil provides support for string manipulation
Table	Table is a PersistentObject that holds a table structure. The rows of the table correspond to the value names of the PersistentObject and the columns to the datatypes. So if you want to set the value of row $i and column $j to $value call $table->setValue($i, $value, $j). To retrieve the corresponding value call $value = $table->getValue($i, $j)
TableRDBMapper	TableRDBMapper maps Table objects to a relational database schema where one object contains several table rows
TableUnifiedRDBMapper	TableRDBMapper maps Table objects to a relational database schema where one object contains several table rows. In comparison to TableRDBMapper it implements the template methods in a way that handles unified table definitions (e.g. tables are named as the type, primary keys are named 'id' and attribute names correspond to table columns). Subclasses simply need to define $_type as the mapper type and implement the getObjectDefinition() method
TerminateController	TerminateController stops the action processing by returning false in executeKernel
TreeViewController	TreeViewController is used to visualize cms data in a tree view
TreeViewOutputStrategy	This OutputStrategy outputs the object's content in a DHTML Treeview
URIUtil	URIUtil provides support for uri manipulation
User	Abstract base class for user classes that represent a system user
UserController	UserController is used to edit data of the current users
UserImpl
UserManager	UserManager is used to edit users and roles. UserManager supports the following operations:
UserManagerRDB	UserManagerRDB is a UserManager that stores user and role information in a database using RDBMappers. The User and Role implementation classes are defined by the configuration keys 'User' and 'Role' in the [implementation] section
UserManagerXML	UserManagerXML is a UserManager that stores user and role information in an XML file
UserRDB
UserRDBBase
UserRDBRDBMapper
UserXML
View	View is used by Controller to handle the view presentation in MVC pattern. View is a subclass of Smarty that is customized for use with the wCMF
ViewController	ViewController is a controller that has no logic. It is used to display a static view only
Visitor	Visitor is used to extend an object's functionality by not extending its interface. Classes to use with the Visitor must implement the acceptVisitor() method. Visitor implements the 'Visitor Pattern'. It implements the 'Template Method Pattern' to allow subclasses to do any Pre- and Post Visit operations (doPreVisit() and doPostVisit() methods). The abstract base class Visitor defines the interface for all specialized Visitor classes
WCMFException	Use the WCMFException class to handle errors. You need not instantiate a WCMFException object because the methods may be called like static class methods e.g. $translated = WCMFWCMFException::throwEx('error message', FILE, LINE)
WCMFInifileParser	WCMFInifileParser adds methods for wcmf specific inifiles. This class is a decorator to the InifileParser class, showing only the readonly methods of InifileParser in it's interface. The advantage in using the InifileParser singleton inside this class is that its instance will hold the same configuration data as the WCMFInifileParser instance does. For this reason other classes may use the InifileParser instance not knowing about the WCMFInifileParser class at all
XMLDataConverter	XMLDataConverter converts data between storage and XML files
XMLExportController	XMLExportController exports the content tree into an XML file
XMLOutputStrategy	This OutputStrategy outputs an object's content in a xml file using the default format
XMLUtil	XMLUtil helps in using XML files as storage. XMLUtil is a subclass of CXmlDb that is customized for use with the wemove cms framework