<?xml version="1.0" encoding="ISO-8859-1"?>

<document>

  <properties>
        <author email="cstaylor@nanshu.com">Christopher Taylor</author>
        <title>Understanding the Domain.xml configuration file</title>
    </properties>
  
  <body>
    
  <section name="Introduction">
    
    <p>
      This HOWTO will try and fill in the gaps left between the Schema [<a href="schema/slide_1_0_16.xsd" target="_blank">xsd</a>] [<a href="schema/slide_1_0_16.dtd" target="_blank">dtd</a>] 
      [<a href="schema/schema_1_0_16.html" target="_blank">documentation</a>] and the current slide configuration <a href="conf-lib.html">document</a>.  This document 
      will not explain how XML works or what XSD is.  This document is for developers, primarily developers working with the Slide WebDAV servlet who want to know what kind of configuration options
      are available.
    </p>
    <p>
        Every Slide webapplication needs an XML configuration file.  This document is normally referred to as the <code>Domain.xml</code> file.
    </p>
  </section>
  <section name="slide - the top level XML element">
    <p>
        <a name="slide_elem">The</a> top-level element in the <code>Domain.xml</code> file is <code>slide</code>. 
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true">None</td>
        </tr>
        </table>
        
        <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#namespace_elem">namespace</a></td>
        <td>1</td>
        <td>unlimited</td>        
        </tr>
        </table>
        
        The <code>slide</code> element support three attributes:
        
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">logger</td>
        <td>The Java classname for the logger object</td>
        <td>org.apache.slide.util.logger.SimpleLogger</td>
        <td>org.apache.slide.util.logger.SimpleLogger</td>
        </tr>
        <tr>
        <td nowrap="true">logger-level</td>
        <td>A numeric level indicator for the amount of data logged.  These values range from 0 to 7, with 0 being the least amount of information logged</td>
        <td>4 (warnings and above)</td>
        <td>4 - INFO</td>
        </tr>
        <tr>
        <td nowrap="true">default</td>
        <td>This is the most critical attribute of the slide element.  This attribute defines the default namespace in this Domain.  The WebDAV servlet will use this value
        when displaying the site to a standard web browser</td>
        <td>my-default-namespace</td>
        <td>slide</td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;slide logger="org.apache.slide.util.logger.SimpleLogger" logger-level="6" default="my-default-namespace"&gt;</code>
    </p>
  </section>
  <section name="parameter - general purpose tag for passing configuration information">
    <p>
        <a name="parameter_elem">A <code>parameter</code></a> element is used in multiple places throughout the Domain.xml configuration file.  <code>Parameters</code> are name/value pairs, similar to Java properties. 
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#slide_elem">slide</a>, <a href="#store_elem">store</a>, <a href="#nodestore_elem">nodestore</a>, <a href="#securitystore_elem">securitystore</a>,
        <a href="#lockstore_elem">lockstore</a>, <a href="#revisiondescriptorsstore_elem">revisiondescriptorsstore</a>, <a href="#revisiondescriptorstore_elem">revisiondescriptorstore</a>,
        <a href="#contentstore_elem">contentstore</a>, <a href="#configuration_elem">configuration</a>, <a href="#contentinterceptor_elem">content-interceptor</a></td>
        </tr>
        </table>
        
        
        The <code>parameter</code> element supports one attribute:
        
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">name</td>
        <td>the name of the parameter in this name/value pair</td>
        <td>driver</td>
        <td>N/A | this attribute is required</td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;parameter name="driver"&gt;org.hsqldb.jdbcDriver&lt;/parameter&gt;</code>
    </p>
  </section>
  <section name="namespace - the key to everything in Slide">
    <p>
        <a name="namespace_elem">The</a> <code>slide</code> top-level element contains a number of <b><a href="namespace.html">Namespaces</a></b>.  These namespaces are the backbone of Slide.  When someone navigates through
        a set of files provided by the Slide web application, they are walking through one of Slide's namespaces.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#slide_elem">slide</a></td>
        </tr>
        </table>

        <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#definition_elem">definition</a></td>
        <td>1</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        <td>1</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#data_elem">data</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">name</td>
        <td>Slide applications refer to Namespaces by name.  This Namespace will be registered under this name.  If two namespaces have the same name, the last one defined in the configuration file
        will be references, and the other one will be lost.</td>
        <td>my-default-namespace</td>
        <td>Must be specified.  If not, the WebDAV component will complain to the log before terminating.</td>
        </tr>
        <tr>
        <td nowrap="true">logger</td>
        <td>The Java classname for the logger object</td>
        <td>org.apache.slide.util.logger.SimpleLogger</td>
        <td>If unspecified, the slide-level logger will be used.  This is a way to customize logging for a particular namespace</td>
        </tr>
        <tr>
        <td nowrap="true">logger-level</td>
        <td>A numeric level indicator for the amount of data logged.  These values range from 0 to 7, with 0 being the least amount of information logged</td>
        <td>4 (warnings and above)</td>
        <td>If unspecified, the slide-level logger will be used.  This is a way to customize logging for a particular namespace</td>
        </tr>
        </table>
    </p>
    <p>
        Example w/o logger: <code>&lt;namespace name="my-default-namespace"&gt;</code>
    </p>
    </section>
    <section name="definition - what services are available in this namespace?">
    <p><a name="definition_elem">The</a> <code>definition</code> contains the <a href="#store_elem">store</a> objects in this domain, and a <a href="#scope_elem">scope</a> object defining the root for this namespace.  It has no attributes: it is merely
    a container for subelements.
    </p>
    <p>        
       <table>
       <tr>
       <td nowrap="true" width="100">Parent Element</td>
       <td nowrap="true"><a href="#namespace_elem">namespace</a></td>
       </tr>
       </table>
       <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#store_elem">store</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#scope_elem">scope</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;definition&gt;</code>
    </p>
    </section>
    <section name="store - contains the objects in this namespace">
    <p><a name="store_elem">A</a> <code>store</code> is bound in the <a href="domain.html">Domain</a> by name; when there are multiple stores, a programmer
    can ask for one by name. A store must support two categories of services: descriptors and data.  Descriptors consist of path names to nodes, security information, locks, and change management.  Data
    is the raw information that a descriptor owns.  Think of it as a filesystem: descriptors are the file metainformation (directories, modification times, access control, file locks, etc...) and
    data is the content of the file.
       </p>
       <p>        
       <table>
       <tr>
       <td nowrap="true" width="100">Parent Element</td>
       <td nowrap="true"><a href="#definition_elem">definition</a></td>
       </tr>
       </table>
       <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#nodestore_elem">nodestore</a></td>
        <td>1</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#securitystore_elem">securitystore</a></td>
        <td>1</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#lockstore_elem">lockstore</a></td>
        <td>1</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#revisiondescriptorsstore_elem">revisiondescriptorsstore</a></td>
        <td>1</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#revisiondescriptorstore_elem">revisiondescriptorstore</a></td>
        <td>1</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#revisiondescriptorstore_elem">contentstore</a></td>
        <td>1</td>
        <td>1</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">name</td>
        <td>The name of this store within the domain</td>
        <td>my-first-store</td>
        <td>N/A | this attribute is required</td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;store name=&quot;database-store&quot;&gt;</code>
    </p>
    </section>
    <section name="nodestore - provides structure for the namespace">
    <p><a name="nodestore_elem">The</a> <code>nodestore</code> service provides structure to the namespace.  It manages the tree of nodes like a filesystem directory.
    </p>
    <p>        
       <table>
       <tr>
       <td nowrap="true" width="100">Parent Element</td>
       <td nowrap="true"><a href="#store_elem">store</a></td>
       </tr>
       </table>
       <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#reference_elem">reference</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">classname</td>
        <td>The fully-qualified name of the Java class that implements the <code>org.apache.slide.store.NodeStore</code> interface</td>
        <td>slidestore.reference.MemoryDescriptorsStore</td>
        <td>N/A | this attribute is optional</td>
        </tr>
        </table>
    </p>
    <p>
        Example with parameters: <br /><code>&lt;nodestore classname=&quot;slidestore.reference.JDBCDescriptorsStore&quot;&gt;<br />
        &lt;parameter name="driver"&gt;org.hsqldb.jdbcDriver&lt;/parameter&gt;<br />
         &lt;parameter name="url"&gt;jdbc:hsqldb:slidestructure&lt;/parameter&gt;<br />
         &lt;parameter name="user"&gt;sa&lt;/parameter&gt;<br />
         &lt;parameter name="password"&gt;&lt;/parameter&gt;<br />
        &lt;/nodestore&gt;</code><br />
    </p>
    <p>
        Example with a reference to another store: <br /><code>&lt;nodestore&gt;&lt;reference store="that-other-store"&gt;&lt;/nodestore&gt;</code><br />
    </p>
