/**
   * Resolves an identifier using the catalog. This method interprets that the namespace of the
   * identifier corresponds to uri entries in the catalog. Where both a namespace and an external
   * identifier exist, the namespace takes precedence.
   *
   * @param resourceIdentifier the identifier to resolve
   * @throws XNIException thrown on general error
   * @throws IOException thrown if some i/o error occurs
   */
  public String resolveIdentifier(XMLResourceIdentifier resourceIdentifier)
      throws IOException, XNIException {

    String resolvedId = null;

    // The namespace is useful for resolving namespace aware
    // grammars such as XML schema. Let it take precedence over
    // the external identifier if one exists.
    String namespace = resourceIdentifier.getNamespace();
    if (namespace != null) {
      resolvedId = resolveURI(namespace);
    }

    // Resolve against an external identifier if one exists. This
    // is useful for resolving DTD external subsets and other
    // external entities. For XML schemas if there was no namespace
    // mapping we might be able to resolve a system identifier
    // specified as a location hint.
    if (resolvedId == null) {
      String publicId = resourceIdentifier.getPublicId();
      String systemId =
          getUseLiteralSystemId()
              ? resourceIdentifier.getLiteralSystemId()
              : resourceIdentifier.getExpandedSystemId();
      if (publicId != null && systemId != null) {
        resolvedId = resolvePublic(publicId, systemId);
      } else if (systemId != null) {
        resolvedId = resolveSystem(systemId);
      }
    }
    return resolvedId;
  }
  /**
   * Resolves an external parsed entity. If the entity cannot be resolved, this method should return
   * null.
   *
   * @param resourceIdentifier description of the resource to be revsoved
   * @throws XNIException Thrown on general error.
   * @throws IOException Thrown if resolved entity stream cannot be opened or some other i/o error
   *     occurs.
   */
  public XMLInputSource resolveEntity(XMLResourceIdentifier resourceIdentifier)
      throws XNIException, IOException {
    // resolve entity using DOM entity resolver
    if (fEntityResolver != null) {
      // For entity resolution the type of the resource would be  XML TYPE
      // DOM L3 LS spec mention only the XML 1.0 recommendation right now
      LSInput inputSource =
          resourceIdentifier == null
              ? fEntityResolver.resolveResource(null, null, null, null, null)
              : fEntityResolver.resolveResource(
                  getType(resourceIdentifier),
                  resourceIdentifier.getNamespace(),
                  resourceIdentifier.getPublicId(),
                  resourceIdentifier.getLiteralSystemId(),
                  resourceIdentifier.getBaseSystemId());
      if (inputSource != null) {
        String publicId = inputSource.getPublicId();
        String systemId = inputSource.getSystemId();
        String baseSystemId = inputSource.getBaseURI();
        InputStream byteStream = inputSource.getByteStream();
        Reader charStream = inputSource.getCharacterStream();
        String encoding = inputSource.getEncoding();
        String data = inputSource.getStringData();

        /**
         * An LSParser looks at inputs specified in LSInput in the following order: characterStream,
         * byteStream, stringData, systemId, publicId.
         */
        XMLInputSource xmlInputSource = new XMLInputSource(publicId, systemId, baseSystemId);

        if (charStream != null) {
          xmlInputSource.setCharacterStream(charStream);
        } else if (byteStream != null) {
          xmlInputSource.setByteStream((InputStream) byteStream);
        } else if (data != null && data.length() != 0) {
          xmlInputSource.setCharacterStream(new StringReader(data));
        }
        xmlInputSource.setEncoding(encoding);
        return xmlInputSource;
      }
    }

    // unable to resolve entity
    return null;
  } // resolveEntity(String,String,String):XMLInputSource
  /**
   * Constructs an input source from a XMLResourceIdentifier object, leaving resolution of the
   * entity and opening of the input stream up to the caller.
   *
   * @param resourceIdentifier the XMLResourceIdentifier containing the information
   */
  public XMLInputSource(XMLResourceIdentifier resourceIdentifier) {

    fPublicId = resourceIdentifier.getPublicId();
    fSystemId = resourceIdentifier.getLiteralSystemId();
    fBaseSystemId = resourceIdentifier.getBaseSystemId();
  } // <init>(XMLResourceIdentifier)
 // Constructors:
 public XMLDTDDescription(XMLResourceIdentifier id, String rootName) {
   this.setValues(
       id.getPublicId(), id.getLiteralSystemId(), id.getBaseSystemId(), id.getExpandedSystemId());
   this.fRootName = rootName;
   this.fPossibleRoots = null;
 } // init(XMLResourceIdentifier, String)