import org.forester.io.parsers.nhx.NHXFormatException;
import org.forester.io.parsers.nhx.NHXParser;
+import org.forester.io.parsers.phyloxml.PhyloXmlDataFormatException;
import org.forester.io.parsers.phyloxml.PhyloXmlUtil;
import org.forester.phylogeny.data.BranchData;
import org.forester.phylogeny.data.Confidence;
import org.forester.phylogeny.data.NodeData;
import org.forester.phylogeny.data.PhylogenyDataUtil;
-import org.forester.phylogeny.iterators.ChildNodeIteratorForward;
-import org.forester.phylogeny.iterators.PhylogenyNodeIterator;
import org.forester.phylogeny.iterators.PreorderTreeIterator;
import org.forester.util.ForesterUtil;
-public final class PhylogenyNode implements PhylogenyNodeI, Comparable<PhylogenyNode> {
+/**
+ * Warning. Implementation of method 'compareTo' only looks at
+ * node name. Thus, use of this class in SortedSets might lead
+ * to unexpected behavior.
+ *
+ */
+public final class PhylogenyNode implements Comparable<PhylogenyNode> {
+ public enum NH_CONVERSION_SUPPORT_VALUE_STYLE {
+ NONE, IN_SQUARE_BRACKETS, AS_INTERNAL_NODE_NAMES;
+ }
private static int _node_count = 0;
private byte _indicator;
private int _id;
* @param n
* the PhylogenyNode to add
*/
- @Override
- final public void addAsChild( final PhylogenyNodeI node ) {
- final PhylogenyNode n = ( PhylogenyNode ) node;
+ final public void addAsChild( final PhylogenyNode node ) {
+ final PhylogenyNode n = node;
addChildNode( n );
n.setParent( this );
}
}
@Override
+ // this is poor, as it only compares on names!
final public int compareTo( final PhylogenyNode o ) {
final PhylogenyNode n = o;
if ( ( getName() == null ) || ( n.getName() == null ) ) {
*
*/
final public boolean equals( final Object o ) {
- System.out.print( " PN___e___ " );
if ( this == o ) {
return true;
}
* @throws IllegalArgumentException
* if n is out of bounds
*/
- @Override
final public PhylogenyNode getChildNode( final int i ) {
if ( isExternal() ) {
throw new UnsupportedOperationException( "attempt to get the child node of an external node." );
* Returns the length of the branch leading to the _parent of this
* PhylogenyNode (double).
*/
- @Override
final public double getDistanceToParent() {
return _distance_parent;
}
previous_node = current_node;
current_node = current_node.getParent();
}
- if ( index < current_node.getNumberOfDescendants() - 1 ) {
+ if ( index < ( current_node.getNumberOfDescendants() - 1 ) ) {
current_node = current_node.getChildNode( index + 1 );
}
while ( current_node.isInternal() && !current_node.isCollapse() ) {
/**
* Returns the ID (int) of this PhylogenyNode.
*/
- @Override
final public int getId() {
return _id;
}
- /**
- * Returns the name of this node.
- */
- @Override
final public String getName() {
return getNodeData().getNodeName();
}
+ final public List<PhylogenyNode> getAllDescendants() {
+ return _descendants;
+ }
+
final public int getNumberOfDescendants() {
if ( _descendants == null ) {
return 0;
@Override
final public int hashCode() {
- System.out.print( " PNh " );
final NodeData data = getNodeData();
if ( ( getName().length() < 1 ) && !data.isHasSequence() && !data.isHasTaxonomy() ) {
return super.hashCode();
return true;
}
+ public final int calculateDepth() {
+ PhylogenyNode n = this;
+ int steps = 0;
+ while ( n._parent != null ) {
+ steps++;
+ n = n._parent;
+ }
+ return steps;
+ }
+
+ public final double calculateDistanceToRoot() {
+ PhylogenyNode n = this;
+ double d = 0.0;
+ while ( n._parent != null ) {
+ if ( n._distance_parent > 0.0 ) {
+ d += n._distance_parent;
+ }
+ n = n._parent;
+ }
+ return d;
+ }
+
/**
* Checks whether this PhylogenyNode is a root.
*
}
// ---------------------------------------------------------
- // Iterator
- // ---------------------------------------------------------
- final public PhylogenyNodeIterator iterateChildNodesForward() {
- return new ChildNodeIteratorForward( this );
- }
-
- // ---------------------------------------------------------
// Basic printing
// ---------------------------------------------------------
/**
* Sets the length of the branch leading to the _parent of this
* PhylogenyNode to double d.
*/
- @Override
final public void setDistanceToParent( final double d ) {
_distance_parent = d;
}
/**
* Sets the name of this node.
*/
- @Override
final public void setName( final String node_name ) {
getNodeData().setNodeName( node_name );
}
/**
* Sets the _parent PhylogenyNode of this PhylogenyNode to n.
*/
- @Override
final public void setParent( final PhylogenyNode n ) {
_parent = n;
}
@Override
final public String toString() {
- StringBuilder sb = new StringBuilder();
- if ( ForesterUtil.isEmpty( getName() ) ) {
- sb.append( getName() );
- sb.append( " " );
- }
+ final StringBuilder sb = new StringBuilder();
if ( getNodeData().isHasTaxonomy() ) {
if ( !ForesterUtil.isEmpty( getNodeData().getTaxonomy().getScientificName() ) ) {
sb.append( getNodeData().getTaxonomy().getScientificName() );
sb.append( " " );
}
- else if ( !ForesterUtil.isEmpty( getNodeData().getTaxonomy().getTaxonomyCode() ) ) {
+ else if ( ( sb.length() <= 1 ) && !ForesterUtil.isEmpty( getNodeData().getTaxonomy().getTaxonomyCode() ) ) {
sb.append( getNodeData().getTaxonomy().getTaxonomyCode() );
sb.append( " " );
}
sb.append( getNodeData().getSequence().getName() );
sb.append( " " );
}
- else if ( !ForesterUtil.isEmpty( getNodeData().getSequence().getSymbol() ) ) {
+ if ( !ForesterUtil.isEmpty( getNodeData().getSequence().getSymbol() ) ) {
sb.append( getNodeData().getSequence().getSymbol() );
sb.append( " " );
}
- else if ( getNodeData().getSequence().getAccession() != null ) {
- sb.append( getNodeData().getTaxonomy().getIdentifier().toString() );
+ if ( getNodeData().getSequence().getAccession() != null ) {
+ sb.append( getNodeData().getSequence().getAccession().toString() );
sb.append( " " );
}
}
+ if ( ( sb.length() <= 1 ) && !ForesterUtil.isEmpty( getName() ) ) {
+ sb.append( getName() );
+ sb.append( " " );
+ }
if ( sb.length() <= 1 ) {
sb.append( "[" );
sb.append( getId() );
PhylogenyNode._node_count = i;
}
- public static PhylogenyNode createInstanceFromNhxString( final String nhx ) throws NHXFormatException {
- return new PhylogenyNode( nhx, PhylogenyMethods.TAXONOMY_EXTRACTION.NO, false );
+ public static PhylogenyNode createInstanceFromNhxString( final String nhx ) throws NHXFormatException,
+ PhyloXmlDataFormatException {
+ return new PhylogenyNode( nhx, NHXParser.TAXONOMY_EXTRACTION.NO, false );
}
public static PhylogenyNode createInstanceFromNhxString( final String nhx,
- final PhylogenyMethods.TAXONOMY_EXTRACTION taxonomy_extraction )
- throws NHXFormatException {
+ final NHXParser.TAXONOMY_EXTRACTION taxonomy_extraction )
+ throws NHXFormatException, PhyloXmlDataFormatException {
return new PhylogenyNode( nhx, taxonomy_extraction, false );
}
public static PhylogenyNode createInstanceFromNhxString( final String nhx,
- final PhylogenyMethods.TAXONOMY_EXTRACTION taxonomy_extraction,
+ final NHXParser.TAXONOMY_EXTRACTION taxonomy_extraction,
final boolean replace_underscores )
- throws NHXFormatException {
+ throws NHXFormatException, PhyloXmlDataFormatException {
return new PhylogenyNode( nhx, taxonomy_extraction, replace_underscores );
}
private PhylogenyNode( final String nhx,
- final PhylogenyMethods.TAXONOMY_EXTRACTION taxonomy_extraction,
- final boolean replace_underscores ) throws NHXFormatException {
+ final NHXParser.TAXONOMY_EXTRACTION taxonomy_extraction,
+ final boolean replace_underscores ) throws NHXFormatException, PhyloXmlDataFormatException {
// init();
NHXParser.parseNHX( nhx, this, taxonomy_extraction, replace_underscores );
setId( PhylogenyNode.getNodeCount() );
git://source.jalview.org / jalview.git / blobdiff