/**
* create a new vertex, with the exact same name and weights, and only the depth is like the old
* one + its length
*
* @param id
* @param v
*/
public SeqVertex(int id, SeqVertex v) {
this(id, v.getName());
int len = v.getWeights().size();
_weights.ensureCapacity(len);
for (int i = 0; i < len; i++) _weights.add(i, v.getWeights().get(i));
_depth = v.getDepth() + v.getName().length();
}
/**
* Would factoring out this suffix result in elimating the reference source vertex?
*
* @param graph the graph
* @param commonSuffix the common suffix of all toSplits
* @param toSplits the list of vertices we're are trying to split
* @return true if toSplit contains the reference source and this ref source has all and only the
* bases of commonSuffix
*/
private boolean wouldEliminateRefSource(
final SeqGraph graph, final SeqVertex commonSuffix, final Collection<SeqVertex> toSplits) {
for (final SeqVertex toSplit : toSplits) {
if (graph.isRefSource(toSplit)) return toSplit.length() == commonSuffix.length();
}
return false;
}
/**
* Would all vertices that we'd split just result in the common suffix?
*
* <p>That is, suppose we have prefix nodes ABC and ABC. After splitting all of the vertices would
* just be ABC again, and we'd enter into an infinite loop.
*
* @param commonSuffix the common suffix of all vertices in toSplits
* @param toSplits the collection of vertices we want to split
* @return true if all of the vertices are equal to the common suffix
*/
private boolean allVerticesAreTheCommonSuffix(
final SeqVertex commonSuffix, final Collection<SeqVertex> toSplits) {
for (final SeqVertex toSplit : toSplits) {
if (toSplit.length() != commonSuffix.length()) return false;
}
return true;
}
/**
* Create a new seqvertex, with all ids from vWithL as prevID
*
* @param nextID
* @param l
* @param origVers
*/
public SeqVertex(int id, String name, Collection<SeqVertex> origVers) {
this(id, name);
Vector<Integer> thisNewLetter = new Vector<Integer>();
for (SeqVertex v : origVers) {
Vector<Integer> vID = v.getAndRemoveLastID(); // this was for the last letter graphs
thisNewLetter.addAll(vID);
}
_prevVerticesID.add(thisNewLetter);
}
/**
* create a new seqVertex, and give it the first id in this prev IDs remove the first prevIDS.
*
* @return
*/
public SeqVertex generateNewVerWithFirstIDasID() {
Integer firstID = getAndRemoveFirstID();
if (firstID == getID()) return this;
SeqVertex newV = new SeqVertex(firstID, getName());
newV._prevVerticesID = getPrevVerIDs();
newV._dfsFinishTime = _dfsFinishTime;
// newV._height = _height;
newV._depth = _depth;
newV._weights = _weights;
return newV;
}
public void addIDsAsFirstPrevIDs(Collection<SeqVertex> vWithL, int lAST_REAL_ID) {
Vector<Integer> prevIDs = new Vector<Integer>();
for (SeqVertex v : vWithL) {
int vid = v.getID();
if (vid >= 0)
if (vid <= lAST_REAL_ID) prevIDs.add(vid);
else if (!v.getPrevVerIDs().isEmpty()) {
prevIDs.addAll(v.getPrevVerIDs().get(0));
v.getPrevVerIDs().remove(0);
}
}
_prevVerticesID.add(prevIDs);
}
/*
* add the given vertex info into this vertex
* combine name and weights
*/
public void concatVertex(SeqVertex vertex, Double w, int lastRealID) {
int prevLen = getName().length();
setName(getName() + vertex.getName());
_weights.add(w);
_weights.addAll(vertex.getWeights());
// System.out.println(toStringWeights());
Vector<Integer> newV = new Vector<Integer>();
if (vertex.getID() <= lastRealID) {
newV.add(vertex.getID());
_prevVerticesID.add(newV);
}
_prevVerticesID.addAll(vertex.getPrevVerIDs());
if (vertex.getDegenerativeFreq().size() > 0) {
// System.err.println(vertex.getID()+":"+vertex.getDegenerativeFreq());
// System.err.println(vertex.getID()+":"+vertex.getDegenerativeLocations());
// System.err.println(vertex.getID()+":"+vertex.getDegenerativeLetters());
// System.err.println(getID()+":"+getName());
// System.err.println(prevLen);
_degenerativeLocations.add(prevLen + 1);
_degenerativeFreq.addAll(vertex.getDegenerativeFreq());
_degenerativeLetters.addAll(vertex.getDegenerativeLetters());
}
}
/**
* Simple single-function interface to split and then update a graph
*
* @param graph the graph containing the vertices in toMerge
* @param v The bottom node whose incoming vertices we'd like to split
* @return true if some useful splitting was done, false otherwise
*/
public boolean split(final SeqGraph graph, final SeqVertex v) {
if (graph == null) throw new IllegalArgumentException("graph cannot be null");
if (v == null) throw new IllegalArgumentException("v cannot be null");
if (!graph.vertexSet().contains(v))
throw new IllegalArgumentException("graph doesn't contain vertex v " + v);
final Collection<SeqVertex> toSplit = graph.incomingVerticesOf(v);
if (toSplit.size() < 2)
// Can only split at least 2 vertices
return false;
else if (!safeToSplit(graph, v, toSplit)) {
return false;
} else {
final SeqVertex suffixVTemplate = commonSuffix(toSplit);
if (suffixVTemplate.isEmpty()) {
return false;
} else if (wouldEliminateRefSource(graph, suffixVTemplate, toSplit)) {
return false;
} else if (allVerticesAreTheCommonSuffix(suffixVTemplate, toSplit)) {
return false;
} else {
final List<BaseEdge> edgesToRemove = new LinkedList<BaseEdge>();
// graph.printGraph(new File("split.pre_" + v.getSequenceString() + "." +
// counter + ".dot"), 0);
for (final SeqVertex mid : toSplit) {
// create my own copy of the suffix
final SeqVertex suffixV = new SeqVertex(suffixVTemplate.getSequence());
graph.addVertex(suffixV);
final SeqVertex prefixV = mid.withoutSuffix(suffixV.getSequence());
final BaseEdge out = graph.outgoingEdgeOf(mid);
final SeqVertex incomingTarget;
if (prefixV == null) {
// this node is entirely explained by suffix
incomingTarget = suffixV;
} else {
incomingTarget = prefixV;
graph.addVertex(prefixV);
graph.addEdge(prefixV, suffixV, new BaseEdge(out.isRef(), 1));
edgesToRemove.add(out);
}
graph.addEdge(suffixV, graph.getEdgeTarget(out), out.copy());
for (final BaseEdge in : graph.incomingEdgesOf(mid)) {
graph.addEdge(graph.getEdgeSource(in), incomingTarget, in.copy());
edgesToRemove.add(in);
}
}
graph.removeAllVertices(toSplit);
graph.removeAllEdges(edgesToRemove);
// graph.printGraph(new File("split.post_" + v.getSequenceString() + "." +
// counter++ + ".dot"), 0);
return true;
}
}
}
/**
* add the ver id from the vToRemove to this vertex previous ids
*
* @param vToKeep
* @param vToRemove
*/
public void addToPrevIDs(SeqVertex vToKeep, SeqVertex vToRemove, int lastRealID) {
if (_prevVerticesID.isEmpty()) {
Vector<Integer> thisV = new Vector<Integer>();
if (vToKeep.getID() >= lastRealID) thisV.add(vToKeep.getID());
if (vToRemove.getID() >= lastRealID) thisV.add(vToRemove.getID());
if (!vToKeep.getPrevVerIDs().isEmpty()) thisV.addAll(vToKeep.getPrevVerIDs().firstElement());
if (!vToRemove.getPrevVerIDs().isEmpty())
thisV.addAll(vToRemove.getPrevVerIDs().firstElement());
_prevVerticesID.add(thisV);
} else {
assert (true);
}
}
/**
* add the name of v1 to this name
*
* @param v1
*/
public void addToName(SeqVertex v1) {
_name = _name + v1.getName();
}
public void copyTheRest(SeqVertex v) {
_prevVerticesID = v.getPrevVerIDs();
_dfsFinishTime = v._dfsFinishTime;
_depth = v._depth;
_weights = v._weights;
}
