aQute.bnd.osgi.Packages Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of biz.aQute.bndlib Show documentation
Show all versions of biz.aQute.bndlib Show documentation
bndlib: A Swiss Army Knife for OSGi
package aQute.bnd.osgi;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import aQute.bnd.header.Attrs;
import aQute.bnd.osgi.Descriptors.PackageRef;
public class Packages implements Map {
private LinkedHashMap map;
static Map EMPTY = Collections.emptyMap();
public static enum QUERY {
ANY, ANNOTATED, NAMED, VERSIONED
}
public Packages(Packages other) {
if (other.map != null) {
map = new LinkedHashMap(other.map);
}
}
public Packages() {}
public void clear() {
if (map != null)
map.clear();
}
public boolean containsKey(PackageRef name) {
if (map == null)
return false;
return map.containsKey(name);
}
@Deprecated
public boolean containsKey(Object name) {
assert name instanceof PackageRef;
if (map == null)
return false;
return map.containsKey(name);
}
public boolean containsValue(Attrs value) {
if (map == null)
return false;
return map.containsValue(value);
}
@Deprecated
public boolean containsValue(Object value) {
assert value instanceof Attrs;
if (map == null)
return false;
return map.containsValue(value);
}
public Set> entrySet() {
if (map == null)
return EMPTY.entrySet();
return map.entrySet();
}
@Deprecated
public Attrs get(Object key) {
assert key instanceof PackageRef;
if (map == null)
return null;
return map.get(key);
}
public Attrs get(PackageRef key) {
if (map == null)
return null;
return map.get(key);
}
public boolean isEmpty() {
return map == null || map.isEmpty();
}
public Set keySet() {
if (map == null)
return EMPTY.keySet();
return map.keySet();
}
public Attrs put(PackageRef ref) {
Attrs attrs = get(ref);
if (attrs != null)
return attrs;
attrs = new Attrs();
put(ref, attrs);
return attrs;
}
public Attrs put(PackageRef key, Attrs value) {
if (map == null)
map = new LinkedHashMap();
return map.put(key, value);
}
public void putAll(Map< ? extends PackageRef, ? extends Attrs> map) {
if (this.map == null) {
if (map.isEmpty())
return;
this.map = new LinkedHashMap();
}
this.map.putAll(map);
}
public void putAllIfAbsent(Map map) {
for (Map.Entry entry : map.entrySet()) {
if (!containsKey(entry.getKey()))
put(entry.getKey(), entry.getValue());
}
}
@Deprecated
public Attrs remove(Object var0) {
assert var0 instanceof PackageRef;
if (map == null)
return null;
return map.remove(var0);
}
public Attrs remove(PackageRef var0) {
if (map == null)
return null;
return map.remove(var0);
}
public int size() {
if (map == null)
return 0;
return map.size();
}
public Collection values() {
if (map == null)
return EMPTY.values();
return map.values();
}
public Attrs getByFQN(String s) {
if (map == null)
return null;
for (Map.Entry pr : map.entrySet()) {
if (pr.getKey().getFQN().equals(s))
return pr.getValue();
}
return null;
}
public Attrs getByBinaryName(String s) {
if (map == null)
return null;
for (Map.Entry pr : map.entrySet()) {
if (pr.getKey().getBinary().equals(s))
return pr.getValue();
}
return null;
}
public boolean containsFQN(String s) {
return getByFQN(s) != null;
}
public boolean containsBinaryName(String s) {
return getByBinaryName(s) != null;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
append(sb);
return sb.toString();
}
public void append(StringBuilder sb) {
String del = "";
for (Map.Entry s : entrySet()) {
sb.append(del);
sb.append(s.getKey());
if (!s.getValue().isEmpty()) {
sb.append(';');
s.getValue().append(sb);
}
del = ",";
}
}
public void merge(PackageRef ref, boolean unique, Attrs... attrs) {
if (unique) {
while (containsKey(ref))
ref = ref.getDuplicate();
}
Attrs org = put(ref);
for (Attrs a : attrs) {
if (a != null)
org.putAll(a);
}
}
public Attrs get(PackageRef packageRef, Attrs deflt) {
Attrs mine = get(packageRef);
if (mine != null)
return mine;
return deflt;
}
@Override
@Deprecated
public boolean equals(Object other) {
return super.equals(other);
}
@Override
@Deprecated
public int hashCode() {
return super.hashCode();
}
}