</section>
<section name="reference - a pointer to another store instance">
    <p>
        <a name="reference_elem">A <code>reference</code></a> element informs Slide that this store's responsibilities should be forwarded to another store implementation. For example,
        a single store instance could manage the services for nodestore, lockstore, and securitystore.  In this case, the lockstore and securitystore definitions should contain a <code>reference</code>
        element referring to the nodestore.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#nodestore_elem">nodestore</a>, <a href="#securitystore_elem">securitystore</a>,
        <a href="#lockstore_elem">lockstore</a>, <a href="#revisiondescriptorsstore_elem">revisiondescriptorsstore</a>, <a href="#revisiondescriptorstore_elem">revisiondescriptorstore</a>,
        <a href="#contentstore_elem">contentstore</a></td>
        </tr>
        </table>
        
        
        The <code>reference</code> element supports one attribute:
        
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">store</td>
        <td>refer my responsibilities to another store.  Accepted values: "nodestore", "securitystore", "lockstore", "revisiondescriptorsstore", "revisiondescriptorstore", "contentstore"</td>
        <td>nodestore</td>
        <td>N/A | this attribute is required</td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;reference store="nodestore" /&gt;</code>
    </p>
  </section>
<section name="securitystore - controls user access to nodes">
    <p><a name="securitystore_elem">The</a> <code>securitystore</code> service restricts access to nodes depending on the permissions.  Think of it like the <code>rwxrxwrxw</code> permissions of Unix... except Slide is a bit more complicated.
    </p>
    <p>        
       <table>
       <tr>
       <td nowrap="true" width="100">Parent Element</td>
       <td nowrap="true"><a href="#store_elem">store</a></td>
       </tr>
       </table>
       <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#reference_elem">reference</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">classname</td>
        <td>The fully-qualified name of the Java class that implements the <code>org.apache.slide.store.SecurityStore</code> interface</td>
        <td>slidestore.reference.MemoryDescriptorsStore</td>
        <td>N/A | this attribute is optional</td>
        </tr>
        </table>
    </p>
    <p>
        Example with parameters: <br /><code>&lt;securitystore classname=&quot;slidestore.reference.JDBCDescriptorsStore&quot;&gt;<br />
        &lt;parameter name="driver"&gt;org.hsqldb.jdbcDriver&lt;/parameter&gt;<br />
         &lt;parameter name="url"&gt;jdbc:hsqldb:slidestructure&lt;/parameter&gt;<br />
         &lt;parameter name="user"&gt;sa&lt;/parameter&gt;<br />
         &lt;parameter name="password"&gt;&lt;/parameter&gt;<br />
        &lt;/securitystore&gt;</code><br />
    </p>
    <p>
        Example with a reference to another store: <br /><code>&lt;securitystore&gt;&lt;reference store="that-other-store"&gt;&lt;/securitystore&gt;</code><br />
    </p>
