public XMLCatalog() 
{
        setChecked(false);
}

Default constructor

 public  void addConfiguredXMLCatalog(XMLCatalog catalog) 
{
        if (isReference()) {
            throw noChildrenAllowed();
        }
        // Add all nested elements to our catalog
        Vector newElements = catalog.getElements();
        Vector ourElements = getElements();
        Enumeration e = newElements.elements();
        while (e.hasMoreElements()) {
            ourElements.addElement(e.nextElement());
        }
        // Append the classpath of the nested catalog
        Path nestedClasspath = catalog.getClasspath();
        createClasspath().append(nestedClasspath);
        // Append the catalog path of the nested catalog
        Path nestedCatalogPath = catalog.getCatalogPath();
        createCatalogPath().append(nestedCatalogPath);
        setChecked(false);
}

Loads a nested <xmlcatalog> into our definition. Not allowed if this catalog is itself a reference to another catalog -- that is, a catalog cannot both refer to another and contain elements or other attributes.

 public  void addDTD(ResourceLocation dtd) throws BuildException 
{
        if (isReference()) {
            throw noChildrenAllowed();
        }
        getElements().addElement(dtd);
        setChecked(false);
}

Creates the nested <dtd> element. Not allowed if this catalog is itself a reference to another catalog -- that is, a catalog cannot both refer to another and contain elements or other attributes.

 public  void addEntity(ResourceLocation entity) throws BuildException 
{
        addDTD(entity);
}

Creates the nested <entity> element. Not allowed if this catalog is itself a reference to another catalog -- that is, a catalog cannot both refer to another and contain elements or other attributes.

 public Path createCatalogPath() 
{
        if (isReference()) {
            throw noChildrenAllowed();
        }
        if (this.catalogPath == null) {
            this.catalogPath = new Path(getProject());
        }
        setChecked(false);
        return this.catalogPath.createPath();
}

Creates a nested <catalogpath> element. Not allowed if this catalog is itself a reference to another catalog -- that is, a catalog cannot both refer to another and contain elements or other attributes.

 public Path createClasspath() 
{
        if (isReference()) {
            throw noChildrenAllowed();
        }
        if (this.classpath == null) {
            this.classpath = new Path(getProject());
        }
        setChecked(false);
        return this.classpath.createPath();
}

Allows nested classpath elements. Not allowed if this catalog is itself a reference to another catalog -- that is, a catalog cannot both refer to another and contain elements or other attributes.

 protected synchronized  void dieOnCircularReference(Stack stk,
    Project p) throws BuildException 
{
        if (isChecked()) {
            return;
        }
        if (isReference()) {
            super.dieOnCircularReference(stk, p);
        } else {
            if (classpath != null) {
                pushAndInvokeCircularReferenceCheck(classpath, stk, p);
            }
            if (catalogPath != null) {
                pushAndInvokeCircularReferenceCheck(catalogPath, stk, p);
            }
            setChecked(true);
        }
}

 public Path getCatalogPath() 
{
        return getRef().catalogPath;
}

Returns the catalog path in which to attempt to resolve DTDs.

 public Source resolve(String href,
    String base) throws TransformerException 
{
        if (isReference()) {
            return getRef().resolve(href, base);
        }
        dieOnCircularReference();
        SAXSource source = null;
        String uri = removeFragment(href);
        log("resolve: '" + uri + "' with base: '" + base + "'", Project.MSG_DEBUG);
        source = (SAXSource) getCatalogResolver().resolve(uri, base);
        if (source == null) {
            log("No matching catalog entry found, parser will use: '"
                + href + "'", Project.MSG_DEBUG);
            //
            // Cannot return a null source, because we have to call
            // setEntityResolver (see setEntityResolver javadoc comment)
            //
            source = new SAXSource();
            URL baseURL = null;
            try {
                if (base == null) {
                    baseURL = FILE_UTILS.getFileURL(getProject().getBaseDir());
                } else {
                    baseURL = new URL(base);
                }
                URL url = (uri.length() == 0 ? baseURL : new URL(baseURL, uri));
                source.setInputSource(new InputSource(url.toString()));
            } catch (MalformedURLException ex) {
                // At this point we are probably in failure mode, but
                // try to use the bare URI as a last gasp
                source.setInputSource(new InputSource(uri));
            }
        }
        setEntityResolver(source);
        return source;
}

Implements the URIResolver.resolve() interface method.

 public InputSource resolveEntity(String publicId,
    String systemId) throws SAXException, IOException 
{
        if (isReference()) {
            return getRef().resolveEntity(publicId, systemId);
        }
        dieOnCircularReference();
        log("resolveEntity: '" + publicId + "': '" + systemId + "'",
            Project.MSG_DEBUG);
        InputSource inputSource =
            getCatalogResolver().resolveEntity(publicId, systemId);
        if (inputSource == null) {
            log("No matching catalog entry found, parser will use: '"
                + systemId + "'", Project.MSG_DEBUG);
        }
        return inputSource;
}

Implements the EntityResolver.resolveEntity() interface method.

 public  void setCatalogPathRef(Reference r) 
{
        if (isReference()) {
            throw tooManyAttributes();
        }
        createCatalogPath().setRefid(r);
        setChecked(false);
}

Allows catalogpath reference. Not allowed if this catalog is itself a reference to another catalog -- that is, a catalog cannot both refer to another and contain elements or other attributes.

 public  void setClasspath(Path classpath) 
{
        if (isReference()) {
            throw tooManyAttributes();
        }
        if (this.classpath == null) {
            this.classpath = classpath;
        } else {
            this.classpath.append(classpath);
        }
        setChecked(false);
}

Allows simple classpath string. Not allowed if this catalog is itself a reference to another catalog -- that is, a catalog cannot both refer to another and contain elements or other attributes.

 public  void setClasspathRef(Reference r) 
{
        if (isReference()) {
            throw tooManyAttributes();
        }
        createClasspath().setRefid(r);
        setChecked(false);
}

Allows classpath reference. Not allowed if this catalog is itself a reference to another catalog -- that is, a catalog cannot both refer to another and contain elements or other attributes.

 public  void setRefid(Reference r) throws BuildException 
{
        if (!elements.isEmpty()) {
            throw tooManyAttributes();
        }
        super.setRefid(r);
}

Makes this instance in effect a reference to another XMLCatalog instance.

You must not set another attribute or nest elements inside this element if you make it a reference. That is, a catalog cannot both refer to another and contain elements or attributes.