Examples of XMLParserConfiguration

com.sun.org.apache.xerces.internal.xni.parser.XMLParserConfiguration
Represents a parser configuration. The parser configuration maintains a table of recognized features and properties, assembles components for the parsing pipeline, and is responsible for initiating parsing of an XML document.
By separating the configuration of a parser from the specific parser instance, applications can create new configurations and re-use the existing parser components and external API generators (e.g. the DOMParser and SAXParser).
The internals of any specific parser configuration instance are hidden. Therefore, each configuration may implement the parsing mechanism any way necessary. However, the parser configuration should follow these guidelines:
- Call the reset method on each component before parsing. This is only required if the configuration is re-using existing components that conform to the XMLComponent interface. If the configuration uses all custom parts, then it is free to implement everything as it sees fit as long as it follows the other guidelines.
- Call the setFeature and setProperty method on each component during parsing to propagate features and properties that have changed. This is only required if the configuration is re-using existing components that conform to the XMLComponent interface. If the configuration uses all custom parts, then it is free to implement everything as it sees fit as long as it follows the other guidelines.
- Pass the same unique String references for all symbols that are propagated to the registered handlers. Symbols include, but may not be limited to, the names of elements and attributes (including their uri, prefix, and localpart). This is suggested but not an absolute must. However, the standard parser components may require access to the same symbol table for creation of unique symbol references to be propagated in the XNI pipeline.
@author Arnaud Le Hors, IBM @author Andy Clark, IBM
mf.org.apache.xerces.xni.parser.XMLParserConfiguration
Represents a parser configuration. The parser configuration maintains a table of recognized features and properties, assembles components for the parsing pipeline, and is responsible for initiating parsing of an XML document.
By separating the configuration of a parser from the specific parser instance, applications can create new configurations and re-use the existing parser components and external API generators (e.g. the DOMParser and SAXParser).
The internals of any specific parser configuration instance are hidden. Therefore, each configuration may implement the parsing mechanism any way necessary. However, the parser configuration should follow these guidelines:
- Call the reset method on each component before parsing. This is only required if the configuration is re-using existing components that conform to the XMLComponent interface. If the configuration uses all custom parts, then it is free to implement everything as it sees fit as long as it follows the other guidelines.
- Call the setFeature and setProperty method on each component during parsing to propagate features and properties that have changed. This is only required if the configuration is re-using existing components that conform to the XMLComponent interface. If the configuration uses all custom parts, then it is free to implement everything as it sees fit as long as it follows the other guidelines.
- Pass the same unique String references for all symbols that are propagated to the registered handlers. Symbols include, but may not be limited to, the names of elements and attributes (including their uri, prefix, and localpart). This is suggested but not an absolute must. However, the standard parser components may require access to the same symbol table for creation of unique symbol references to be propagated in the XNI pipeline.
@author Arnaud Le Hors, IBM @author Andy Clark, IBM @version $Id: XMLParserConfiguration.java 699892 2008-09-28 21:08:27Z mrglavas $
org.apache.xerces.xni.parser.XMLParserConfiguration
Represents a parser configuration. The parser configuration maintains a table of recognized features and properties, assembles components for the parsing pipeline, and is responsible for initiating parsing of an XML document.
By separating the configuration of a parser from the specific parser instance, applications can create new configurations and re-use the existing parser components and external API generators (e.g. the DOMParser and SAXParser).
The internals of any specific parser configuration instance are hidden. Therefore, each configuration may implement the parsing mechanism any way necessary. However, the parser configuration should follow these guidelines:
- Call the reset method on each component before parsing. This is only required if the configuration is re-using existing components that conform to the XMLComponent interface. If the configuration uses all custom parts, then it is free to implement everything as it sees fit as long as it follows the other guidelines.
- Call the setFeature and setProperty method on each component during parsing to propagate features and properties that have changed. This is only required if the configuration is re-using existing components that conform to the XMLComponent interface. If the configuration uses all custom parts, then it is free to implement everything as it sees fit as long as it follows the other guidelines.
- Pass the same unique String references for all symbols that are propagated to the registered handlers. Symbols include, but may not be limited to, the names of elements and attributes (including their uri, prefix, and localpart). This is suggested but not an absolute must. However, the standard parser components may require access to the same symbol table for creation of unique symbol references to be propagated in the XNI pipeline.
@author Arnaud Le Hors, IBM @author Andy Clark, IBM @version $Id: XMLParserConfiguration.java,v 1.3 2001/10/01 10:13:21 andyc Exp $

