package org.eclipse.osgi.internal.framework;
import java.lang.reflect.Array;
import java.util.*;
import org.osgi.dto.DTO;
import org.osgi.framework.*;
import org.osgi.framework.dto.*;
import org.osgi.framework.startlevel.BundleStartLevel;
import org.osgi.framework.startlevel.FrameworkStartLevel;
import org.osgi.framework.startlevel.dto.BundleStartLevelDTO;
import org.osgi.framework.startlevel.dto.FrameworkStartLevelDTO;
import org.osgi.framework.wiring.*;
import org.osgi.framework.wiring.dto.*;
import org.osgi.resource.dto.*;
public class DTOBuilder {
private final Map<BundleRevision, BundleRevisionDTO> resources;
private final Map<BundleWiring, BundleWiringDTO.NodeDTO> wiringnodes;
private DTOBuilder() {
resources = new IdentityHashMap<>();
wiringnodes = new IdentityHashMap<>();
}
public static BundleDTO newBundleDTO(Bundle bundle) {
if (bundle == null) {
return null;
}
BundleDTO dto = new BundleDTO();
dto.id = bundle.getBundleId();
dto.lastModified = bundle.getLastModified();
dto.state = bundle.getState();
dto.symbolicName = bundle.getSymbolicName();
dto.version = bundle.getVersion().toString();
return dto;
}
public static BundleStartLevelDTO newBundleStartLevelDTO(Bundle b, BundleStartLevel bsl) {
if (bsl == null) {
return null;
}
BundleStartLevelDTO dto = new BundleStartLevelDTO();
dto.bundle = b.getBundleId();
dto.activationPolicyUsed = bsl.isActivationPolicyUsed();
dto.persistentlyStarted = bsl.isPersistentlyStarted();
dto.startLevel = bsl.getStartLevel();
return dto;
}
public static BundleRevisionDTO newBundleRevisionDTO(BundleRevision revision) {
BundleRevisionDTO dto = new DTOBuilder().getBundleRevisionDTO(revision);
return dto;
}
private int getResourceId(BundleRevision revision) {
BundleRevisionDTO dto = getBundleRevisionDTO(revision);
if (dto == null) {
return 0;
}
return dto.id;
}
private BundleRevisionDTO getBundleRevisionDTO(BundleRevision revision) {
if (revision == null) {
return null;
}
BundleRevisionDTO dto = resources.get(revision);
if (dto != null) {
return dto;
}
dto = new BundleRevisionDTO();
dto.id = identifier(revision);
resources.put(revision, dto);
dto.bundle = revision.getBundle().getBundleId();
dto.symbolicName = revision.getSymbolicName();
dto.type = revision.getTypes();
dto.version = revision.getVersion().toString();
dto.capabilities = getListCapabilityDTO(revision.getDeclaredCapabilities(null));
dto.requirements = getListRequirementDTO(revision.getDeclaredRequirements(null));
return dto;
}
private List<CapabilityDTO> getListCapabilityDTO(List<BundleCapability> caps) {
if (caps == null) {
return null;
}
List<CapabilityDTO> dtos = newList(caps.size());
for (BundleCapability cap : caps) {
dtos.add(getCapabilityDTO(cap));
}
return dtos;
}
private CapabilityDTO getCapabilityDTO(BundleCapability cap) {
if (cap == null) {
return null;
}
CapabilityDTO dto = new CapabilityDTO();
dto.id = identifier(cap);
dto.namespace = cap.getNamespace();
dto.resource = getResourceId(cap.getRevision());
dto.attributes = newAttributesMapDTO(cap.getAttributes());
dto.directives = newDirectivesMapDTO(cap.getDirectives());
return dto;
}
private List<CapabilityRefDTO> getListCapabilityRefDTO(List<BundleCapability> caps) {
if (caps == null) {
return null;
}
List<CapabilityRefDTO> dtos = newList(caps.size());
for (BundleCapability cap : caps) {
dtos.add(getCapabilityRefDTO(cap));
}
return dtos;
}
private CapabilityRefDTO getCapabilityRefDTO(BundleCapability cap) {
if (cap == null) {
return null;
}
CapabilityRefDTO dto = new CapabilityRefDTO();
dto.capability = identifier(cap);
dto.resource = getResourceId(cap.getRevision());
return dto;
}
private List<RequirementDTO> getListRequirementDTO(List<BundleRequirement> reqs) {
if (reqs == null) {
return null;
}
List<RequirementDTO> dtos = newList(reqs.size());
for (BundleRequirement req : reqs) {
dtos.add(getRequirementDTO(req));
}
return dtos;
}
private RequirementDTO getRequirementDTO(BundleRequirement req) {
if (req == null) {
return null;
}
RequirementDTO dto = new RequirementDTO();
dto.id = identifier(req);
dto.namespace = req.getNamespace();
dto.resource = getResourceId(req.getRevision());
dto.attributes = newAttributesMapDTO(req.getAttributes());
dto.directives = newDirectivesMapDTO(req.getDirectives());
return dto;
}
private List<RequirementRefDTO> getListRequirementRefDTO(List<BundleRequirement> reqs) {
if (reqs == null) {
return null;
}
List<RequirementRefDTO> dtos = newList(reqs.size());
for (BundleRequirement req : reqs) {
dtos.add(getRequirementRefDTO(req));
}
return dtos;
}
private RequirementRefDTO getRequirementRefDTO(BundleRequirement req) {
if (req == null) {
return null;
}
RequirementRefDTO dto = new RequirementRefDTO();
dto.requirement = identifier(req);
dto.resource = getResourceId(req.getRevision());
return dto;
}
public static BundleRevisionDTO[] newArrayBundleRevisionDTO(BundleRevisions revisions) {
if (revisions == null) {
return null;
}
List<BundleRevision> revs = revisions.getRevisions();
final int size = revs.size();
BundleRevisionDTO[] dtos = new BundleRevisionDTO[size];
for (int i = 0; i < size; i++) {
dtos[i] = new DTOBuilder().getBundleRevisionDTO(revs.get(i));
}
return dtos;
}
public static BundleWiringDTO newBundleWiringDTO(BundleRevision revision) {
if (revision == null) {
return null;
}
BundleWiringDTO dto = new DTOBuilder().getBundleWiringDTO(revision.getWiring());
return dto;
}
public static FrameworkWiringDTO newFrameworkWiringDTO(Collection<BundleWiring> allWirings) {
DTOBuilder builder = new DTOBuilder();
for (BundleWiring wiring : allWirings) {
builder.getBundleWiringNodeDTO(wiring);
}
FrameworkWiringDTO dto = new FrameworkWiringDTO();
dto.wirings = new HashSet<>(builder.wiringnodes.values());
dto.resources = new HashSet<>(builder.resources.values());
return dto;
}
private BundleWiringDTO getBundleWiringDTO(BundleWiring wiring) {
if (wiring == null) {
return null;
}
BundleWiringDTO dto = new BundleWiringDTO();
dto.bundle = wiring.getBundle().getBundleId();
dto.root = getWiringId(wiring);
dto.nodes = new HashSet<>(wiringnodes.values());
dto.resources = new HashSet<>(resources.values());
return dto;
}
private int getWiringId(BundleWiring wiring) {
BundleWiringDTO.NodeDTO dto = getBundleWiringNodeDTO(wiring);
if (dto == null) {
return 0;
}
return dto.id;
}
private BundleWiringDTO.NodeDTO getBundleWiringNodeDTO(BundleWiring wiring) {
if (wiring == null) {
return null;
}
BundleWiringDTO.NodeDTO dto = wiringnodes.get(wiring);
if (dto != null) {
return dto;
}
dto = new BundleWiringDTO.NodeDTO();
dto.id = identifier(wiring);
wiringnodes.put(wiring, dto);
dto.current = wiring.isCurrent();
dto.inUse = wiring.isInUse();
dto.resource = getResourceId(wiring.getRevision());
dto.capabilities = getListCapabilityRefDTO(wiring.getCapabilities(null));
dto.requirements = getListRequirementRefDTO(wiring.getRequirements(null));
dto.providedWires = getListBundleWireDTO(wiring.getProvidedWires(null));
dto.requiredWires = getListBundleWireDTO(wiring.getRequiredWires(null));
return dto;
}
private List<WireDTO> getListBundleWireDTO(List<BundleWire> wires) {
if (wires == null) {
return null;
}
List<WireDTO> dtos = newList(wires.size());
for (BundleWire wire : wires) {
dtos.add(getBundleWireDTO(wire));
}
return dtos;
}
private BundleWireDTO getBundleWireDTO(BundleWire wire) {
if (wire == null) {
return null;
}
BundleWireDTO dto = new BundleWireDTO();
dto.capability = getCapabilityRefDTO(wire.getCapability());
dto.requirement = getRequirementRefDTO(wire.getRequirement());
dto.provider = getResourceId(wire.getProvider());
dto.requirer = getResourceId(wire.getRequirer());
dto.providerWiring = getWiringId(wire.getProviderWiring());
dto.requirerWiring = getWiringId(wire.getRequirerWiring());
return dto;
}
public static BundleWiringDTO[] newArrayBundleWiringDTO(BundleRevisions revisions) {
if (revisions == null) {
return null;
}
List<BundleRevision> revs = revisions.getRevisions();
final int size = revs.size();
List<BundleWiringDTO> dtos = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
BundleWiring wiring = revs.get(i).getWiring();
if (wiring != null) {
dtos.add(new DTOBuilder().getBundleWiringDTO(wiring));
}
}
return dtos.toArray(new BundleWiringDTO[dtos.size()]);
}
public static FrameworkDTO newFrameworkDTO(BundleContext systemBundleContext, Map<String, String> configuration) {
FrameworkDTO dto = new FrameworkDTO();
dto.properties = asProperties(configuration);
if (systemBundleContext == null) {
dto.bundles = newList(0);
dto.services = newList(0);
return dto;
}
Bundle[] bundles = systemBundleContext.getBundles();
int size = bundles == null ? 0 : bundles.length;
List<BundleDTO> bundleDTOs = newList(size);
for (int i = 0; i < size; i++) {
bundleDTOs.add(newBundleDTO(bundles[i]));
}
dto.bundles = bundleDTOs;
try {
ServiceReference<?>[] references = systemBundleContext.getAllServiceReferences(null, null);
size = references == null ? 0 : references.length;
List<ServiceReferenceDTO> refDTOs = newList(size);
for (int i = 0; i < size; i++) {
ServiceReferenceDTO serviceRefDTO = getServiceReferenceDTO(references[i]);
if (serviceRefDTO != null) {
refDTOs.add(serviceRefDTO);
}
}
dto.services = refDTOs;
} catch (InvalidSyntaxException e) {
dto.services = newList(0);
}
return dto;
}
@SuppressWarnings("unchecked")
private static Map<String, Object> asProperties(Map<String, ?> m) {
return (Map<String, Object>) m;
}
private static ServiceReferenceDTO getServiceReferenceDTO(ServiceReference<?> ref) {
if (ref == null) {
return null;
}
Bundle b = ref.getBundle();
if (b == null) {
return null;
}
ServiceReferenceDTO dto = new ServiceReferenceDTO();
dto.bundle = b.getBundleId();
String[] keys = ref.getPropertyKeys();
Map<String, Object> properties = newMap(keys.length);
for (String k : keys) {
Object v = ref.getProperty(k);
if (Constants.SERVICE_ID.equals(k)) {
dto.id = ((Long) v).longValue();
}
properties.put(k, mapValue(v));
}
dto.properties = properties;
Bundle[] using = ref.getUsingBundles();
final int length = (using == null) ? 0 : using.length;
long[] usingBundles = new long[length];
for (int i = 0; i < length; i++) {
usingBundles[i] = using[i].getBundleId();
}
dto.usingBundles = usingBundles;
return dto;
}
public static FrameworkStartLevelDTO newFrameworkStartLevelDTO(FrameworkStartLevel fsl) {
if (fsl == null) {
return null;
}
FrameworkStartLevelDTO dto = new FrameworkStartLevelDTO();
dto.initialBundleStartLevel = fsl.getInitialBundleStartLevel();
dto.startLevel = fsl.getStartLevel();
return dto;
}
public static ServiceReferenceDTO[] newArrayServiceReferenceDTO(ServiceReference<?>[] references) {
if (references == null) {
return null;
}
final int length = references.length;
List<ServiceReferenceDTO> refDTOs = new ArrayList<>(length);
for (int i = 0; i < length; i++) {
ServiceReferenceDTO dto = getServiceReferenceDTO(references[i]);
if (dto != null) {
refDTOs.add(dto);
}
}
return refDTOs.toArray(new ServiceReferenceDTO[refDTOs.size()]);
}
private static Object mapValue(Object v) {
if ((v == null) || v instanceof Number || v instanceof Boolean || v instanceof Character || v instanceof String || v instanceof DTO) {
return v;
}
if (v instanceof Map) {
Map<?, ?> m = (Map<?, ?>) v;
Map<Object, Object> map = newMap(m.size());
for (Map.Entry<?, ?> e : m.entrySet()) {
map.put(mapValue(e.getKey()), mapValue(e.getValue()));
}
return map;
}
if (v instanceof List) {
List<?> c = (List<?>) v;
List<Object> list = newList(c.size());
for (Object o : c) {
list.add(mapValue(o));
}
return list;
}
if (v instanceof Set) {
Set<?> c = (Set<?>) v;
Set<Object> set = newSet(c.size());
for (Object o : c) {
set.add(mapValue(o));
}
return set;
}
if (v.getClass().isArray()) {
final int length = Array.getLength(v);
final Class<?> componentType = mapComponentType(v.getClass().getComponentType());
Object array = Array.newInstance(componentType, length);
for (int i = 0; i < length; i++) {
Array.set(array, i, mapValue(Array.get(v, i)));
}
return array;
}
return String.valueOf(v);
}
private static Class<?> mapComponentType(Class<?> componentType) {
if (componentType.isPrimitive() || componentType.isArray() || Object.class.equals(componentType) || Number.class.isAssignableFrom(componentType) || Boolean.class.isAssignableFrom(componentType) || Character.class.isAssignableFrom(componentType) || String.class.isAssignableFrom(componentType) || DTO.class.isAssignableFrom(componentType)) {
return componentType;
}
if (Map.class.isAssignableFrom(componentType)) {
return Map.class;
}
if (List.class.isAssignableFrom(componentType)) {
return List.class;
}
if (Set.class.isAssignableFrom(componentType)) {
return Set.class;
}
return String.class;
}
private static <E> List<E> newList(int size) {
return new ArrayList<>(size);
}
private static <E> Set<E> newSet(int size) {
return new HashSet<>(size);
}
private static <K, V> Map<K, V> newMap(int size) {
return new HashMap<>(size);
}
private static Map<String, String> newDirectivesMapDTO(Map<String, String> map) {
Map<String, String> dto = new HashMap<>(map);
return dto;
}
private static Map<String, Object> newAttributesMapDTO(Map<String, Object> map) {
Map<String, Object> dto = new HashMap<>(map);
for (Map.Entry<String, Object> entry : dto.entrySet()) {
Object value = entry.getValue();
if (value instanceof Version) {
entry.setValue(String.valueOf(value));
continue;
}
if (value instanceof List) {
List<Object> newList = new ArrayList<>((List<?>) value);
for (ListIterator<Object> iter = newList.listIterator(); iter.hasNext();) {
Object element = iter.next();
if (element instanceof Version) {
iter.set(String.valueOf(element));
}
}
entry.setValue(newList);
continue;
}
}
return dto;
}
private static int identifier(Object o) {
return System.identityHashCode(o);
}
}
DTOBuilder
resources: Map<BundleRevision, BundleRevisionDTO>
