How to use

PackageDependencySpec

in

org.jboss.galleon.spec

@SuppressWarnings("unchecked")
public T addPackageDep(PackageDependencySpec dep) {
  localPkgDeps = CollectionUtils.putLinked(localPkgDeps, dep.getName(), dep);
  if(!dep.isOptional()) {
    ++requiredDeps;
  }
  return (T) this;
}

/**
 * Creates an optional dependency on the package.
 *
 * @param name  target package name
 * @return  dependency spec
 */
public static PackageDependencySpec optional(String name) {
  return new PackageDependencySpec(name, OPTIONAL);
}

public static PackageDependencySpec newInstance(String packageName, int type) throws ProvisioningDescriptionException {
  switch(type) {
    case PackageDependencySpec.OPTIONAL:
      return PackageDependencySpec.optional(packageName);
    case PackageDependencySpec.PASSIVE:
      return PackageDependencySpec.passive(packageName);
    case PackageDependencySpec.REQUIRED:
      return PackageDependencySpec.required(packageName);
    default:
      throw new ProvisioningDescriptionException(Errors.unexpectedPackageDependencyType(packageName, type));
  }
}

public T addPackageDep(String packageName, boolean optional) {
  return addPackageDep(optional ? PackageDependencySpec.optional(packageName) : PackageDependencySpec.required(packageName));
}

  private static void writePackageDependency(ElementNode deps, PackageDependencySpec depSpec, String ns) {
    final ElementNode depElement = addElement(deps, PackageDepsSpecXmlParser.PACKAGE, ns);
    addAttribute(depElement, Attribute.NAME, depSpec.getName());
    if(depSpec.isOptional()) {
      if(depSpec.isPassive()) {
        addAttribute(depElement, PackageDepsSpecXmlParser.Attribute.PASSIVE, TRUE);
      } else {
        addAttribute(depElement, PackageDepsSpecXmlParser.Attribute.OPTIONAL, TRUE);
      }
    }
  }
}

void processPackageDeps(final PackageDepsSpec pkgDeps, PackageRuntime.Builder parent) throws ProvisioningException {
  if (pkgDeps.hasLocalPackageDeps()) {
    for (PackageDependencySpec dep : pkgDeps.getLocalPackageDeps()) {
      if(fpConfigStack.isPackageExcluded(currentOrigin.producer, dep.getName())) {
        if(!dep.isOptional()) {
          throw new UnsatisfiedPackageDependencyException(currentOrigin.getFPID(), dep.getName());
      if ((pkgDepMask & dep.getType()) > 0) {
        resolvePackage(dep.getName(), parent, dep.getType());
    try {
      for (PackageDependencySpec dep : pkgDeps.getExternalPackageDeps(origin)) {
        if (fpConfigStack.isPackageExcluded(currentOrigin.producer, dep.getName())) {
          if (!dep.isOptional()) {
            throw new UnsatisfiedPackageDependencyException(currentOrigin.getFPID(), dep.getName());
        if ((pkgDepMask & dep.getType()) > 0) {
          resolvePackage(dep.getName(), parent, dep.getType());

if (pkg.hasLocalPackageDeps()) {
  for(PackageDependencySpec pkgDep : pkg.getLocalPackageDeps()) {
    final PackageSpec depSpec = packages.get(pkgDep.getName());
    if(depSpec == null) {
      if(notFound.isEmpty()) {
        notFound = new ArrayList<>();
      notFound.add(pkgDep.getName());

@Override
public String toString() {
  final StringBuilder buf = new StringBuilder();
  buf.append('[').append(name);
  if(isOptional()) {
    buf.append(type == OPTIONAL ? " optional" : " passive");
  }
  return buf.append(']').toString();
}

public T addPackageDep(String origin, String packageName, int type) throws ProvisioningDescriptionException {
  return addPackageDep(origin, PackageDependencySpec.newInstance(packageName, type));
}

boolean featureEnabled = true;
for (PackageDependencySpec p : spec.getLocalPackageDeps()) {
  Identity identity = Identity.fromChannel(resolved.getProducer(), p.getName());
  Group grp = allPackages.get(identity);
    Identity identity = Identity.fromString(o, p.getName());
    Group grp = allPackages.get(identity);
    if (grp != null) {

public T addPackageDep(String origin, String packageName, boolean optional) {
  return addPackageDep(origin, optional ? PackageDependencySpec.optional(packageName) : PackageDependencySpec.required(packageName));
}

if(PackageDependencySpec.isOptional(type)) {
  return;

public T addPackageDep(String packageName, int type) throws ProvisioningDescriptionException {
  return addPackageDep(PackageDependencySpec.newInstance(packageName, type));
}

    throw new XMLStreamException(Errors.requiredPassiveDependency(name), reader.getLocation());
  return PackageDependencySpec.passive(name);
return optional == null || !optional ? PackageDependencySpec.required(name) : PackageDependencySpec.optional(name);

  return addPackageDep(dep);
if(!dep.isOptional()) {
  ++requiredDeps;
  externalPkgDeps = CollectionUtils.put(externalPkgDeps, origin, Collections.singletonMap(dep.getName(), dep));
  return (T) this;
  if(deps.containsKey(dep.getName())) {
    deps = Collections.singletonMap(origin, dep);
  } else {
    deps = new HashMap<>(2);
    deps.put(first.getKey(), first.getValue());
    deps.put(dep.getName(), dep);
deps.put(dep.getName(), dep);
return (T) this;

  private void buildGroups(Group grp, PackageInfo pkg, PackageInfoBuilder builder) {
    Group gp = allPackagesGroups.get(pkg.getIdentity());
    if (gp == null) {
      gp = Group.fromIdentity(pkg.getIdentity());
      allPackagesGroups.put(pkg.getIdentity(), gp);
      gp.setPackage(pkg);

      for (PackageDependencySpec s : pkg.getSpec().getLocalPackageDeps()) {
        buildGroups(gp, builder.build(Identity.fromString(s.getName()), pkg), builder);
      }
      for (String o : pkg.getSpec().getPackageOrigins()) {
        for (PackageDependencySpec p : pkg.getSpec().getExternalPackageDeps(o)) {
          buildGroups(gp, builder.build(Identity.fromString(o, p.getName()), pkg), builder);
        }
      }
    }
    grp.addGroup(gp);
  }
}

/**
 * Creates a passive dependency on the package.
 *
 * @param name  target package name
 * @return  dependency spec
 */
public static PackageDependencySpec passive(String name) {
  return new PackageDependencySpec(name, PASSIVE);
}

/**
 * Creates a required dependency on the package.
 *
 * @param name  target package name
 * @return  dependency spec
 */
public static PackageDependencySpec required(String name) {
  return new PackageDependencySpec(name, REQUIRED);
}