private void parse(InputStream stream, ContentHandler handler,
                       ContentHandlerFactory handlerFactory, Metadata originalMetadata,
                       ParseContext context) throws IOException, SAXException, TikaException {
        // Track the metadata between parsers, so we can apply our policy
        Metadata lastMetadata = cloneMetadata(originalMetadata);
        Metadata metadata = lastMetadata;

        // Start tracking resources, so we can clean up when done
        TemporaryResources tmp = new TemporaryResources();
        try {
            // Ensure we'll be able to re-read safely, buffering to disk if so,
            //  to permit Parsers 2+ to be able to read the same data
            InputStream taggedStream = ParserUtils.ensureStreamReReadable(stream, tmp, originalMetadata);

            for (Parser p : parsers) {
                // Get a new handler for this parser, if we can
                // If not, the user will get text from every parser
                //  mushed together onto the one solitary handler...
                if (handlerFactory != null) {
                    handler = handlerFactory.getNewContentHandler();
                }

                // Record that we used this parser
                recordParserDetails(p, originalMetadata);

                // Prepare an near-empty Metadata, will merge after
                metadata = cloneMetadata(originalMetadata);

                // Notify the implementation of what we're about to do
                parserPrepare(p, metadata, context);

                // Process if possible
                Exception failure = null;
                try {
                    p.parse(taggedStream, handler, metadata, context);
                } catch (Exception e) {
                    // Record the failure such that it can't get lost / overwritten
                    recordParserFailure(p, e, originalMetadata);
                    recordParserFailure(p, e, metadata);
                    failure = e;
                }

                // Notify the implementation how it went
                boolean tryNext = parserCompleted(p, metadata, handler, context, failure);

                // Handle metadata merging / clashes
                metadata = mergeMetadata(metadata, lastMetadata, policy);

                // Abort if requested, with the exception if there was one
                if (!tryNext) {
                    if (failure != null) {
                        if (failure instanceof IOException) {
                            throw (IOException) failure;
                        }
                        if (failure instanceof SAXException) {
                            throw (SAXException) failure;
                        }
                        if (failure instanceof TikaException) {
                            throw (TikaException) failure;
                        }
                        throw new TikaException("Unexpected RuntimeException from " + p, failure);
                    }
                    // Abort processing, don't try any more parsers
                    break;
                }

                // Prepare for the next parser, if present
                lastMetadata = cloneMetadata(metadata);
                taggedStream = ParserUtils.streamResetForReRead(taggedStream, tmp);
            }
        } finally {
            tmp.dispose();
        }

        // Finally, copy the latest metadata back onto their supplied object
        for (String n : metadata.names()) {
            originalMetadata.remove(n);
            for (String val : metadata.getValues(n)) {
                originalMetadata.add(n, val);
            }
        }
    }
Processes the given Stream through one or more parsers,
resetting things between parsers as requested by policy.
The actual processing is delegated to one or more {@link Parser}s.
You will get one ContentHandler fetched for each Parser used.
TODO Do we need to return all the ContentHandler instances we created?

@deprecated The {@link ContentHandlerFactory} override is still experimental
and the method signature is subject to change before Tika 2.0
tika-core/src/main/java/org/apache/tika/parser/multiple/AbstractMultipleParser.java