private void createIncludeDirectives(
final DefaultModule module, final List<IncludeDirective> list, final Category category) {
DefaultResource[] providers = getDefaultProviders(Scope.RUNTIME, true, category);
for (int i = 0; i < providers.length; i++) {
DefaultResource provider = providers[i];
if (provider.isaDescendant(module)) {
// create a ref
String path = provider.getResourcePath();
IncludeDirective include = new IncludeDirective(IncludeDirective.REF, category, path, null);
if (!list.contains(include)) {
list.add(include);
}
} else {
// create a urn
Type[] types = provider.getTypes();
for (int j = 0; j < types.length; j++) {
Type type = types[j];
String label = type.getID();
Artifact artifact = type.getArtifact();
String urn = artifact.toString();
IncludeDirective include =
new IncludeDirective(IncludeDirective.URI, category, urn, null);
if (!list.contains(include)) {
list.add(include);
}
}
}
}
}
/**
* Return a resource type relative to a supplied type id.
*
* @param id the type name to retrieve
* @return the type instance
* @exception IllegalArgumentException if the id value does not match a type produced by the
* resource.
*/
public Type getType(final String id) throws IllegalArgumentException {
boolean flag = id.indexOf('#') > -1;
if (flag) {
for (int i = 0; i < m_types.length; i++) {
Type type = m_types[i];
if (type.getCompoundName().equals(id)) {
return type;
}
}
} else {
for (int i = 0; i < m_types.length; i++) {
Type type = m_types[i];
if (type.getID().equals(id)) {
return type;
}
}
}
final String error =
"Type name ["
+ id
+ "] not recognized with the scope of resource ["
+ getResourcePath()
+ "].";
throw new IllegalArgumentException(error);
}
/**
* Utility function supporting resolution of uris containing 'resource' or 'alias' schemes. If the
* supplied uri schem is 'resource' or 'alias' the reference is resolved to a artifact type, group
* and name from which a resource is resolved and the uri returned. If the scheme is resource the
* usri of the resource is returned. If the scheme is 'alias' a linkn alias is returned. If the
* scheme is not 'resource' or 'alias' the argument will be evaluated as a normal transit artifact
* uri specification.
*
* @param ref the uri argument
* @return the uri value
* @exception URISyntaxException if an error occurs during uri creation
*/
public URI toURI(final String ref) throws URISyntaxException {
Artifact spec = Artifact.createArtifact(ref);
if (spec.isRecognized()) {
return spec.toURI();
} else if (ref.startsWith("resource:") || ref.startsWith("alias:")) {
String type = spec.getType();
String group = spec.getGroup();
String name = spec.getName();
String path = group + "/" + name;
Library library = getLibrary();
try {
Resource resource = library.getResource(path);
Type t = resource.getType(type);
if (ref.startsWith("resource:")) {
Artifact artifact = t.getArtifact();
return artifact.toURI();
} else {
Artifact artifact = t.getLinkArtifact();
return artifact.toURI();
}
} catch (ResourceNotFoundException e) {
final String error = "Unresolvable resource reference: " + path;
IllegalArgumentException iae = new IllegalArgumentException(error);
iae.initCause(e);
throw iae;
}
} else {
return spec.toURI();
}
}
/**
* Test if this resource is associated with a type of the supplied name.
*
* @param type the type id
* @return TRUE if this resource produces an artifact of the supplied type
*/
public boolean isa(final String type) {
for (int i = 0; i < m_types.length; i++) {
Type someType = m_types[i];
String name = someType.getID();
if (name.equals(type)) {
return true;
}
}
return false;
}