</section>
<section name="lockstore - provides exclusive access to nodes">
    <p><a name="lockstore_elem">The</a> <code>lockstore</code> service guarantees upon request that a single user may access a resource without interruption.  
    Think of it like locking a file in Unix with exclusive access: <code>fcntl ( some_file_descriptor, F_SETLK, some_struct_flock_ptr * )</code>.
    </p>
    <p>        
       <table>
       <tr>
       <td nowrap="true" width="100">Parent Element</td>
       <td nowrap="true"><a href="#store_elem">store</a></td>
       </tr>
       </table>
       
       <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        
        <tr>
        <td nowrap="true"><a href="#reference_elem">reference</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        
        </table>
        
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        
        <tr>
        <td nowrap="true">classname</td>
        <td>The fully-qualified name of the Java class that implements the <code>org.apache.slide.store.LockStore</code> interface</td>
        <td>slidestore.reference.MemoryDescriptorsStore</td>
        <td>N/A | this attribute is optional</td>
        </tr>
        
        </table>
    </p>
    <p>
        Example with parameters: <br /><code>&lt;lockstore classname=&quot;slidestore.reference.JDBCDescriptorsStore&quot;&gt;<br />
        &lt;parameter name="driver"&gt;org.hsqldb.jdbcDriver&lt;/parameter&gt;<br />
         &lt;parameter name="url"&gt;jdbc:hsqldb:slidestructure&lt;/parameter&gt;<br />
         &lt;parameter name="user"&gt;sa&lt;/parameter&gt;<br />
         &lt;parameter name="password"&gt;&lt;/parameter&gt;<br />
         &lt;/lockstore&gt;</code><br />
    </p>
    <p>
        Example with a reference to another store: <br /><code>&lt;lockstore&gt;&lt;reference store="that-other-store"&gt;&lt;/lockstore&gt;</code><br />
    </p>
    </section>
    
    <section name="revisiondescriptorsstore - gives access to all revision metainformation of a particular node">
    <p><a name="revisiondescriptorsstore_elem">The</a> <code>revisiondescriptorsstore</code> service contains information about the different versions of a particular node, including the revision numbers, the latest revision, and any 
    branches.  Information concerning a particular revision is not supporting by this service.
    </p>
    <p>        
       <table>
       <tr>
       <td nowrap="true" width="100">Parent Element</td>
       <td nowrap="true"><a href="#store_elem">store</a></td>
       </tr>
       </table>
       <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#reference_elem">reference</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">classname</td>
        <td>The fully-qualified name of the Java class that implements the <code>org.apache.slide.store.RevisionDescriptorsStore</code> interface</td>
        <td>slidestore.reference.MemoryDescriptorsStore</td>
        <td>N/A | this attribute is optional</td>
        </tr>
        </table>
    </p>
    <p>
        Example with parameters: <br /><code>&lt;revisiondescriptorsstore classname=&quot;slidestore.reference.JDBCDescriptorsStore&quot;&gt;<br />
        &lt;parameter name="driver"&gt;org.hsqldb.jdbcDriver&lt;/parameter&gt;<br />
         &lt;parameter name="url"&gt;jdbc:hsqldb:slidestructure&lt;/parameter&gt;<br />
         &lt;parameter name="user"&gt;sa&lt;/parameter&gt;<br />
         &lt;parameter name="password"&gt;&lt;/parameter&gt;<br />
        &lt;/revisiondescriptorsstore&gt;</code><br />
    </p>
    <p>
        Example with a reference to another store: <br /><code>&lt;revisiondescriptorsstore&gt;&lt;reference store="that-other-store"&gt;&lt;/revisiondescriptorsstore&gt;</code><br />
    </p>
    </section>
    
    <section name="revisiondescriptorstore - gives access to revision information for a particular revision of a particular node">
    <p><a name="revisiondescriptorstore_elem">The</a> <code>revisiondescriptorstore</code> service contains information about a single revision of a particular node, including the revision number, an optional branch name, associated version labels,
     properties, content length, content type, creation time, modified time, etc.  Information concerning other revisions of the same node is not supporting by this service.
       <table>
       <tr>
       <td nowrap="true" width="100">Parent Element</td>
       <td nowrap="true"><a href="#store_elem">store</a></td>
       </tr>
       </table>
       <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#reference_elem">reference</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">classname</td>
        <td>The fully-qualified name of the Java class that implements the <code>org.apache.slide.store.RevisionDescriptorStore</code> interface</td>
        <td>slidestore.reference.MemoryDescriptorStore</td>
        <td>N/A | this attribute is optional</td>
        </tr>
        </table>
    </p>
    <p>
        Example with parameters: <br /><code>&lt;revisiondescriptorstore classname=&quot;slidestore.reference.JDBCDescriptorsStore&quot;&gt;<br />
        &lt;parameter name="driver"&gt;org.hsqldb.jdbcDriver&lt;/parameter&gt;<br />
         &lt;parameter name="url"&gt;jdbc:hsqldb:slidestructure&lt;/parameter&gt;<br />
         &lt;parameter name="user"&gt;sa&lt;/parameter&gt;<br />
         &lt;parameter name="password"&gt;&lt;/parameter&gt;<br />
        &lt;/revisiondescriptorstore&gt;</code><br />
    </p>
    <p>
        Example with a reference to another store: <br /><code>&lt;revisiondescriptorstore&gt;&lt;reference store="that-other-store"&gt;&lt;/revisiondescriptorstore&gt;</code><br />
    </p>
    <p>
        <b>Note:</b> take care when defining this element, as the difference between this service and the previous one differ by a single letter <b>'s'</b>.
    </p>
    </section>
    
    <section name="contentstore - responsible for the data associated with a particular node">
    <p><a name="contentstore_elem">The</a> <code>contentstore</code> service provides the <b>content</b> of a particular node, accessible by revision number.  Think of it as the stream of bytes from disk; once the node has been located
    in the structure (<code>NodeStore</code>), passed security checks (<code>SecurityStore</code>), and is not locked by someone else (<code>LockStore</code>), the contents of that node may be read from or
    written to the content store.</p>
       <p>
       <table>
       <tr>
       <td nowrap="true" width="100">Parent Element</td>
       <td nowrap="true"><a href="#store_elem">store</a></td>
       </tr>
       </table>
       <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#reference_elem">reference</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">classname</td>
        <td>The fully-qualified name of the Java class that implements the <code>org.apache.slide.store.ContentStore</code> interface</td>
        <td>slidestore.reference.MemoryDescriptorStore</td>
        <td>N/A | this attribute is optional</td>
        </tr>
        </table>
    </p>
    <p>
        Example with parameters: <br /><code>&lt;contentstore classname=&quot;slidestore.reference.JDBCDescriptorsStore&quot;&gt;<br />
        &lt;parameter name="driver"&gt;org.hsqldb.jdbcDriver&lt;/parameter&gt;<br />
         &lt;parameter name="url"&gt;jdbc:hsqldb:slidestructure&lt;/parameter&gt;<br />
         &lt;parameter name="user"&gt;sa&lt;/parameter&gt;<br />
         &lt;parameter name="password"&gt;&lt;/parameter&gt;<br />
        &lt;/contentstore&gt;</code><br />
    </p>
    <p>
        Example with a reference to another store: <br /><code>&lt;contentstore&gt;&lt;reference store="that-other-store"&gt;&lt;/contentstore&gt;</code><br />
    </p>
    </section>
    
    <section name="scope - maps a namespace onto the domain">
    <p><a name="scope_elem">The</a> <code>scope</code> element maps a store onto the structure provided by the <a href="domain.html">Domain</a>.  Think of it like an entry in the Unix <code>fstab</code>
    file, where a <a href="#store_elem"><code>store</code></a> is a filesystem mapped onto the file system tree maintained by the operating system.  One and only one store can be mounted to the root ("<code>/</code>").
    When a complete path is handed to the Domain during a call, the Domain is responsible for choosing the right store to handle the call.  For example, if store 'memory' has a <code>scope</code>
    referencing <code>/</code>, and store 'database' has a <code>scope</code> referencing <code>/db</code>, a request to read from node <code>/db/chris/some_file</code> will be passed to the 'database' store.</p>
    <p>In addition, for each <code>scope</code> element, a new instance of the store is created and mapped into the Domain on the provided URI.  This means that a single store definition may be
    instantiated multiple times, but exist at different places on the Domain structure.</p>
       <p>
       <table>
       <tr>
       <td nowrap="true" width="100">Parent Element</td>
       <td nowrap="true"><a href="#definition_elem">definition</a></td>
       </tr>
       </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">store</td>
        <td>The name of the store mapped to the URI described in the match attribute</td>
        <td>my-first-store</td>
        <td>N/A | this attribute is required</td>
        </tr>
        <tr>
        <td nowrap="true">match</td>
        <td>Where the namespace referenced by the store attribute will be mapped on the Domain structure. Must be an absolute path starting with '/'</td>
        <td>/database</td>
        <td>N/A | this attribute is required</td>
        </tr>
        </table>
    </p>                                                                                                                                                            
    <p>
        Example: <br /><code>&lt;scope store="my-database-store" match="/" /&gt;</code><br />
    </p>
    </section>
    <section name="configuration - the catchall element for configuring Slide">
    <p>
        <a name="configuration_elem">A <code>configuration</code></a> element makes changes to Slide settings outside of a particular namespace or node.  The configuration is split into six sections:
        <ul>
        <li>actions</li>
        <li>paths</li>
        <li>parameters</li>
        <li>roles</li>
        <li>default properties</li>
        <li>content-interceptor definitions</li>
        </ul>
         All of the sections except <code>default-action</code> are optional.

    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#slide_elem">slide</a></td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#default_action_elem">default-action</a></td>
        <td>1</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#read_object_elem">read-object</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#create_object_elem">create-object</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#remove_object_elem">remove-object</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#grant_permission_elem">grant-permission</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#revoke_permission_elem">revoke-permission</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#read_permissions_elem">read-permissions</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#lock_object_elem">lock-object</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#kill_lock_elem">kill-lock</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#read_locks_elem">read-locks</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#read_revision_metadata_elem">read-revision-metadata</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#create_revision_metadata_elem">create-revision-metadata</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#modify_revision_metadata_elem">modify-revision-metadata</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#remove_revision_metadata_elem">remove-revision-metadata</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#read_revision_content_elem">read-revision-content</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#create_revision_content_elem">create-revision-content</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#modify_revision_content_elem">modify-revision-content</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#remove_revision_content_elem">remove-revision-content</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#userspath_elem">userspath</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#guestpath_elem">guestpath</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#filespath_elem">filespath</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#role_elem">role</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#auto_create_users_elem">auto-create-users</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#auto_create_users_role_elem">auto-create-users-role</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#default_property_elem">default-property</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#contentinterceptor_elem">content-interceptor</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;configuration&gt;</code>
    </p>
  </section>
  <section name="default-action - the action called when no other action is available">
    <p>
        <a name="default_action_elem">The <code>default-action</code></a> is called when no element is configured for the operation in question.</p>
    <p>What is an action?  Slide supplies several standard actions for use with the WebDAV network protocol.  For example, reading the contents of a file requires a successful <code>read-revision-content</code>
    action.  The <code>configuration</code> element lists these actions by name, each containing a reference to an <code>ActionNode</code> somewhere else in the Domain structure.
    </p>
    <p><img src="images/action-objects.png" /></p>
    <p>An <code>ActionNode</code>, defined in the <code><a href="#data_elem">data</a></code> section of the Domain.xml file, can have any name that you wish.  Common examples are <code>read</code> for
    read actions like <code>read-revision-content</code>, <code>write</code> for write actions like <code>modify-revision-content</code> and <code>remove-revision-content</code>, and <code>manage</code>
    for administration actions like <code>revoke-permission</code>, but these names are not required, just suggested.</p>
    <p>Multiple actions can refer to the same action node, and any actions not defined in the <code>configuration</code> element are assigned the value of the <code>default-action</code> tag.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;default-action&gt;/actions/not-permitted&lt;/default-action&gt;</code>
    </p>
  </section>
  <section name="read-object - can you look up the node?">
    <p>
        <a name="read_object_elem">The <code>read-object</code></a> action is called when someone wants to find a node in the structure.  Successfully calling a <code>read-object</code> action doesn't mean
        the user can do anything else with the Node, but without a successful <code>read-object</code> action, no other operations on the Node are possible.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;read-object&gt;/actions/read&lt;/read-object&gt;</code>
    </p>
  </section>
  <section name="create-object - can you insert a new node in the Domain?">
    <p>
        <a name="create_object_elem">The <code>create-object</code></a> action is called when someone wants to insert a node into the Domain structure, including locks on other nodes.  Successfully calling a <code>create-object</code> action doesn't mean
        the user can do anything else with the Node, but without a successful <code>create-object</code> action, no locking operations are permitted.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;create-object&gt;/actions/write&lt;/create-object&gt;</code>
    </p>
  </section>
  <section name="remove-object - can you remove an existing node from the Domain?">
    <p>
        <a name="remove_object_elem">The <code>remove-object</code></a> action is called when someone wants to remove a node from the Domain structure.  Successfully calling a <code>remove-object</code> action doesn't mean
        the user can do anything else with the Node.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;remove-object&gt;/actions/write&lt;/remove-object&gt;</code>
    </p>
  </section>
  <section name="grant-permission - can you add a new permission record to a node in the Domain?">
    <p>
        <a name="grant_permission_elem">The <code>grant-permission</code></a> action is called when someone wants to add a new permission record to an existing node in the Domain structure.  
        This is a dangerous action, so only authorized users should be allowed to call it, since
        successfully calling a <code>grant-permission</code> action gives the user control over other operations on that node.  <code>grant-permission</code> does not remove existing permissions from the
        node.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;grant-permission&gt;/actions/manage&lt;/grant-permission&gt;</code>
    </p>
  </section>
  <section name="revoke-permission - can you remove an existing permission record from a node in the Domain?">
    <p>
        <a name="revoke_permission_elem">The <code>grant-permission</code></a> action is called when someone wants to remove an existing permission record from an existing node in the Domain structure.  
        This is a dangerous action, so only authorized users should be allowed to call it, since
        successfully calling a <code>revoke-permission</code> action gives the user control over other operations on that node.  For example, a user could remove a "deny write" permission from the
        node, giving the user access that it did not already have. <code>revoke-permission</code> does not add new permissions to the node.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;revoke-permission&gt;/actions/manage&lt;/revoke-permission&gt;</code>
    </p>
  </section>
  <section name="read-permissions - can you read existing permission records from a node in the Domain?">
    <p>
        <a name="read_permission_elem">The <code>read-permissions</code></a> action is called when someone wants to enumerate the existing permission records of an existing node in the Domain structure.  
        This can be a dangerous action, so only authorized users should be allowed to call it, since
        successfully calling a <code>read-permissions</code> action gives the user information about other operations on that node.  <code>read-permissions</code> does not modify the permission records of the node.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;read-permissions&gt;/actions/manage&lt;/read-permissions&gt;</code>
    </p>
  </section>
  <section name="lock-object - can you stop someone from using an existing node?">
    <p>
        <a name="lock_object_elem">The <code>lock-object</code></a> action is called when someone wants to protect an existing node in the Domain structure from concurrent use.
        Locks are required for write actions.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;lock-object&gt;/actions/write&lt;/lock-object&gt;</code>
    </p>
  </section>
  <section name="kill-lock - can you override an existing lock?">
    <p>
        <a name="kill_lock_elem">The <code>kill-lock</code></a> action is called when someone wants to remove existing locks from an object.  This can be a dangerous action, so only
        authorized users should be allowed to call it.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;kill-lock&gt;/actions/manage&lt;/kill-lock&gt;</code>
    </p>
  </section>
  <section name="read-locks - can you enumerate existing locks?">
    <p>
        <a name="read_locks_elem">The <code>read-lock</code></a> action is called when someone wants to enumerate existing locks on an object.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;read-locks&gt;/actions/read&lt;/read-locks&gt;</code>
    </p>
  </section>
  <section name="read-revision-metadata - can you look at information about a node?">
    <p>
        <a name="read_revision_metadata_elem">The <code>read-revision-metadata</code></a> action is called when someone wants to look at information about a particular node.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;read-revision-metadata&gt;/actions/read&lt;/read-revision-metadata&gt;</code>
    </p>
  </section>
  <section name="create-revision-metadata - can you create metadata information about a node?">
    <p>
        <a name="create_revision_metadata_elem">The <code>create-revision-metadata</code></a> action is called before creating a new revision of a particular node.  
        Successfully calling a <code>create-revision-metadata</code> action doesn't mean
        the user can actually create a new revision of the Node's contents, but without a successful <code>create-revision-metadata</code> action, creating a revision is impossible.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;create-revision-metadata&gt;/actions/write&lt;/create-revision-metadata&gt;</code>
    </p>
  </section>
  <section name="modify-revision-metadata - can you change the metadata information about a node?">
    <p>
        <a name="modify_revision_metadata_elem">The <code>modify-revision-metadata</code></a> action is called before creating a new revision of a particular node.  
        Successfully calling a <code>modify-revision-metadata</code> action doesn't mean
        the user can actually create a new revision of the Node's contents, but without a successful <code>modify-revision-metadata</code> action, creating a revision is impossible.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;modify-revision-metadata&gt;/actions/write&lt;/modify-revision-metadata&gt;</code>
    </p>
  </section>
  <section name="remove-revision-metadata - can you remove metadata information about a node?">
    <p>
        <a name="remove_revision_metadata_elem">The <code>remove-revision-metadata</code></a> action is called before destroying an existing revision of a particular node.  
        Successfully calling a <code>remove-revision-metadata</code> action doesn't mean
        the user can actually remove an existing revision of the Node's contents, but without a successful <code>remove-revision-metadata</code> action, removing a revision is impossible.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;remove-revision-metadata&gt;/actions/write&lt;/remove-revision-metadata&gt;</code>
    </p>
  </section>
  <section name="read-revision-content - can you create a new revision of a node?">
    <p>
        <a name="read_revision_content_elem">The <code>read-revision-content</code></a> action is called before destroying an existing revision of a particular node.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;read-revision-content&gt;/actions/read&lt;/read-revision-content&gt;</code>
    </p>
  </section>
  <section name="create-revision-content - can you create a new revision of a node?">
    <p>
        <a name="create_revision_content_elem">The <code>create-revision-content</code></a> action is called before creating a new revision of a particular node's content.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;create-revision-content&gt;/actions/write&lt;/create-revision-content&gt;</code>
    </p>
  </section>
  <section name="modify-revision-content - can you modify an existing revision of a node?">
    <p>
        <a name="modify_revision_content_elem">The <code>modify-revision-content</code></a> action is called before modifying an existing revision of a particular node's content.
    </p>
    <p>
        What is the difference between creating a new revision of a node's contents and simply modifying a node's existing revision?
    </p>
    <p>
        <img src="images/modify-or-create.png" />
    </p>
    <p>
        As you can see from the above illustration, creating a new content revision means creating new revision metadata.  This means that the previous revision may be retrieved intact. When
        modifying an existing revision's content, the old content associated with that revision is irretrievably lost.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;modify-revision-content&gt;/actions/write&lt;/modify-revision-content&gt;</code>
    </p>
  </section>
  <section name="remove-revision-content - can you remove an existing revision of a node?">
    <p>
        <a name="remove_revision_content_elem">The <code>remove-revision-content</code></a> action is called before removing an existing revision of a particular node's content.  Typically this is called
        when removing a node from the nodestore.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;remove-revision-content&gt;/actions/write&lt;/remove-revision-content&gt;</code>
    </p>
  </section>
  <section name="read-revision-content - can you read a node's content?">
    <p>
        <a name="read_revision_content_elem">The <code>read-revision-content</code></a> action is called before the user can read a particular node's content.  
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;read-revision-content&gt;/actions/read&lt;/read-revision-content&gt;</code>
    </p>
  </section>
  <section name="userspath - where SubjectNodes representing each user are stored in the Domain">
    <p>
        <a name="userspath_elem">All</a> authenticated users are represented by <code>SubjectNodes</code> in Slide.  These nodes are collected beneath a single parent node in the Domain structure, and the
        path to this parent node is configured with the <code>userspath</code>.
    </p>
    <p>
        If the <code><a href="#auto_create_users_elem">auto-create-users</a></code> element is set to <b>true</b>, new SubjectNodes will be created for users who don't already have one.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
   <p>
        Example: <code>&lt;userspath&gt;/users&lt;/userspath&gt;</code>
    </p>
  </section>
  <section name="guestpath - the SubjectNode for unauthenticated users">
    <p>
        <a name="guestpath_elem">All</a> unauthenticated users are represented by a single <code>SubjectNode</code> in Slide: the value of <code>guestpath</code>.
    </p>
    <p>
        Note: In Slide v1.0, the guest path must be a relative URI (no leading <code>'/'</code>), because the code appends the value of <code>guestpath</code> to the value of
        <code><a href="#userpath_elem">userspath</a></code>.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;guestpath&gt;guest&lt;/guestpath&gt;</code>
    </p>
  </section>
  <section name="filespath - a common SubjectNode for file sharing">
    <p>
        <font color="red"><a name="filespath_elem">The</a> <code>filespath</code> SubjectNode is not currently used</font>.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example: <code>&lt;filespath&gt;/the-path-to-nowhere-leads-to-me&lt;/filespath&gt;</code>
    </p>
  </section>
  <section name="role - are you this type of user?">
    <p>
        <a name="role_elem">All</a> Nodes in the Domain structure have an associated <code>role</code>.  Roles are like primary groups in Unix or Windows: all nodes must have one and only one
        associated role.  If a node does not have a role specifically assigned to it, it will have the special role <b>nobody</b>.  Roles simplify configuration: groups of users in the same role will
        have the same security settings.  When a new user is added to Slide, simply add them to the appropriate role and no other changes need to be made.
    </p>
    <p>
        <img src="images/role-mapping.png" />
    </p>
    <p>
        There are three roles built into the Slide framework:
        <ul>
        <li>slideroles.basic.GuestRole</li>
        <li>slideroles.basic.RootRole</li>
        <li>slideroles.basic.UserRole</li>
        </ul>
        Developer's can add their own additional role classes as needed.
    </p>
    <p>
        Note: When using an external Realm for authentication, the Slide role names must match those understood by the Realm.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
         <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">name</td>
        <td>the alias for this role: must follow the Realm role stated above</td>
        <td>slideroles.basic.RootRole</td>
        <td>N/A | this attribute is required</td>
        </tr>
        </table>
    </p>
    <p>
        In Slide v1.0, things are a little more complicated.  SubjectNodes that represent each user in the Domain aren't associated with a role; they <b>are</b> the role.  For example, a user with
        the <code>RootRole</code> wouldn't be a standard SubjectNode; instead, it is an instance of the <code>slideroles.basic.RootRole</code> class, which means that changing a user's role while the server
        is running is almost impossible.
    </p>
    <p>
        Example for root role: <code>&lt;role name="root"&gt;slideroles.basic.RootRole&lt;/role&gt;</code><br />
        Example for user role: <code>&lt;role name="user"&gt;slideroles.basic.UserRole&lt;/role&gt;</code><br />
        Example for guest role: <code>&lt;role name="guest"&gt;slideroles.basic.GuestRole&lt;/role&gt;</code>
    </p>
  </section>
  <section name="auto-create-users - what happens when a user logs in but no SubjectNode exists?">
    <p>
        <a name="auto_create_users_elem">When</a> a user successfully logs into Slide, their username is matched to a corresponding SubjectNode in the <code><a href="#userspath">userspath</a></code>.
        That SubjectNode represents them within Slide.  But what happens if a user's SubjectNode does not exist in the Domain structure?  A new node will be created for them if the value of this
        element is <b>true</b>.  Otherwise the login will be rejected.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example for "yes, automatically create user SubjectNodes" : <code>&lt;auto-create-users&gt;true&lt;/auto-create-users&gt;</code><br />
        Example for "no, do not automatically create user SubjectNodes" : <code>&lt;auto-create-users&gt;false&lt;/auto-create-users&gt;</code>
    </p>
  </section>
  <section name="auto-create-users-role - the role of new SubjectNodes">
    <p>
        <a name="auto_create_users_role_elem">When</a> a user successfully logs into Slide, their username is matched to a corresponding SubjectNode in the <code><a href="#userspath">userspath</a></code>.
        That SubjectNode represents them within Slide.  But what happens if a user's SubjectNode does not exist in the Domain structure?  
        If the value of <a href="#auto_create_users_elem"><code>auto-create-users</code></a> is true, the default Java class <code>slideroles.basic.UserRoleImpl</code> will created as the SubjectNode.
        You can override this default behavior with the <code>auto-create-users-role</code> element.
    </p>
    <p>
        Note: See the difference between <code>UserRole</code> and <code>UserRoleImpl</code>?  The <code>UserRole</code> is a Java interface, so it cannot be instatiated.  The mapping between the roles
        listed in <a href="#role_elem"><code>role</code></a> section and the implementations are listed below:<br />
        <ul>
        <li><code>slideroles.basic.RootRole</code> - <code>slideroles.basic.RootRoleImpl</code></li>
        <li><code>slideroles.basic.UserRole</code> - <code>slideroles.basic.UserRoleImpl</code></li>
        <li><code>slideroles.basic.GuestRole</code> - <code>slideroles.basic.GuestRoleImpl</code></li>
        </ul>
        For additional roles, a developer needs to follow the same pattern of class/interface.
    </p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example for GuestRole : <code>&lt;auto-create-users-role&gt;slideroles.basic.GuestRoleImpl&lt;/auto-create-users-role&gt;</code>
    </p>
  </section>
  <section name="default-property - adding default properties to a SubjectNode">
    <p>
        <a href="http://asg.web.cmu.edu/rfc/rfc2518.html#sec-4">Properties</a> <a name="default_property_elem">are</a> an important part of the WebDAV standard.  For a complete explanation of what properties
        are, I recommend reading the WebDAV specification, but briefly a property is:
        <ul>
            <li>a piece of information related to a URI within a WebDAV collection</li>
            <li>can be "live" or "dead"
                <ul>
                    <li>Live properties can be changed automatically by the server</li>
                    <li>Dead properties are stored by the server but completely managed by the client</li>
                </ul>
            </li>
        <li>can be associated with XML namespaces</li>
        </ul>
        In short, a Java programmer can think of WebDAV properties like they would a <code>java.util.Properties</code> object managed by the server.  Each property must have a unique name (a combination
        of the common name and the optional XML namespace) and contains a value.  Properties can appear or disappear depending on server conditions (if the properties are "live"), and the values of these
        properties can change (again, if the properties are "live").  Clients may also add or remove dead properties to a URI resource if they have the appropriate privileges. 
    </p>
    <p>One example of a live property is <code>getlastmodified</code>, which contains the time the associated resource was modified.</p>

    <p>Use <code>default-property</code> tags for adding default properties to particular roles.  There are four well-known roles in Slide:
    <ul>
    <li><code>root</code> | root role</li>
    <li><code>user</code> | user role</li>
    <li><code>guest</code> | guest role</li>
    <li><code>nobody</code> | nobody role</li>
    </ul>
    </p>
    <p>
        Example default-property tag : <br /><code>&lt;default-property<br /> name="my-first-property-name"<br /> namespace="http://www.java-internals.com/slide/properties"<br /> value="my-first-property-default-value"<br /> role="nobody" /&gt;</code>
    </p>
    <p>The combination of the <code>name</code> and <code>namespace</code> attributes <b>must not</b> conflict with other properties of the same node.  However, the names of two properties may be equal
    as long as they have different values for the <code>namespace</code> attribute.  I recommend using a URL to your personal home page as the URI in the <code>namespace</code> attribute.</p>
    <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">name</td>
        <td>the local name of this WebDAV property.  Used with the optional namespace attribute to form the complete name of the property</td>
        <td>my-first-property-name</td>
        <td>N/A | this attribute is required</td>
        </tr>
        <tr>
        <td nowrap="true">namespace</td>
        <td>the optional XML namespace for this WebDAV property.  Used with the mandatory name attribute to form the complete name of the property</td>
        <td>http://www.java-internals.com/slide/properties</td>
        <td>"" the empty namespace</td>
        </tr>
        <tr>
        <td nowrap="true">value</td>
        <td>the optional default value of this property.  Clients may change this value later.</td>
        <td>my-first-property-default-value</td>
        <td>"" the empty value</td>
        </tr>
        <tr>
        <td nowrap="true">role</td>
        <td>this default property and value is associated with all nodes of this role (root|user|guest|nobody)</td>
        <td>nobody</td>
        <td>N/A | this attribute is required</td>
        </tr>
        </table>
    </p>
    <p>
        Note: the <code>nobody</code> role is a special role that applies to all nodes created in the Namespace.  For example, if we add a new file to the <code>/files</code> area of the structure,
        that node will have all of the associated <code>nobody</code> role default properties.
    </p>
  </section>
  <section name="content-interceptor - plug yourself in with custom handlers">
  <p>
    <a name="contentinterceptor_elem">Content interceptors</a> are called by Slide during various stages of a request.  Developing content interceptors is outside the scope of this configuration
    document, but in summary a content interceptor must:
    <ul>
    <li>implement the <code>org.apache.slide.content.ContentInterceptor</code> interface</li>
    <li>override the methods in the interface</li>
    </ul>
  </p>
      <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#configuration_elem">configuration</a></td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#parameter_elem">parameter</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">class</td>
        <td>the fully-qualified Java class name of the ContentInterceptor to install into the Slide runtime</td>
        <td>com.java_internals.slide.intercept.MyFirstInterceptor</td>
        <td>N/A | this attribute is required</td>
        </tr>
        </table>
    </p>
  <p>
        Example content interceptor w/o parameters:<br /> <code>&lt;content-interceptor class="com.java_internals.slide.intercept.MyFirstInterceptor" /&gt;</code><br />
        Example content interceptor with parameters:<br /> <code>&lt;content-interceptor class="com.java_internals.slide.intercept.MyFirstInterceptor"&gt;<br />
        &lt;parameter name="some-name"&gt;some value&lt;/parameter&gt;<br />&lt;/content-interceptor&gt;</code>
  </p>
  </section>
  <section name="data - building the Domain structure from the configuration file">
  <p>
    The <a name="data_elem"><code>Data</code></a> element gives us a place for creating nodes during Slide startup.
  </p>
  <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#namespace_elem">namespace</a></td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#objectnode_elem">objectnode</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        </table>
    </p>
  <p>
        Example of data node:<code>&lt;data&gt;...&lt;/data&gt;</code><br />
  </p>
  </section>
  <section name="ObjectNode - declaring nodes in the namespace">
  <p>
    <a name="objectnode_elem"><code>ObjectNodes</code></a> give us a way to define the namespace tree structure within the configuration file.  Each ObjectNode has several associated properties:
    <ul>
    <li><code>Java class</code> of the Node</li>
    <li>URI of the Node</li>
    <li>Associated <a href="#permission_elem"><code>permissions</code></a></li>
    <li>WebDAV <a href="#property_elem"><code>Properties</code></a> of the Node</li>
    </ul>
  </p>
  <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#data_elem">data</a></td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#revision_elem">revision</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#permission_elem">permission</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#objectnode_elem">objectnode</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">classname</td>
        <td>the fully-qualified Java class name of the ObjectNode</td>
        <td>org.apache.slide.structure.SubjectNode</td>
        <td>N/A | this attribute is required</td>
        </tr>
        <tr>
        <td nowrap="true">uri</td>
        <td>path to this node within the collection</td>
        <td>/users/GroupA</td>
        <td>N/A | this attribute is required</td>
        </tr>
        <tr>
        <td nowrap="true">linkedUri</td>
        <td>only used with link nodes.  The path to the actual node in the structure</td>
        <td>/users/foobar</td>
        <td>N/A | this attribute is required</td>
        </tr>
        </table>
    </p>
  <p>
    <code>LinkNodes</code> give us a way of placing dummy nodes in the namespace that refer to other real nodes:
  </p>
  <p>
    <img src="images/link-node.png" />
  </p>
  <p>
    As you can see from the above image, the green <b>foobar</b> node in <b>GroupA</b> <i>links</i> to the <b>foobar</b> node in the <b>Users</b> portion of the tree.
  </p>
    <p>
        Example of a regular SubjectNode:<br /> <code>&lt;objectnode<br />
        classname="org.apache.slide.structure.SubjectNode"<br />
        uri="/users/foobar" /&gt; </code><br />
    </p>
    <p>
        Example of a LinkNode:<br /> <code>&lt;objectnode<br />
        classname="org.apache.slide.structure.LinkNode"<br />
        uri="/users/GroupA/foobar"<br />
        linkedUri="/users/foobar" /&gt; </code><br />
    </p>
    <p>
    <code>ObjectNode</code> elements may contain other <code>ObjectNodes</code> as well:
   </p>
   <p>
        <pre>&lt;objectnode classname="org.apache.slide.structure.SubjectNode" uri="/users"&gt;
    &lt;objectnode classname="org.apache.slide.structure.SubjectNode" uri="/users/foobar" /&gt;
