The basic CCML element is <cc:rel>, and is used to express comparisons against the environment description. A <cc:rel prop="propname" arg="arg"> compares the value of an environment property called propname against a value arg. The attribute type specifies how the two values are to be interpreted, while op specifies how they are to be compared.

See the range of property expressions available.

A <cc:logic> element combines the results of its direct CCML children. (Other content will be stripped.) With the default op="or", it succeeds if any of those children succeed. With op="and", it succeeds only if all of those children succeed. nor and nand invert those results respectively.

The following example fragment succeeds only if the property arch includes the token i386 and plugin-types includes Proxylet:

<cc:logic op="and">
  <cc:rel prop="arch" arg="i386">
  <cc:rel prop="plugin-types" arg="Proxylet">
</cc:logic>

See how logical operations appear in earlier versions.

Each CCML element is processed in a certain context determined by its containing elements. A root context applies to the root element. If a CCML element in the root context fails, the whole process has failed. Unless otherwise specified, each element is processed in the same context as its parent's. The element type <cc:option> provides a new context which masks the outer context, so a local failure within it does not cause wider or global failure. The <cc:choice> element type re-exposes its own context to failures of its contained elements, but only if all fail.

<cc:option>
  <cc:rel prop="arch" arg="i386">
  <cc:rel prop="plugin-types" arg="Proxylet>
  <myapp:some-elem>
    Some content goes here.
  </myapp:some-elem>
</cc:option>

  
  
  <myapp:some-elem>
    Some content goes here.
  </myapp:some-elem>

<cc:choice>
  <cc:option>
    <cc:rel prop="system" arg="linux">
    <myapp:load-resource href="linux.jar" />
  </cc:option>

  <cc:option>
    <cc:rel prop="system" arg="macos">
    <myapp:load-resource href="mac.jar" />
  </cc:option>

  <cc:option>
    <cc:rel prop="system" arg="windows">
    <myapp:load-resource href="win.jar" />
  </cc:option>
</cc:choice>

    <myapp:load-resource href="mac.jar" />

To process CCML in Java, create a Properties describing your environment, create a PropertiesDOMFilter from it, and pass a DOM Element to it representing the document containing embedded CCML. The document will be modified in-place, according to the environment description. A SelectionException is thrown if some critical element failed to match the environment.

The following example program resolves files named as arguments against Java's own system properties:

import java.util.Properties;
import java.io.File;
import org.xml.sax.InputSource;
import org.w3c.dom.Document;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import uk.ac.lancs.scc.ccml.SelectionException;
import uk.ac.lancs.scc.ccml.DOMFilter;
import uk.ac.lancs.scc.ccml.PropertiesDOMFilter;

public class TestCCML {
    public static void main(String args) throws Exception {
        Properties properties = System.getProperties();
        properties.store(System.out, "Configuration properties");
    
        DOMFilter filter = new PropertiesDOMFilter(properties);
        DocumentBuilderFactory documentBuilderFactory =
            DocumentBuilderFactory.newInstance();
        documentBuilderFactory.setIgnoringComments(true);
        documentBuilderFactory.setNamespaceAware(true);
        documentBuilderFactory.setIgnoringElementContentWhitespace(true);
        documentBuilderFactory.setValidating(false);
    
        for (String filename : args) {
            try {
                // Read in the document.
                File file = new File(filename);
                InputSource source = new InputSource(new FileInputStream(file));
                DocumentBuilder builder =
                    documentBuilderFactory.newDocumentBuilder();
                Document document = builder.parse(source);
    
                // Filter CCML from the document.
                filter.filter(document.getDocumentElement());
    
                // Write out the filtered document.
                System.out.println();
                System.out.println(filename + ":");
                TransformerFactory transformerFactory =
                    TransformerFactory.newInstance();
                Transformer transformer = transformerFactory.newTransformer();
                DOMSource domSource = new DOMSource(document);
                StreamResult result = new StreamResult(System.out);
                transformer.transform(domSource, result);
                System.out.println();
            } catch (SelectionException ex) {
                System.out.println(filename + ": failed\n" + ex);
            } catch (Exception ex) {
                System.out.println(ex);
            }
        }
    }
}

• Lower case is used throughout.

• There is no DTD, schema, or public identifier.

• A URI namespace is specified.

• There are no reference expressions.

• CCML is not a separate document, but embedded in another. This obviates action elements, and only expression elements are required.

• Nesting of <cc:choice> elements is fully mandated.