Examples of org.apache.xerces.xni.parser.XMLParserConfiguration

        }


        // variables
        PrintWriter out = new PrintWriter(System.out);
        XMLDocumentParser parser = null;
        XMLParserConfiguration parserConfig = null;
        int repetition = DEFAULT_REPETITION;
        boolean namespaces = DEFAULT_NAMESPACES;
        boolean namespacePrefixes = DEFAULT_NAMESPACE_PREFIXES;
        boolean validation = DEFAULT_VALIDATION;
        boolean schemaValidation = DEFAULT_SCHEMA_VALIDATION;
        boolean schemaFullChecking = DEFAULT_SCHEMA_FULL_CHECKING;
        boolean memoryUsage = DEFAULT_MEMORY_USAGE;
        boolean tagginess = DEFAULT_TAGGINESS;


        // process arguments
        for (int i = 0; i < argv.length; i++) {
            String arg = argv[i];
            if (arg.startsWith("-")) {
                String option = arg.substring(1);
                if (option.equals("p")) {
                    // get parser name
                    if (++i == argv.length) {
                        System.err.println("error: Missing argument to -p option.");
                        continue;
                    }
                    String parserName = argv[i];


                    // create parser
                    try {
                        parserConfig = (XMLParserConfiguration)ObjectFactory.newInstance(parserName,
                            ObjectFactory.findClassLoader(), true);
                        parserConfig.addRecognizedFeatures(new String[] {
                            NAMESPACE_PREFIXES_FEATURE_ID,
                        });
                        parser = null;
                    }
                    catch (Exception e) {
                        parserConfig = null;
                        System.err.println("error: Unable to instantiate parser configuration ("+parserName+")");
                    }
                    continue;
                }
                if (option.equals("x")) {
                    if (++i == argv.length) {
                        System.err.println("error: Missing argument to -x option.");
                        continue;
                    }
                    String number = argv[i];
                    try {
                        int value = Integer.parseInt(number);
                        if (value < 1) {
                            System.err.println("error: Repetition must be at least 1.");
                            continue;
                        }
                        repetition = value;
                    }
                    catch (NumberFormatException e) {
                        System.err.println("error: invalid number ("+number+").");
                    }
                    continue;
                }
                if (option.equalsIgnoreCase("n")) {
                    namespaces = option.equals("n");
                    continue;
                }
                if (option.equalsIgnoreCase("np")) {
                    namespacePrefixes = option.equals("np");
                    continue;
                }
                if (option.equalsIgnoreCase("v")) {
                    validation = option.equals("v");
                    continue;
                }
                if (option.equalsIgnoreCase("s")) {
                    schemaValidation = option.equals("s");
                    continue;
                }
                if (option.equalsIgnoreCase("f")) {
                    schemaFullChecking = option.equals("f");
                    continue;
                }
                if (option.equalsIgnoreCase("m")) {
                    memoryUsage = option.equals("m");
                    continue;
                }
                if (option.equalsIgnoreCase("t")) {
                    tagginess = option.equals("t");
                    continue;
                }
                if (option.equals("-rem")) {
                    if (++i == argv.length) {
                        System.err.println("error: Missing argument to -# option.");
                        continue;
                    }
                    System.out.print("# ");
                    System.out.println(argv[i]);
                    continue;
                }
                if (option.equals("h")) {
                    printUsage();
                    continue;
                }
                System.err.println("error: unknown option ("+option+").");
                continue;
            }


            // use default parser?
            if (parserConfig == null) {


                // create parser
                try {
                    parserConfig = (XMLParserConfiguration)ObjectFactory.newInstance(DEFAULT_PARSER_CONFIG,
                        ObjectFactory.findClassLoader(), true);
                    parserConfig.addRecognizedFeatures(new String[] {
                        NAMESPACE_PREFIXES_FEATURE_ID,
                    });
                }
                catch (Exception e) {
                    System.err.println("error: Unable to instantiate parser configuration ("+DEFAULT_PARSER_CONFIG+")");
                    continue;
                }
            }


            // set parser features
            if (parser == null) {
                parser = new Counter(parserConfig);
            }
            try {
                parserConfig.setFeature(NAMESPACES_FEATURE_ID, namespaces);
            }
            catch (XMLConfigurationException e) {
                System.err.println("warning: Parser does not support feature ("+NAMESPACES_FEATURE_ID+")");
            }
            try {
                parserConfig.setFeature(VALIDATION_FEATURE_ID, validation);
            }
            catch (XMLConfigurationException e) {
                System.err.println("warning: Parser does not support feature ("+VALIDATION_FEATURE_ID+")");
            }
            try {
                parserConfig.setFeature(SCHEMA_VALIDATION_FEATURE_ID, schemaValidation);
            }
            catch (XMLConfigurationException e) {
                if (e.getType() == XMLConfigurationException.NOT_SUPPORTED) {
                    System.err.println("warning: Parser does not support feature ("+SCHEMA_VALIDATION_FEATURE_ID+")");
                }
            }
            try {
                parserConfig.setFeature(SCHEMA_FULL_CHECKING_FEATURE_ID, schemaFullChecking);
            }
            catch (XMLConfigurationException e) {
                if (e.getType() == XMLConfigurationException.NOT_SUPPORTED) {
                    System.err.println("warning: Parser does not support feature ("+SCHEMA_FULL_CHECKING_FEATURE_ID+")");
                }

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.