How to use

XmlParsers

in

org.jboss.galleon.xml

public void parse(final Reader input, final FeaturePackSpec.Builder fpBuilder) throws XMLStreamException {
  XmlParsers.parse(input, fpBuilder);
}

public static void parse(final Reader reader, Object builder) throws XMLStreamException {
  INSTANCE.doParse(reader, builder);
}

@Override
public void plugin(XmlParsers parsers) {
  parsers.plugin(ROOT_2_0, this);
}

public static ConfigLayerSpec parseConfigLayerSpec(Path p, String model) throws ProvisioningException {
  try(BufferedReader reader = Files.newBufferedReader(p)) {
    return parseConfigLayerSpec(reader, model);
  } catch (Exception e) {
    throw new ProvisioningException(Errors.parseXml(p), e);
  }
}

ConfigLayerSpec getConfigLayer(ConfigId configId) throws ProvisioningException {
  if(layers != null) {
    final ConfigLayerSpec layer = layers.get(configId);
    if(layer != null) {
      return layer;
    }
  }
  final Path p = LayoutUtils.getLayerSpecXml(dir, configId.getModel(), configId.getName(), false);
  if (!Files.exists(p)) {
    return null;
  }
  final ConfigLayerSpec layer = XmlParsers.parseConfigLayerSpec(p, configId.getModel());
  if (layers == null) {
    layers = new HashMap<>();
  }
  layers.put(configId, layer);
  return layer;
}

  @Override
  public FeatureConfig parse(final Reader input) throws XMLStreamException {
    final FeatureConfig config = new FeatureConfig();
    XmlParsers.parse(input, config);
    return config;
  }
}

@Override
public void plugin(XmlParsers parsers) {
  parsers.plugin(ROOT_1_0, this);
}

  @Override
  public PackageSpec parse(final Reader input) throws XMLStreamException {
    final Builder pkgBuilder = PackageSpec.builder();
    XmlParsers.parse(input, pkgBuilder);
    return pkgBuilder.build();
  }
}

default void plugin(XmlParsers parsers) {
  parsers.plugin(getRoot(), this);
}

  @Override
  public ConfigModel parse(final Reader input) throws XMLStreamException, ProvisioningDescriptionException {
    final ConfigModel.Builder builder = ConfigModel.builder();
    XmlParsers.parse(input, builder);
    return builder.build();
  }
}

  @Override
  public FeatureSpec parse(final Reader input) throws XMLStreamException, ProvisioningDescriptionException {
    final FeatureSpec.Builder builder = FeatureSpec.builder();
    XmlParsers.parse(input, builder);
    return builder.build();
  }
}

  @Override
  public ProvisionedState parse(final Reader input) throws XMLStreamException {
    final ProvisionedState.Builder builder = ProvisionedState.builder();
    XmlParsers.parse(input, builder);
    return builder.build();
  }
}

  @Override
  public ProvisioningConfig parse(final Reader input) throws XMLStreamException, ProvisioningDescriptionException {
    final ProvisioningConfig.Builder builder = ProvisioningConfig.builder();
    XmlParsers.parse(input, builder);
    return builder.build();
  }
}

  @Override
  public ProvisionedConfig parse(Reader input) throws XMLStreamException, ProvisioningDescriptionException {
    final ProvisionedConfigBuilder builder = ProvisionedConfigBuilder.builder();
    XmlParsers.parse(input, builder);
    return builder.build();
  }
}

  @Override
  public ConfigLayerSpec parse(final Reader input) throws XMLStreamException,
      ProvisioningDescriptionException {
    final ConfigLayerSpec.Builder builder = ConfigLayerSpec.builder();
    XmlParsers.parse(input, builder);
    return builder.build();
  }
}

  @Override
  public FeatureGroup parse(final Reader input) throws XMLStreamException, ProvisioningDescriptionException {
    final FeatureGroup.Builder configBuilder = FeatureGroup.builder();
    XmlParsers.parse(input, configBuilder);
    return configBuilder.build();
  }
}

public static Configuration parse(Map<String, String> options) throws ProvisioningException {
  Configuration config = new Configuration();
  Path configFile = getConfigFile();
  if (Files.exists(configFile)) {
    try (BufferedReader reader = Files.newBufferedReader(configFile)) {
      XmlParsers.parse(reader, config);
    } catch (IOException | XMLStreamException e) {
      throw new ProvisioningException(Errors.parseXml(configFile), e);
    }
  }
  return config;
}

public static ConfigLayerSpec parseConfigLayerSpec(Reader reader, String model) throws ProvisioningException {
  ConfigLayerSpec.Builder builder = ConfigLayerSpec.builder();
  builder.setModel(model);
  try {
    parse(reader, builder);
  } catch (XMLStreamException e) {
    throw new ProvisioningException("Failed to parse config layer spec", e);
  }
  return builder.build();
}

public static FeaturePackDescription describeFeaturePack(Path fpDir, String encoding) throws ProvisioningDescriptionException {
  assertDirectory(fpDir);
  final Path fpXml = fpDir.resolve(Constants.FEATURE_PACK_XML);
  if(!Files.exists(fpXml)) {
    throw new ProvisioningDescriptionException(Errors.pathDoesNotExist(fpXml));
  }
  final FeaturePackDescription.Builder layoutBuilder;
  try (Reader is = Files.newBufferedReader(fpXml, Charset.forName(encoding))) {
    final FeaturePackSpec.Builder specBuilder = FeaturePackSpec.builder();
    XmlParsers.parse(is, specBuilder);
    layoutBuilder = FeaturePackDescription.builder(specBuilder);
  } catch (IOException e) {
    throw new ProvisioningDescriptionException(Errors.openFile(fpXml));
  } catch (XMLStreamException e) {
    throw new ProvisioningDescriptionException(Errors.parseXml(fpXml), e);
  }
  final Path packagesDir = fpDir.resolve(Constants.PACKAGES);
  if(Files.exists(packagesDir)) {
    processPackages(layoutBuilder, packagesDir, encoding);
  }
  return layoutBuilder.build();
}