&lt;/objectnode&gt;
        </pre>
    </p>
  </section>
  <section name="revision - declaring revisions of an ObjectNode in the configuration file">
  <p>
    <a name="revision_elem">You</a> can list revisions of an <code>ObjectNode</code> with the <code>revision</code> element.
  </p>
  <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#objectnode_elem">objectnode</a></td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Child Element Name</th>
        <th nowrap="true">Minimum</th>
        <th nowrap="true">Maximum</th>
        </tr>
        <tr>
        <td nowrap="true"><a href="#ancestor_elem">ancestor</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#property_elem">property</a></td>
        <td>0</td>
        <td>unlimited</td>
        </tr>
        <tr>
        <td nowrap="true"><a href="#content_elem">content</a></td>
        <td>0</td>
        <td>1</td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">number</td>
        <td>the revisions's tag number</td>
        <td>2</td>
        <td>N/A | this attribute is required</td>
        </tr>
        <tr>
        <td nowrap="true">uri</td>
        <td>path to this node within the collection</td>
        <td>/users/GroupA</td>
        <td>N/A | this attribute is required</td>
        </tr>
        <tr>
        <td nowrap="true">linkedUri</td>
        <td>only used with link nodes.  The path to the actual node in the structure</td>
        <td>/users/foobar</td>
        <td>N/A | this attribute is required</td>
        </tr>
        </table>
    </p>
    <p>
        Example of a <code>revision: &lt;revision number="1" /&gt;</code><br />
    </p>
  </section>
  <section name="ancestor - is a revision based on a previous version?">
  <p>
    <a name="ancestor_elem">You</a> can make a particular revision based on a previous one using the <code>ancestor</code> element
  </p>
  <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#revision_elem">revision</a></td>
        </tr>
        </table>
    </p>
    <p>
        Example of an <code>ancestor: &lt;ancestor&gt;true&lt;/ancestor&gt;</code><br />
    </p>
  </section>
  <section name="property - defining WebDAV properties for a revision">
  <p>
    <a name="property_elem">You</a> can add properties to a particular revision of a node.  This node is a copy of the <code><a href="#default_property_elem">default-property</a></code> element.
  </p>
  <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#revision_elem">revision</a></td>
        </tr>
        </table>
  </p>
  </section>
  <section name="content - giving a revision some content">
  <p>
    <a name="content_elem">Nodes may have content</a>.  Use this element to tell Slide where it should find the content for this particular revision.  The value of this node must be a URL.
  </p>
  <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#revision_elem">revision</a></td>
        </tr>
        </table>
  </p>
  <p>
        Example of <code>content: &lt;content&gt;http://www.somesite.com/video/my-first-movie.mpg&lt;/content&gt;</code><br />
    </p>
  </section>
  <section name="permission - controlling access to an ObjectNode">
  <p>
    Slide controls access to ObjectNodes through <a name="permission_elem"><code>permissions</code></a>.  A <code>permission</code> consists of four components:
    <ul>
    <li>what (action)</li>
    <li>who (subject)</li>
    <li>grant/deny (negative)</li>
    <li>affect child nodes (inheritable)</li>
    </ul>
  </p>
  <p>        
        <table>
        <tr>
        <td nowrap="true" width="100">Parent Element</td>
        <td nowrap="true"><a href="#objectnode_elem">objectnode</a></td>
        </tr>
        </table>
        <table>
        <tr>
        <th nowrap="true" width="100">Attribute name</th>
        <th nowrap="true">Description</th>
        <th nowrap="true">Example</th>
        <th nowrap="true">Default value</th>
        </tr>
        <tr>
        <td nowrap="true">action</td>
        <td>path to the ActionNode</td>
        <td>/actions/write</td>
        <td>N/A | this attribute is required</td>
        </tr>
        <tr>
        <td nowrap="true">subject</td>
        <td>name of the subject or role who will be affected by this rule</td>
        <td>root</td>
        <td>N/A | this attribute is required</td>
        </tr>
        <tr>
        <td nowrap="true">negative</td>
        <td>if true, deny the user access to this action</td>
        <td>true</td>
        <td>false</td>
        </tr>
        <tr>
        <td nowrap="true">inherit</td>
        <td>if true, all child nodes of this SubjectNode receive the same permission</td>
        <td>true</td>
        <td>false</td>
        </tr>
        </table>
  </p>
  <p>
        Example of <code>permission: &lt;permission action="/actions/manage" subject="foobar" negative="false" inherit="true" /&gt;</code><br />
  </p>
  <p>
        <img src="images/permissions.png" />
  </p>
  <p>
        How is the above permission evaluated?  Whenever the <b>foobar</b> (subject) attempts the <b>manage</b> (action) action on the <b>files</b> (the ObjectNode containing the <code>permission</code> object)
        node or its children (inherit), the action is permitted.
  </p>
  </section>
</body>
</document>
