Flud+ v1.11.1.2版本的 MD5 值为：8801c2f52bfd51902dee3a73c65b73f8

以下内容为反编译后的 WireFeedInput.java 源代码，内容仅作参考

package com.rometools.rome.io;

import com.rometools.rome.feed.WireFeed;
import com.rometools.rome.feed.impl.ConfigurableClassLoader;
import com.rometools.rome.io.impl.FeedParsers;
import com.rometools.rome.io.impl.XmlFixerReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.WeakHashMap;
import org.jdom2.JDOMException;
import org.jdom2.input.JDOMParseException;
import org.w3c.dom.Document;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.XMLReader;
import s2.YeuH.coEcUdmLw;
import sa.l;
import sa.n;
import t1.BXM.LFQgKHPqf;
import wa.k;
public class WireFeedInput {
    private static final InputSource EMPTY_INPUTSOURCE = new InputSource(new ByteArrayInputStream(new byte[0]));
    private static final EntityResolver RESOLVER = new EmptyEntityResolver();
    private static Map<ClassLoader, FeedParsers> clMap = new WeakHashMap();
    private boolean allowDoctypes;
    private final Locale locale;
    private final boolean validate;
    private boolean xmlHealerOn;

    public static class EmptyEntityResolver implements EntityResolver {
        private EmptyEntityResolver() {
        }

        @Override
        public InputSource resolveEntity(String str, String str2) {
            if (str2 == null || !str2.endsWith(".dtd")) {
                return null;
            }
            return WireFeedInput.EMPTY_INPUTSOURCE;
        }
    }

    public WireFeedInput() {
        this(false, Locale.US);
    }

    public WireFeedInput(boolean z10, Locale locale) {
        this.allowDoctypes = false;
        this.validate = false;
        this.xmlHealerOn = true;
        this.locale = locale;
    }

    private static FeedParsers getFeedParsers() {
        FeedParsers feedParsers;
        synchronized (WireFeedInput.class) {
            try {
                ClassLoader classLoader = ConfigurableClassLoader.INSTANCE.getClassLoader();
                feedParsers = clMap.get(classLoader);
                if (feedParsers == null) {
                    feedParsers = new FeedParsers();
                    clMap.put(classLoader, feedParsers);
                }
            } catch (Throwable th) {
                throw th;
            }
        }
        return feedParsers;
    }

    public static List<String> getSupportedFeedTypes() {
        return getFeedParsers().getSupportedFeedTypes();
    }

    private boolean isFeatureSupported(XMLReader xMLReader, String str, boolean z10) {
        try {
            xMLReader.setFeature(str, z10);
            return true;
        } catch (SAXNotRecognizedException | SAXNotSupportedException unused) {
            return false;
        }
    }

    private void setFeature(SAXBuilder sAXBuilder, XMLReader xMLReader, String str, boolean z10) {
        if (isFeatureSupported(xMLReader, str, z10)) {
            sAXBuilder.setFeature(str, z10);
        }
    }

    public WireFeed build(File file) {
        Reader fileReader = new FileReader(file);
        try {
            if (this.xmlHealerOn) {
                fileReader = new XmlFixerReader(fileReader);
            }
            WireFeed build = build(fileReader);
            fileReader.close();
            return build;
        } catch (Throwable th) {
            fileReader.close();
            throw th;
        }
    }

    public WireFeed build(Reader reader) {
        SAXBuilder createSAXBuilder = createSAXBuilder();
        try {
            if (this.xmlHealerOn) {
                reader = new XmlFixerReader(reader);
            }
            return build(createSAXBuilder.build(reader));
        } catch (IllegalArgumentException e10) {
            throw e10;
        } catch (JDOMParseException e11) {
            throw new ParsingFeedException("Invalid XML: " + e11.getMessage(), e11);
        } catch (Exception e12) {
            throw new ParsingFeedException("Invalid XML", e12);
        }
    }

    public WireFeed build(Document document) {
        ?? obj = new Object();
        obj.f3911j = new l(0);
        try {
            n nVar = new n(null);
            obj.m(document, nVar, null, true);
            return build(nVar);
        } catch (IllegalArgumentException e10) {
            throw e10;
        } catch (Exception e11) {
            throw new ParsingFeedException("Invalid XML", e11);
        }
    }

    public WireFeed build(InputSource inputSource) {
        try {
            return build(createSAXBuilder().build(inputSource));
        } catch (IllegalArgumentException e10) {
            throw e10;
        } catch (JDOMParseException e11) {
            throw new ParsingFeedException("Invalid XML: " + e11.getMessage(), e11);
        } catch (Exception e12) {
            throw new ParsingFeedException(coEcUdmLw.vcvx, e12);
        }
    }

    public WireFeed build(n nVar) {
        WireFeedParser parserFor = getFeedParsers().getParserFor(nVar);
        if (parserFor != null) {
            return parserFor.parse(nVar, this.validate, this.locale);
        }
        throw new IllegalArgumentException("Invalid document");
    }

    public SAXBuilder createSAXBuilder() {
        SAXBuilder sAXBuilder = this.validate ? new SAXBuilder(k.f14075l) : new SAXBuilder(k.f14074k);
        sAXBuilder.setEntityResolver(RESOLVER);
        try {
            XMLReader createParser = sAXBuilder.createParser();
            setFeature(sAXBuilder, createParser, LFQgKHPqf.NJEkdNOan, false);
            setFeature(sAXBuilder, createParser, "http://xml.org/sax/features/external-parameter-entities", false);
            setFeature(sAXBuilder, createParser, "http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
            if (!this.allowDoctypes) {
                setFeature(sAXBuilder, createParser, "http://apache.org/xml/features/disallow-doctype-decl", true);
            }
            sAXBuilder.setExpandEntities(false);
            return sAXBuilder;
        } catch (JDOMException e10) {
            throw new IllegalStateException("JDOM could not create a SAX parser", e10);
        }
    }

    public boolean getXmlHealerOn() {
        return this.xmlHealerOn;
    }

    public boolean isAllowDoctypes() {
        return this.allowDoctypes;
    }

    public void setAllowDoctypes(boolean z10) {
        this.allowDoctypes = z10;
    }

    public void setXmlHealerOn(boolean z10) {
        this.xmlHealerOn = z10;
    }
}