wCMF  3.6
 All Classes Namespaces Files Functions Variables Groups Pages
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
oCAbstractFormatAbstractFormat maybe used as base class for specialized formats
oCActionMapperActionMapper 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
oCAdminControllerAdminController is used as an entry point to the admintool
oCAnonymousUserAnonymous User
oCApplicationThe main application class. Does all the initialization
oCArrayOutputStrategyThis OutputStrategy outputs an object's content into an array
oCArrayUtilArrayUtil provides support for array manipulation
oCAssociateControllerAssociateController is a controller that (dis-)associates Nodes (by setting the parent/child relations)
oCAsyncPagingControllerAsyncPagingController is a controller that allows to navigate lists
oCAuthUserAuthUser provides a storage and methods for user data used for authentication/authorization purposes. This class requires php >= 4.1.0
oCAuthUserRDBAuthUser that gets configuration from an database
oCAuthUserXMLAuthUser that gets configuration from an XML file
oCBackupControllerThis 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
oCBatchControllerBatchController 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
oCBatchDisplayControllerBatchDisplayController 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
oCBusyLockManagerBusyLockManager acts as if half of the resources are locked. Use this to simulate heavy concurrency
oCChangeListenerChangeListener defines an interface for classes that want to be notified when a value of an persistent object changes
oCChildrenListControllerChildrenListController is a controller that loads chilren of a given node and displays the result in a list
oCCommitVisitorThe CommitVisitor is used to commit the object's changes to the object storage. The objects must implement the PersistentObject interface
oCConcurrencyControllerConcurrencyController is a controller that allows to lock/unlock objects
oCConfigControllerConfigController 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
oCControllerController 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'
oCControllerDelegateControllerDelegate 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
oCControllerMessageControllerMessages 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
oCCopyControllerCopyController is a controller that copies Nodes
oCCreateInstanceControllerThis Controller creates a new instance of this application
oCCSVUtilCSVUtil provides basic support for csv file functionality. The first line of a csv file is supposed to hold the field names
oCDataConverterDataConverter is the base class for all converter classes. It defines the interface for converting data between storage and application
oCDBUtilDBUtil provides database helper functions
oCDefaultControlRendererDefaultControlRenderer 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
oCDefaultDataConverterThe default dataconverter
oCDefaultOutputStrategyThis OutputStrategy outputs an object's content to the Log category DefaultOutputStrategy. Classes used must implement the toString() method
oCDefaultValueRendererDefaultValueRenderer 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
oCDeleteControllerDeleteController is a controller that delete Nodes
oCDisplayControllerDisplayController is a simple controller demonstrating how to display a Node using the displaynode.tpl template
oCDotOutputStrategyThis OutputStrategy outputs an object's content in a dot file
oCEditRightsControllerEditRightsController is used to edit rights on a resource
oCElementImageOutputStrategyThis OutputStrategy outputs a tree of objects into an image file. It must be configured with a map that was calculated by a LayoutVisitor
oCEncodingUtilEncodingUtil provides helper functions for working with different encodings mainly UTF-8
oCExitControllerExitController stops the script execution immediatly by calling the exit function
oCFailureControllerFailureController is a controller that shows an error page to the user
oCFileUtilFileUtil provides basic support for file functionality like HTTP file upload
oCFormatterFormatter 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'
oCFormUtilFormUtil provides basic support for HTML forms. It's mainly for creating input controls from definition strings
oCFTPUtilFTPUtil provides support for ftp functionality
oCGraphicsUtilGraphicsUtil provides support for graphic manipulation
oCHierarchicalFormatHierarchicalFormat 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
oCHTMLDataConverterHTMLDataConverter converts data between storage and HTML files
oCHTMLFormatHTMLFormat 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
oCHTTPClientHTTPClient is used to do calls to other wCMF instances over HTTP
oCI18nUtilI18nUtil provides support i18n functionality
oCIFormatIFormat 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
oCImageOutputStrategyThis OutputStrategy outputs a tree of objects into an image file. It must be configured with a map that was calculated by a LayoutVisitor
oCInifileParserInifileParser provides basic services for parsing a ini file from the file system
oCInsertControllerInsertController is a controller that inserts Nodes
oCInternalLinkInternalLink 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
oCJSONFormatJSONFormat 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
oCJSONUtilJSONUtil provides helper functions for JSON
oCLayoutVisitorThe 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
oCLinkConverterLinkConverter 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)
oCListboxControllerListboxController is a controller that uses g_getOIDs to retrieve listbox data
oCLocalizationLocalization 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)
oCLockLock represents a lock on an object
oCLockManagerLockManager is used to handle lock requests on objects
oCLockManagerRDBLockManagerRDB 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
oCLogLog is used to log application events. The implementation is a wrapper over log4php. All methods may be called in a static way
oCLoggingControllerLoggingController is a controller that logs a message
oCLoginControllerLoginController is a controller that handles the login process
oCLogOutputStrategyThis OutputStrategy outputs an object's content to the logger category LogOutputStrategy, loglevel info Used classes must implement the toString() method
oCLongTaskControllerLongTaskController 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
oCMailClass to send mails
oCMapVisitorThe MapVisitor is used to extract data from the visited objects into an associative array. Subclasses define the map structure and content
oCMessageUse 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')
oCMultipleActionControllerMultipleActionController is a controller that executes multiple actions by passing them do the appropriate controllers and returning all results as once
oCMySQLBackupControllerThis Controller enhances the file backup defined by BackupController by a backup of a given MySQL database
oCMySQLDateConverterMySQLDateConverter converts MySQL dates to a date localized to the users or application settings
oCNodeNode 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
oCNodeIteratorNodeIterator 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
oCNodeListControllerNodeListController is a controller that loads nodes of a given type and displays the result in a list
oCNodeProcessorNodeProcessor is used to iterate over all values of a Node and apply a given callback function
oCNodeRDBMapperNodeRDBMapper 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
oCNodeSerializerNodeSerializer provides helper functions to de-/serialize Nodes
oCNodeToSingleTableMapperNodeToSingleTableMapper 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
oCNodeUnifiedRDBMapperNodeUnifiedRDBMapper 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:
oCNodeUtilNodeUtil provides services for the Node class. All methods are static
oCNodeXMLDBMapperNodeXMLDBMapper maps Node objects to a xml file using the CXmlDb class. http://sourceforge.net/projects/phpxmldb
oCNodeXMLMapperNodeXMLMapper maps nodes to a xml file
oCNullFormatNullFormat passes through the original request and response objects without modifying or transforming them
oCNullLockManagerNullLockManager acts as if no LockManager was installed. Use this to disable locking
oCNullNodeNullNode 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))
oCNullViewNullView is a stub class that implements all view methods
oCObfuscatorThis 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
oCObjectFactoryObjectFactory loads class definitions and instantiates classes
oCObjectQueryObjectQuery 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
oCOutputStrategyOutputStrategy 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
oCOutputVisitorThe 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
oCPageExportControllerPageExportController 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
oCPagingControllerPagingController is a controller that allows to navigate lists
oCPagingInfoPagingInfo contains information about a paged list
oCPDFPagePDFPage instances define the content of a pdf page by using a set of FPDF/FPDI commands inside the PDFPage::render method
oCPDFTemplatePDFTemplate 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
oCPDOConnectionPDOConnection extends PDO
oCPersistenceFacadePersistenceFacade instantiates the PersistenceFacade implementation
oCPersistenceFacadeImplPersistenceFacadeImpl delegates persistence operations to the type-specific PersistenceMappers
oCPersistenceMapperPersistenceMapper is the base class for all mapper classes
oCPersistentIteratorPersistentIterator 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'
oCPersistentObjectPersistentObject 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:
oCPositionStores a coordinate tuple for use with the LayoutVisitor
oCPrincipalControllerPrincipalController is used to edit users and roles
oCRDBMapperRDBMapper 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
oCRemoteCapablePersistenceFacadeRemoteCapablePersistenceFacade delegates local persistence operations to the default PersistenceFacadeImpl and remote operations to a remote server
oCRemotingFacadeRemotingFacade is used to communicate with other wCMF instances
oCRequestRequest holds the request values that are used as input to Controller instances. It is typically instantiated and filled by the ActionMapper
oCResourceListControllerResourceListController is a controller used to manage resources from the server and displays it using the resourcelist.tpl template. For file resources it uses elFinder
oCResourceTreeControllerResourceTreeController allows to browse cms content in a tree view and set links when selecting a resource. It works together with resourcetree.tpl
oCResponseResponse 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
oCRightsManagerRightsManager is used to handle all authorization requests
oCRoleAbstract base class for role classes that represent a user role
oCRPCClientRPCClient is used to do calls to other wCMF instances on the same maschine
oCSaveControllerSaveController is a controller that saves Node data
oCSearchControllerSearchController is a controller that executes a search for oids and displays them in a paged list. Internally it uses Zend Lucene indexed search
oCSearchIndexControllerSearchIndexController creates a Lucene index from the complete datastore
oCSearchUtilThis 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
oCSessionDataThis class provides a unified access to session data
oCSimpleBatchControllerSimpleBatchController is a controller demonstrating the use of BatchController for cutting a long task into a fixed number of smaller tasks
oCSimpleLongTaskControllerSimpleLongTaskController is a controller demonstrating the use of LongTaskController for cutting a long task into a fixed number of smaller tasks
oCSimplePagingControllerSimplePagingController is a controller demonstrating the use of PagingController for splitting long lists into several pages
oCSOAPControllerSOAPController is a controller that handles SOAPRequests
oCSOAPFormatSOAPFormat realizes the SOAP request/response format. Nodes are serialized into an array (the nusoap library creates the XML)
oCSortControllerSortController is a controller that sorts Nodes of same type
oCStorableThis class defines the interface for classes that can be stored in the session
oCStringQueryStringQuery 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
oCStringUtilStringUtil provides support for string manipulation
oCTableTable 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)
oCTableRDBMapperTableRDBMapper maps Table objects to a relational database schema where one object contains several table rows
oCTableUnifiedRDBMapperTableRDBMapper 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
oCTerminateControllerTerminateController stops the action processing by returning false in executeKernel
oCTreeViewControllerTreeViewController is used to visualize cms data in a tree view
oCTreeViewOutputStrategyThis OutputStrategy outputs the object's content in a DHTML Treeview
oCURIUtilURIUtil provides support for uri manipulation
oCUserAbstract base class for user classes that represent a system user
oCUserControllerUserController is used to edit data of the current users
oCUserManagerUserManager is used to edit users and roles. UserManager supports the following operations:
oCUserManagerRDBUserManagerRDB 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
oCUserManagerXMLUserManagerXML is a UserManager that stores user and role information in an XML file
oCViewView 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
oCViewControllerViewController is a controller that has no logic. It is used to display a static view only
oCVisitorVisitor 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
oCWCMFExceptionUse 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)
oCWCMFInifileParserWCMFInifileParser 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
oCXMLDataConverterXMLDataConverter converts data between storage and XML files
oCXMLExportControllerXMLExportController exports the content tree into an XML file
oCXMLOutputStrategyThis OutputStrategy outputs an object's content in a xml file using the default format
\CXMLUtilXMLUtil helps in using XML files as storage. XMLUtil is a subclass of CXmlDb that is customized for use with the wemove cms framework