/*
* public HashMap getLeafElements() { HashMap map = new HashMap(); Object[]
* elts = dataElements.values().toArray(); for (int j=0; j<elts.length; j++)
* { PDMDataElement data = (PDMDataElement) elts[j];
* map.put(data.getID(),data); } Object[] ops =
* operations.values().toArray(); for (int i=0; i<ops.length; i++){
* PDMOperation op = (PDMOperation) ops[i]; if
* (!(op.getInputElements().isEmpty())){ HashMap outs =
* op.getOutputElements(); Object[] outArray = outs.values().toArray(); for
* (int j=0; j<outArray.length; j++) { PDMDataElement d = (PDMDataElement)
* outArray[j]; map.remove(d.getID()); } } } return map; }
*/
public HashMap getLeafElements() {
HashMap result = new HashMap();
HashSet leafOps = getLeafOperations();
if (!(leafOps.isEmpty())) {
Iterator it = leafOps.iterator();
while (it.hasNext()) {
PDMOperation op = (PDMOperation) it.next();
PDMDataElement data = op.getOutputElement();
result.put(data.getID(), data);
}
} else {
Object[] elts = dataElements.values().toArray();
for (int j = 0; j < elts.length; j++) {
PDMDataElement data = (PDMDataElement) elts[j];
result.put(data.getID(), data);
}
Object[] ops = operations.values().toArray();
for (int i = 0; i < ops.length; i++) {
PDMOperation op = (PDMOperation) ops[i];
HashMap outs = op.getOutputElements();
Object[] outArray = outs.values().toArray();
for (int j = 0; j < outArray.length; j++) {
PDMDataElement d = (PDMDataElement) outArray[j];
result.remove(d.getID());
}
}
}
return result;
}
@Override
public void execute() {
Map<String, Set<CortexLinksMap>> links = new HashMap<String, Set<CortexLinksMap>>();
Map<String, Set<String>> linkFilenames = new HashMap<String, Set<String>>();
if (LINKS != null && !LINKS.isEmpty()) {
for (CortexLinksMap cl : LINKS) {
String name = cl.getCortexLinks().getColor(0).getSampleName();
if (!links.containsKey(name)) {
links.put(name, new HashSet<CortexLinksMap>());
linkFilenames.put(name, new HashSet<String>());
}
links.get(name).add(cl);
linkFilenames.get(name).add(cl.getCortexLinks().getCortexLinksFile().getAbsolutePath());
}
log.info("Loaded {} links", LINKS.size());
for (CortexLinksMap clm : LINKS) {
log.info(
" {}: {}",
clm.getCortexLinks().getCortexLinksFile().getAbsolutePath(),
clm.getCortexLinks().getNumLinks());
}
}
log.info("Loaded {} graphs", GRAPHS.size());
for (CortexGraph cg : GRAPHS) {
String name = cg.getColor(0).getSampleName();
graphs.put(cg.getCortexFile().getName(), cg);
log.info(
" {}: {} {}", cg.getCortexFile().getName(), cg.getKmerSize(), linkFilenames.get(name));
}
loadContigs();
log.info("Loaded {} contigs", contigs.size());
log.info("Listening on port {}", PORT);
try {
HttpServer server = HttpServer.create(new InetSocketAddress(PORT), 0);
server.createContext("/", new PageHandler());
server.createContext("/graphlist", new GraphList());
server.createContext("/search", new SearchHandler());
server.createContext("/cr", new CtxRecordHandler());
server.createContext("/links", new LinksHandler());
server.setExecutor(null);
server.start();
} catch (IOException e) {
throw new IndianaException("Unable to start server", e);
}
}
public boolean hashSetContainsSameOperations(HashSet set1, HashSet set2) {
boolean result = false;
HashSet s1 = (HashSet) set1.clone();
HashSet s2 = (HashSet) set2.clone();
// first part, are all elements of s1 also in s2?
boolean one = false;
Iterator it = set1.iterator();
while (it.hasNext()) {
PDMOperation d = (PDMOperation) it.next();
if (s2.contains(d)) {
s1.remove(d);
}
}
if (s1.isEmpty()) {
one = true;
}
// second part, are all elements of s21 also in s1?
boolean two = false;
HashSet s3 = (HashSet) set1.clone();
HashSet s4 = (HashSet) set2.clone();
Iterator it2 = set2.iterator();
while (it2.hasNext()) {
PDMOperation d = (PDMOperation) it2.next();
if (s3.contains(d)) {
s4.remove(d);
}
}
if (s4.isEmpty()) {
two = true;
}
// administrative stuff
s1.clear();
s2.clear();
s3.clear();
s4.clear();
result = one && two;
return result;
}
void remove() {
UFNode root = this.find();
if (root != this) for (UFNode child : children) child.parent = root;
else if (!children.isEmpty()) {
Iterator<UFNode> it = children.iterator();
root = it.next();
root.parent = null;
while (it.hasNext()) it.next().parent = root;
root.size = this.size;
}
root.size--;
this.parent = null;
this.size = 1;
}
synchronized void updateAll() {
HashSet<Node> seenNodes = new HashSet<Node>();
for (int i = 0; i < _all.size(); i++) {
Node n = _all.get(i);
n.update(seenNodes);
}
if (!seenNodes.isEmpty()) {
// not empty, means that at least 1 server gave node list
// remove unused hosts
Iterator<Node> it = _all.iterator();
while (it.hasNext()) {
if (!seenNodes.contains(it.next())) it.remove();
}
}
}
private void unpackSegment(InputStream in, JarOutputStream out) throws IOException {
_props.setProperty(java.util.jar.Pack200.Unpacker.PROGRESS, "0");
// Process the output directory or jar output.
new PackageReader(pkg, in).read();
if (_props.getBoolean("unpack.strip.debug")) pkg.stripAttributeKind("Debug");
if (_props.getBoolean("unpack.strip.compile")) pkg.stripAttributeKind("Compile");
_props.setProperty(java.util.jar.Pack200.Unpacker.PROGRESS, "50");
pkg.ensureAllClassFiles();
// Now write out the files.
HashSet classesToWrite = new HashSet(pkg.getClasses());
for (Iterator i = pkg.getFiles().iterator(); i.hasNext(); ) {
Package.File file = (Package.File) i.next();
String name = file.nameString;
JarEntry je = new JarEntry(Utils.getJarEntryName(name));
boolean deflate;
deflate =
(keepDeflateHint)
? (((file.options & Constants.FO_DEFLATE_HINT) != 0)
|| ((pkg.default_options & Constants.AO_DEFLATE_HINT) != 0))
: deflateHint;
boolean needCRC = !deflate; // STORE mode requires CRC
if (needCRC) crc.reset();
bufOut.reset();
if (file.isClassStub()) {
Package.Class cls = file.getStubClass();
assert (cls != null);
new ClassWriter(cls, needCRC ? crcOut : bufOut).write();
classesToWrite.remove(cls); // for an error check
} else {
// collect data & maybe CRC
file.writeTo(needCRC ? crcOut : bufOut);
}
je.setMethod(deflate ? JarEntry.DEFLATED : JarEntry.STORED);
if (needCRC) {
if (verbose > 0)
Utils.log.info("stored size=" + bufOut.size() + " and crc=" + crc.getValue());
je.setMethod(JarEntry.STORED);
je.setSize(bufOut.size());
je.setCrc(crc.getValue());
}
if (keepModtime) {
je.setTime(file.modtime);
// Convert back to milliseconds
je.setTime((long) file.modtime * 1000);
} else {
je.setTime((long) modtime * 1000);
}
out.putNextEntry(je);
bufOut.writeTo(out);
out.closeEntry();
if (verbose > 0) Utils.log.info("Writing " + Utils.zeString((ZipEntry) je));
}
assert (classesToWrite.isEmpty());
_props.setProperty(java.util.jar.Pack200.Unpacker.PROGRESS, "100");
pkg.reset(); // reset for the next segment, if any
}
public PDMStateSpace calculateSimpleStateSpace(
boolean root, boolean failure, boolean input, boolean colored, int numStates, int breadth) {
PDMStateSpace result = new PDMStateSpace(this, colored);
HashSet states = new HashSet();
int j = (operations.size() + 1);
if (!input) {
HashSet empty = new HashSet();
PDMState st = new PDMState(result, "state" + i, empty, empty, empty);
result.addState(st);
states.add(st);
i++;
} else {
// Start with the complete set of input data elements available
HashSet empty = new HashSet();
String name = new String("state" + i);
HashSet ins = new HashSet(); // this hashSet contains the input
// elements to the process (input
// elements of PDM)
HashSet execOps = new HashSet();
// Fill the hashSet with the leaf elements
HashMap leafs = getLeafElements();
Object[] leafElts = leafs.values().toArray();
for (int i = 0; i < leafElts.length; i++) {
PDMDataElement d = (PDMDataElement) leafElts[i];
ins.add(d);
}
HashSet leafOps = getLeafOperations();
Iterator it = leafOps.iterator();
while (it.hasNext()) {
PDMOperation op = (PDMOperation) it.next();
execOps.add(op);
}
PDMState start = new PDMState(result, name, ins, execOps, empty); // start
// state
// of
// the
// statespace
result.addState(start);
i++;
states.add(start);
}
while (!states.isEmpty()) {
HashSet states2 = (HashSet) states.clone();
Iterator it = states2.iterator();
while (it.hasNext()) {
PDMState state = (PDMState) it.next();
HashSet nextStates = calculateNextStates(state, result, root, failure, numStates, breadth);
Iterator it2 = nextStates.iterator();
// Add the new states to iterator
while (it2.hasNext()) {
PDMState st = (PDMState) it2.next();
states.add(st);
}
states.remove(state);
}
}
i = 0;
j = 0;
Message.add("<PDMMDPStateSpace>", Message.TEST);
Message.add("<NumberOfStates = " + result.getNumberOfStates() + " >", Message.TEST);
Message.add("</PDMMDPStateSpace>", Message.TEST);
return result;
}