fromUri static method

Future fromUri(String uri, { bool parseCharacterEntities = true, bool parseComments = false, bool trimWhitespace = true, bool parseCdataAsText = true, List<Type>? returnNodesOfType, int start = 0, int? stop, })

Retrieves a document from uri, parses it, and returns all identified XML nodes in a list.

If parseCharacterEntities is true, text values will be parsed and replace all encoded character entities with their corresponding character. parseCharacterEntities must not be null.

If parseComments is true, commments will be scrubbed from string before parsing.

If trimWhitespace is true, unnecessary whitespace between nodes will be removed and all remaining whitespace will be replaced with a single space. trimWhitespace must not be null.

If returnNodesOfType is not null, only the nodes of the types contained in returnNodesOfType will be returned, otherwise, all nodes, regardless of type, will be returned.

start and stop refer to the indexes of the identified nodes. Only matches found between start and stop will be returned. start must not be null and must be >= 0. stop may be null, but must be >= start if provided.

Returns null if the uri can't be reached or no valid XML nodes are found in the returned document.

Implementation

static Future<dynamic?> fromUri(
  String uri, {
  bool parseCharacterEntities = true,
  bool parseComments = false,
  bool trimWhitespace = true,
  bool parseCdataAsText = true,
  List<Type>? returnNodesOfType,
  int start = 0,
  int? stop,
}) async {
  assert(start >= 0);
  assert(stop == null || stop >= start);

  final response = await get(Uri.parse(uri));
  if (response.statusCode != 200) {
    return null;
  }

  final document = response.body;

  if (returnNodesOfType != null) {
    if (returnNodesOfType.length == 1) {
      final nodeType = returnNodesOfType.first;

      if (nodeType == XmlDocument) {
        return XmlDocument.from(
          document,
          parseCharacterEntities: parseCharacterEntities,
          parseComments: parseComments,
          trimWhitespace: trimWhitespace,
          parseCdataAsText: parseCdataAsText,
        );
      } else if (nodeType == XmlAttlist) {
        return XmlAttlist.parseString(
          document,
          trimWhitespace: trimWhitespace,
          start: start,
          stop: stop,
        );
      } else if (nodeType == XmlEtd) {
        return XmlEtd.parseString(
          document,
          trimWhitespace: trimWhitespace,
          start: start,
          stop: stop,
        );
      } else if (nodeType == XmlComment) {
        return XmlComment.parseString(
          document,
          parseCharacterEntities: parseCharacterEntities,
          trimWhitespace: trimWhitespace,
          start: start,
          stop: stop,
        );
      } else if (nodeType == XmlConditional) {
        return XmlConditional.parseString(
          document,
          parseCharacterEntities: parseCharacterEntities,
          parseComments: parseComments,
          trimWhitespace: trimWhitespace,
          parseCdataAsText: parseCdataAsText,
          start: start,
          stop: stop,
        );
      } else if (nodeType == XmlDoctype) {
        return XmlDoctype.parseString(
          document,
          parseCharacterEntities: parseCharacterEntities,
          parseComments: parseComments,
          trimWhitespace: trimWhitespace,
          parseCdataAsText: parseCdataAsText,
          start: start,
          stop: stop,
        );
      } else if (nodeType == XmlElement) {
        return XmlElement.parseString(
          document,
          parseCharacterEntities: parseCharacterEntities,
          parseComments: parseComments,
          trimWhitespace: trimWhitespace,
          parseCdataAsText: parseCdataAsText,
          start: start,
          stop: stop,
        );
      } else if (nodeType == XmlEntity) {
        return XmlEntity.parseString(
          document,
          trimWhitespace: trimWhitespace,
          start: start,
          stop: stop,
        );
      } else if (nodeType == XmlNotation) {
        return XmlNotation.parseString(
          document,
          trimWhitespace: trimWhitespace,
          start: start,
          stop: stop,
        );
      } else if (nodeType == XmlProcessingInstruction) {
        return XmlProcessingInstruction.parseString(
          document,
          trimWhitespace: trimWhitespace,
          start: start,
          stop: stop,
        );
      } else if (nodeType == XmlText) {
        return XmlText.parseString(
          document,
          trimWhitespace: trimWhitespace,
          start: start,
          stop: stop,
        );
      }
    }
  }

  return XmlNode.parseString(
    document,
    parseCharacterEntities: parseCharacterEntities,
    parseComments: parseComments,
    trimWhitespace: trimWhitespace,
    parseCdataAsText: parseCdataAsText,
    returnNodesOfType: returnNodesOfType,
    start: start,
    stop: stop,
  );
}