public DigesterDefinitionsReader() 
{
               
        digester = new Digester();
        digester.setValidating(validating);
        digester.setNamespaceAware(true);
        digester.setUseContextClassLoader(true);
        digester.setErrorHandler(new ThrowingErrorHandler());
        // Register our local copy of the DTDs that we can find
        for (int i = 0; i <  registrations.length; i += 2) {
            URL url = this.getClass().getResource(
                registrations[i + 1]);
            if (url != null) {
                digester.register(registrations[i], url.toString());
            }
        }
}

Creates a new instance of DigesterDefinitionsReader.

 public  void addDefinition(Definition definition) 
{
        definitions.put(definition.getName(), definition);
}

Adds a new Definition to the internal Map or replaces an existing one.

 public  void init(Map params) throws DefinitionsFactoryException 
{
        if (params != null) {
            String value = params.get(PARSER_VALIDATE_PARAMETER_NAME);
            if (value != null) {
                digester.setValidating(Boolean.valueOf(value));
            }
        }
        initDigesterForTilesDefinitionsSyntax(digester);
        inited = true;
}

Initializes the DefinitionsReader object.

This method must be called before the #read method is called.

 public Map read(Object source) throws DefinitionsFactoryException 
{
        // Get out if we have not been initialized.
        if (!inited) {
            throw new DefinitionsFactoryException(
                "Definitions reader has not been initialized.");
        }
        // This is an instance variable instead of a local variable because
        // we want to be able to call the addDefinition method to populate it.
        // But we reset the Map here, which, of course, has threading implications.
        definitions = new HashMap< String, Definition >();
        if (source == null) {
            // Perhaps we should throw an exception here.
            return null;
        }
        InputStream input;
        try {
            input = (InputStream) source;
        } catch (ClassCastException e) {
            throw new DefinitionsFactoryException(
                "Invalid source type.  Requires java.io.InputStream.", e);
        }
        try {
            // set first object in stack
            //digester.clear();
            digester.push(this);
            // parse
            digester.parse(input);
        } catch (SAXException e) {
            throw new DefinitionsFactoryException(
                "XML error reading definitions.", e);
        } catch (IOException e) {
            throw new DefinitionsFactoryException(
                "I/O Error reading definitions.", e);
        }
        return definitions;
}

Reads Definition objects from a source.

Implementations should publish what type of source object is expected.