src/jalview/io/NewickFile.java

   1 /*\r
   2 * Jalview - A Sequence Alignment Editor and Viewer\r
   3 * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
   4 *\r
   5 * This program is free software; you can redistribute it and/or\r
   6 * modify it under the terms of the GNU General Public License\r
   7 * as published by the Free Software Foundation; either version 2\r
   8 * of the License, or (at your option) any later version.\r
   9 *\r
  10 * This program is distributed in the hope that it will be useful,\r
  11 * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13 * GNU General Public License for more details.\r
  14 *\r
  15 * You should have received a copy of the GNU General Public License\r
  16 * along with this program; if not, write to the Free Software\r
  17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
  18 */\r
  19 \r
  20 // NewickFile.java\r
  21 // Tree I/O\r
  22 // http://evolution.genetics.washington.edu/phylip/newick_doc.html\r
  23 // TODO: Implement Basic NHX tag parsing and preservation\r
  24 // TODO: http://evolution.genetics.wustl.edu/eddy/forester/NHX.html\r
  25 // TODO: Extended SequenceNodeI to hold parsed NHX strings\r
  26 package jalview.io;\r
  27 \r
  28 import jalview.datamodel.*;\r
  29 \r
  30 import java.io.*;\r
  31 \r
  32 \r
  33 /**\r
  34  * DOCUMENT ME!\r
  35  *\r
  36  * @author $author$\r
  37  * @version $Revision$\r
  38  */\r
  39 public class NewickFile extends FileParse\r
  40 {\r
  41     SequenceNode root;\r
  42     private boolean HasBootstrap = false;\r
  43     private boolean HasDistances = false;\r
  44     private boolean RootHasDistance = false;\r
  45 \r
  46     // File IO Flags\r
  47     boolean ReplaceUnderscores = false;\r
  48     boolean printRootInfo = false;\r
  49     private com.stevesoft.pat.Regex[] NodeSafeName = new com.stevesoft.pat.Regex[]\r
  50         {\r
  51             new com.stevesoft.pat.Regex().perlCode("m/[\\[,:'()]/"), // test for requiring quotes\r
  52             new com.stevesoft.pat.Regex().perlCode("s/'/''/"), // escaping quote characters\r
  53             new com.stevesoft.pat.Regex().perlCode("s/\\/w/_/") // unqoted whitespace transformation\r
  54         };\r
  55     char QuoteChar = '\'';\r
  56 \r
  57     /**\r
  58      * Creates a new NewickFile object.\r
  59      *\r
  60      * @param inStr DOCUMENT ME!\r
  61      *\r
  62      * @throws IOException DOCUMENT ME!\r
  63      */\r
  64     public NewickFile(String inStr) throws IOException\r
  65     {\r
  66         super(inStr, "Paste");\r
  67     }\r
  68 \r
  69     /**\r
  70      * Creates a new NewickFile object.\r
  71      *\r
  72      * @param inFile DOCUMENT ME!\r
  73      * @param type DOCUMENT ME!\r
  74      *\r
  75      * @throws IOException DOCUMENT ME!\r
  76      */\r
  77     public NewickFile(String inFile, String type) throws IOException\r
  78     {\r
  79         super(inFile, type);\r
  80     }\r
  81 \r
  82     /**\r
  83      * Creates a new NewickFile object.\r
  84      *\r
  85      * @param newtree DOCUMENT ME!\r
  86      */\r
  87     public NewickFile(SequenceNode newtree)\r
  88     {\r
  89         root = newtree;\r
  90     }\r
  91 \r
  92     /**\r
  93      * Creates a new NewickFile object.\r
  94      *\r
  95      * @param newtree DOCUMENT ME!\r
  96      * @param bootstrap DOCUMENT ME!\r
  97      */\r
  98     public NewickFile(SequenceNode newtree, boolean bootstrap)\r
  99     {\r
 100         HasBootstrap = bootstrap;\r
 101         root = newtree;\r
 102     }\r
 103 \r
 104     /**\r
 105      * Creates a new NewickFile object.\r
 106      *\r
 107      * @param newtree DOCUMENT ME!\r
 108      * @param bootstrap DOCUMENT ME!\r
 109      * @param distances DOCUMENT ME!\r
 110      */\r
 111     public NewickFile(SequenceNode newtree, boolean bootstrap, boolean distances)\r
 112     {\r
 113         root = newtree;\r
 114         HasBootstrap = bootstrap;\r
 115         HasDistances = distances;\r
 116     }\r
 117 \r
 118     /**\r
 119      * Creates a new NewickFile object.\r
 120      *\r
 121      * @param newtree DOCUMENT ME!\r
 122      * @param bootstrap DOCUMENT ME!\r
 123      * @param distances DOCUMENT ME!\r
 124      * @param rootdistance DOCUMENT ME!\r
 125      */\r
 126     public NewickFile(SequenceNode newtree, boolean bootstrap,\r
 127         boolean distances, boolean rootdistance)\r
 128     {\r
 129         root = newtree;\r
 130         HasBootstrap = bootstrap;\r
 131         HasDistances = distances;\r
 132         RootHasDistance = rootdistance;\r
 133     }\r
 134 \r
 135     /**\r
 136      * DOCUMENT ME!\r
 137      *\r
 138      * @param Error DOCUMENT ME!\r
 139      * @param Er DOCUMENT ME!\r
 140      * @param r DOCUMENT ME!\r
 141      * @param p DOCUMENT ME!\r
 142      * @param s DOCUMENT ME!\r
 143      *\r
 144      * @return DOCUMENT ME!\r
 145      */\r
 146     private String ErrorStringrange(String Error, String Er, int r, int p,\r
 147         String s)\r
 148     {\r
 149         return ((Error == null) ? "" : Error) + Er + " at position " + p +\r
 150         " ( " +\r
 151         s.substring(((p - r) < 0) ? 0 : (p - r),\r
 152             ((p + r) > s.length()) ? s.length() : (p + r)) + " )\n";\r
 153     }\r
 154 \r
 155     // @tree annotations\r
 156     // These are set automatically by the reader\r
 157     public boolean HasBootstrap()\r
 158     {\r
 159         return HasBootstrap;\r
 160     }\r
 161 \r
 162     /**\r
 163      * DOCUMENT ME!\r
 164      *\r
 165      * @return DOCUMENT ME!\r
 166      */\r
 167     public boolean HasDistances()\r
 168     {\r
 169         return HasDistances;\r
 170     }\r
 171 \r
 172     public boolean HasRootDistance()\r
 173     {\r
 174         return RootHasDistance;\r
 175     }\r
 176     /**\r
 177      * DOCUMENT ME!\r
 178      *\r
 179      * @throws IOException DOCUMENT ME!\r
 180      */\r
 181     public void parse() throws IOException\r
 182     {\r
 183         String nf;\r
 184 \r
 185         { // fill nf with complete tree file\r
 186 \r
 187             StringBuffer file = new StringBuffer();\r
 188 \r
 189             while ((nf = nextLine()) != null)\r
 190             {\r
 191                 file.append(nf);\r
 192             }\r
 193 \r
 194             nf = file.toString();\r
 195         }\r
 196 \r
 197         root = new SequenceNode();\r
 198 \r
 199         SequenceNode realroot = null;\r
 200         SequenceNode c = root;\r
 201 \r
 202         int d = -1;\r
 203         int cp = 0;\r
 204         //int flen = nf.length();\r
 205 \r
 206         String Error = null;\r
 207         String nodename = null;\r
 208 \r
 209         float DefDistance = (float) 0.001; // @param Default distance for a node - very very small\r
 210         int DefBootstrap = 0; // @param Default bootstrap for a node\r
 211 \r
 212         float distance = DefDistance;\r
 213         int bootstrap = DefBootstrap;\r
 214 \r
 215         boolean ascending = false; // flag indicating that we are leaving the current node\r
 216 \r
 217         com.stevesoft.pat.Regex majorsyms = new com.stevesoft.pat.Regex(\r
 218                 "[(\\['),;]");\r
 219 \r
 220         while (majorsyms.searchFrom(nf, cp) && (Error == null))\r
 221         {\r
 222             int fcp = majorsyms.matchedFrom();\r
 223 \r
 224             switch (nf.charAt(fcp))\r
 225             {\r
 226             case '[': // Comment or structured/extended NH format info\r
 227 \r
 228                 com.stevesoft.pat.Regex comment = new com.stevesoft.pat.Regex(\r
 229                         "]");\r
 230 \r
 231                 if (comment.searchFrom(nf, fcp))\r
 232                 {\r
 233                     // Skip the comment field\r
 234                     cp = 1 + comment.matchedFrom();\r
 235                 }\r
 236                 else\r
 237                 {\r
 238                     Error = ErrorStringrange(Error, "Unterminated comment", 3,\r
 239                             fcp, nf);\r
 240                 }\r
 241 \r
 242                 ;\r
 243 \r
 244                 break;\r
 245 \r
 246             case '(':\r
 247 \r
 248                 // ascending should not be set\r
 249                 // New Internal node\r
 250                 if (ascending)\r
 251                 {\r
 252                     Error = ErrorStringrange(Error, "Unexpected '('", 7, fcp, nf);\r
 253 \r
 254                     continue;\r
 255                 }\r
 256 \r
 257                 ;\r
 258                 d++;\r
 259 \r
 260                 if (c.right() == null)\r
 261                 {\r
 262                     c.setRight(new SequenceNode(null, c, null, DefDistance,\r
 263                             DefBootstrap, false));\r
 264                     c = (SequenceNode) c.right();\r
 265                 }\r
 266                 else\r
 267                 {\r
 268                     if (c.left() != null)\r
 269                     {\r
 270                         // Dummy node for polytomy - keeps c.left free for new node\r
 271                         SequenceNode tmpn = new SequenceNode(null, c, null, 0,\r
 272                                 0, true);\r
 273                         tmpn.SetChildren(c.left(), c.right());\r
 274                         c.setRight(tmpn);\r
 275                     }\r
 276 \r
 277                     c.setLeft(new SequenceNode(null, c, null, DefDistance,\r
 278                             DefBootstrap, false));\r
 279                     c = (SequenceNode) c.left();\r
 280                 }\r
 281 \r
 282                 if (realroot == null)\r
 283                 {\r
 284                     realroot = c;\r
 285                 }\r
 286 \r
 287                 nodename = null;\r
 288                 distance = DefDistance;\r
 289                 bootstrap = DefBootstrap;\r
 290                 cp = fcp + 1;\r
 291 \r
 292                 break;\r
 293 \r
 294             // Deal with quoted fields\r
 295             case '\'':\r
 296 \r
 297                 com.stevesoft.pat.Regex qnodename = new com.stevesoft.pat.Regex(\r
 298                         "([^']|'')+'");\r
 299 \r
 300                 if (qnodename.searchFrom(nf, fcp))\r
 301                 {\r
 302                     int nl = qnodename.stringMatched().length();\r
 303                     nodename = new String(qnodename.stringMatched().substring(0,\r
 304                                 nl - 1));\r
 305                     cp = fcp + nl + 1;\r
 306                 }\r
 307                 else\r
 308                 {\r
 309                     Error = ErrorStringrange(Error,\r
 310                             "Unterminated quotes for nodename", 7, fcp, nf);\r
 311                 }\r
 312 \r
 313                 break;\r
 314 \r
 315             case ';':\r
 316 \r
 317                 if (d != -1)\r
 318                 {\r
 319                     Error = ErrorStringrange(Error,\r
 320                             "Wayward semicolon (depth=" + d + ")", 7, fcp, nf);\r
 321                 }\r
 322 \r
 323             // cp advanced at the end of default\r
 324             default:\r
 325 \r
 326                 // Parse simpler field strings\r
 327                 String fstring = nf.substring(cp, fcp);\r
 328                 com.stevesoft.pat.Regex uqnodename = new com.stevesoft.pat.Regex(\r
 329                         "\\b([^' :;\\](),]+)");\r
 330                 com.stevesoft.pat.Regex nbootstrap = new com.stevesoft.pat.Regex(\r
 331                         "\\S+([0-9+]+)\\S*:");\r
 332                 com.stevesoft.pat.Regex ndist = new com.stevesoft.pat.Regex(\r
 333                         ":([-0-9Ee.+]+)");\r
 334 \r
 335                 if (uqnodename.search(fstring) &&\r
 336                         ((uqnodename.matchedFrom(1) == 0) ||\r
 337                         (fstring.charAt(uqnodename.matchedFrom(1) - 1) != ':'))) // JBPNote HACK!\r
 338                 {\r
 339                     if (nodename == null)\r
 340                     {\r
 341                         if (ReplaceUnderscores)\r
 342                         {\r
 343                             nodename = uqnodename.stringMatched(1).replace('_',\r
 344                                     ' ');\r
 345                         }\r
 346                         else\r
 347                         {\r
 348                             nodename = uqnodename.stringMatched(1);\r
 349                         }\r
 350                     }\r
 351                     else\r
 352                     {\r
 353                         Error = ErrorStringrange(Error,\r
 354                                 "File has broken algorithm - overwritten nodename",\r
 355                                 10, fcp, nf);\r
 356                     }\r
 357                 }\r
 358 \r
 359                 if (nbootstrap.search(fstring) &&\r
 360                         (nbootstrap.matchedFrom(1) > (uqnodename.matchedFrom(1) +\r
 361                         uqnodename.stringMatched().length())))\r
 362                 {\r
 363                     try\r
 364                     {\r
 365                         bootstrap = (new Integer(nbootstrap.stringMatched(1))).intValue();\r
 366                         HasBootstrap = true;\r
 367                     }\r
 368                     catch (Exception e)\r
 369                     {\r
 370                         Error = ErrorStringrange(Error,\r
 371                                 "Can't parse bootstrap value", 4,\r
 372                                 cp + nbootstrap.matchedFrom(), nf);\r
 373                     }\r
 374                 }\r
 375 \r
 376                 boolean nodehasdistance = false;\r
 377 \r
 378                 if (ndist.search(fstring))\r
 379                 {\r
 380                     try\r
 381                     {\r
 382                         distance = (new Float(ndist.stringMatched(1))).floatValue();\r
 383                         HasDistances = true;\r
 384                         nodehasdistance = true;\r
 385                     }\r
 386                     catch (Exception e)\r
 387                     {\r
 388                         Error = ErrorStringrange(Error,\r
 389                                 "Can't parse node distance value", 7,\r
 390                                 cp + ndist.matchedFrom(), nf);\r
 391                     }\r
 392                 }\r
 393 \r
 394                 if (ascending)\r
 395                 {\r
 396                     // Write node info here\r
 397                     c.setName(nodename);\r
 398                     // Trees without distances still need a render distance\r
 399                     c.dist = (HasDistances) ? distance : DefDistance;\r
 400                     // be consistent for internal bootstrap defaults too\r
 401                     c.setBootstrap((HasBootstrap) ? bootstrap : DefBootstrap);\r
 402                     if (c == realroot)\r
 403                     {\r
 404                         RootHasDistance = nodehasdistance; // JBPNote This is really UGLY!!! Ensure root node gets its given distance\r
 405                     }\r
 406                 }\r
 407                 else\r
 408                 {\r
 409                     // Find a place to put the leaf\r
 410                     SequenceNode newnode = new SequenceNode(null, c, nodename,\r
 411                             (HasDistances) ? distance : DefDistance,\r
 412                             (HasBootstrap) ? bootstrap : DefBootstrap, false);\r
 413 \r
 414                     if (c.right() == null)\r
 415                     {\r
 416                         c.setRight(newnode);\r
 417                     }\r
 418                     else\r
 419                     {\r
 420                         if (c.left() == null)\r
 421                         {\r
 422                             c.setLeft(newnode);\r
 423                         }\r
 424                         else\r
 425                         {\r
 426                             // Insert a dummy node for polytomy\r
 427                             // dummy nodes have distances\r
 428                             SequenceNode newdummy = new SequenceNode(null, c,\r
 429                                     null, (HasDistances ? 0 : DefDistance), 0, true);\r
 430                             newdummy.SetChildren(c.left(), newnode);\r
 431                             c.setLeft(newdummy);\r
 432                         }\r
 433                     }\r
 434                 }\r
 435 \r
 436                 if (ascending)\r
 437                 {\r
 438                     // move back up the tree from preceding closure\r
 439                     c = c.AscendTree();\r
 440 \r
 441                     if ((d > -1) && (c == null))\r
 442                     {\r
 443                         Error = ErrorStringrange(Error,\r
 444                                 "File broke algorithm: Lost place in tree (is there an extra ')' ?)",\r
 445                                 7, fcp, nf);\r
 446                     }\r
 447                 }\r
 448 \r
 449                 if (nf.charAt(fcp) == ')')\r
 450                 {\r
 451                     d--;\r
 452                     ascending = true;\r
 453                 }\r
 454                 else\r
 455                 {\r
 456                     if (nf.charAt(fcp) == ',')\r
 457                     {\r
 458                         if (ascending)\r
 459                         {\r
 460                             ascending = false;\r
 461                         }\r
 462                         else\r
 463                         {\r
 464                             // Just advance focus, if we need to\r
 465                             if ((c.left() != null) && (!c.left().isLeaf()))\r
 466                             {\r
 467                                 c = (SequenceNode) c.left();\r
 468                             }\r
 469                         }\r
 470                     }\r
 471 \r
 472                     // else : We do nothing if ';' is encountered.\r
 473                 }\r
 474 \r
 475                 // Reset new node properties to obvious fakes\r
 476                 nodename = null;\r
 477                 distance = DefDistance;\r
 478                 bootstrap = DefBootstrap;\r
 479 \r
 480                 cp = fcp + 1;\r
 481             }\r
 482         }\r
 483 \r
 484         if (Error != null)\r
 485         {\r
 486             throw (new IOException("NewickFile: " + Error + "\n"));\r
 487         }\r
 488 \r
 489         root = (SequenceNode) root.right().detach(); // remove the imaginary root.\r
 490 \r
 491         if (!RootHasDistance)\r
 492         {\r
 493             root.dist = (HasDistances) ? 0 : DefDistance;\r
 494         }\r
 495     }\r
 496 \r
 497     /**\r
 498      * DOCUMENT ME!\r
 499      *\r
 500      * @return DOCUMENT ME!\r
 501      */\r
 502     public SequenceNode getTree()\r
 503     {\r
 504         return root;\r
 505     }\r
 506 \r
 507     /**\r
 508      * Generate a newick format tree according to internal flags\r
 509      * for bootstraps, distances and root distances.\r
 510      *\r
 511      * @return new hampshire tree in a single line\r
 512      */\r
 513     public String print()\r
 514     {\r
 515         synchronized (this)\r
 516         {\r
 517             StringBuffer tf = new StringBuffer();\r
 518             print(tf, root);\r
 519 \r
 520             return (tf.append(";").toString());\r
 521         }\r
 522     }\r
 523 \r
 524     /**\r
 525      *\r
 526      *\r
 527      * Generate a newick format tree according to internal flags\r
 528      * for distances and root distances and user specificied writing of\r
 529      * bootstraps.\r
 530      * @param withbootstraps controls if bootstrap values are explicitly written.\r
 531      *\r
 532      * @return new hampshire tree in a single line\r
 533      */\r
 534     public String print(boolean withbootstraps)\r
 535     {\r
 536         synchronized (this)\r
 537         {\r
 538             boolean boots = this.HasBootstrap;\r
 539             this.HasBootstrap = withbootstraps;\r
 540 \r
 541             String rv = print();\r
 542             this.HasBootstrap = boots;\r
 543 \r
 544             return rv;\r
 545         }\r
 546     }\r
 547 \r
 548     /**\r
 549      *\r
 550      * Generate newick format tree according to internal flags\r
 551      * for writing root node distances.\r
 552      *\r
 553      * @param withbootstraps explicitly write bootstrap values\r
 554      * @param withdists explicitly write distances\r
 555      *\r
 556      * @return new hampshire tree in a single line\r
 557      */\r
 558     public String print(boolean withbootstraps, boolean withdists)\r
 559     {\r
 560         synchronized (this)\r
 561         {\r
 562             boolean dists = this.HasDistances;\r
 563             this.HasDistances = withdists;\r
 564 \r
 565             String rv = print(withbootstraps);\r
 566             this.HasDistances = dists;\r
 567 \r
 568             return rv;\r
 569         }\r
 570     }\r
 571 \r
 572     /**\r
 573      * Generate newick format tree according to user specified flags\r
 574      *\r
 575      * @param withbootstraps explicitly write bootstrap values\r
 576      * @param withdists explicitly write distances\r
 577      * @param printRootInfo explicitly write root distance\r
 578      *\r
 579      * @return new hampshire tree in a single line\r
 580      */\r
 581     public String print(boolean withbootstraps, boolean withdists,\r
 582         boolean printRootInfo)\r
 583     {\r
 584         synchronized (this)\r
 585         {\r
 586             boolean rootinfo = printRootInfo;\r
 587             this.printRootInfo = printRootInfo;\r
 588 \r
 589             String rv = print(withbootstraps, withdists);\r
 590             this.printRootInfo = rootinfo;\r
 591 \r
 592             return rv;\r
 593         }\r
 594     }\r
 595 \r
 596     /**\r
 597      * DOCUMENT ME!\r
 598      *\r
 599      * @return DOCUMENT ME!\r
 600      */\r
 601     char getQuoteChar()\r
 602     {\r
 603         return QuoteChar;\r
 604     }\r
 605 \r
 606     /**\r
 607      * DOCUMENT ME!\r
 608      *\r
 609      * @param c DOCUMENT ME!\r
 610      *\r
 611      * @return DOCUMENT ME!\r
 612      */\r
 613     char setQuoteChar(char c)\r
 614     {\r
 615         char old = QuoteChar;\r
 616         QuoteChar = c;\r
 617 \r
 618         return old;\r
 619     }\r
 620 \r
 621     /**\r
 622      * DOCUMENT ME!\r
 623      *\r
 624      * @param name DOCUMENT ME!\r
 625      *\r
 626      * @return DOCUMENT ME!\r
 627      */\r
 628     private String nodeName(String name)\r
 629     {\r
 630         if (NodeSafeName[0].search(name))\r
 631         {\r
 632             return QuoteChar + NodeSafeName[1].replaceAll(name) + QuoteChar;\r
 633         }\r
 634         else\r
 635         {\r
 636             return NodeSafeName[2].replaceAll(name);\r
 637         }\r
 638     }\r
 639 \r
 640     /**\r
 641      * DOCUMENT ME!\r
 642      *\r
 643      * @param c DOCUMENT ME!\r
 644      *\r
 645      * @return DOCUMENT ME!\r
 646      */\r
 647     private String printNodeField(SequenceNode c)\r
 648     {\r
 649         return ((c.getName() == null) ? "" : nodeName(c.getName())) +\r
 650         ((HasBootstrap)\r
 651         ? ((c.getBootstrap() > -1) ? (" " + c.getBootstrap()) : "") : "") +\r
 652         ((HasDistances) ? (":" + c.dist) : "");\r
 653     }\r
 654 \r
 655     /**\r
 656      * DOCUMENT ME!\r
 657      *\r
 658      * @param root DOCUMENT ME!\r
 659      *\r
 660      * @return DOCUMENT ME!\r
 661      */\r
 662     private String printRootField(SequenceNode root)\r
 663     {\r
 664         return (printRootInfo)\r
 665         ? (((root.getName() == null) ? "" : nodeName(root.getName())) +\r
 666         ((HasBootstrap)\r
 667         ? ((root.getBootstrap() > -1) ? (" " + root.getBootstrap()) : "") : "") +\r
 668         ((RootHasDistance) ? (":" + root.dist) : "")) : "";\r
 669     }\r
 670 \r
 671     // Non recursive call deals with root node properties\r
 672     public void print(StringBuffer tf, SequenceNode root)\r
 673     {\r
 674         if (root != null)\r
 675         {\r
 676             if (root.isLeaf() && printRootInfo)\r
 677             {\r
 678                 tf.append(printRootField(root));\r
 679             }\r
 680             else\r
 681             {\r
 682                 if (root.isDummy())\r
 683                 {\r
 684                     _print(tf, (SequenceNode) root.right());\r
 685                     _print(tf, (SequenceNode) root.left());\r
 686                 }\r
 687                 else\r
 688                 {\r
 689                     tf.append("(");\r
 690                     _print(tf, (SequenceNode) root.right());\r
 691 \r
 692                     if (root.left() != null)\r
 693                     {\r
 694                         tf.append(",");\r
 695                     }\r
 696 \r
 697                     _print(tf, (SequenceNode) root.left());\r
 698                     tf.append(")" + printRootField(root));\r
 699                 }\r
 700             }\r
 701         }\r
 702     }\r
 703 \r
 704     // Recursive call for non-root nodes\r
 705     public void _print(StringBuffer tf, SequenceNode c)\r
 706     {\r
 707         if (c != null)\r
 708         {\r
 709             if (c.isLeaf())\r
 710             {\r
 711                 tf.append(printNodeField(c));\r
 712             }\r
 713             else\r
 714             {\r
 715                 if (c.isDummy())\r
 716                 {\r
 717                     _print(tf, (SequenceNode) c.left());\r
 718                     if (c.left() != null)\r
 719                     {\r
 720                       tf.append(",");\r
 721                     }\r
 722                     _print(tf, (SequenceNode) c.right());\r
 723                 }\r
 724                 else\r
 725                 {\r
 726                     tf.append("(");\r
 727                     _print(tf, (SequenceNode) c.right());\r
 728 \r
 729                     if (c.left() != null)\r
 730                     {\r
 731                         tf.append(",");\r
 732                     }\r
 733 \r
 734                     _print(tf, (SequenceNode) c.left());\r
 735                     tf.append(")" + printNodeField(c));\r
 736                 }\r
 737             }\r
 738         }\r
 739     }\r
 740 \r
 741     // Test\r
 742     public static void main(String[] args)\r
 743     {\r
 744         try\r
 745         {\r
 746             if (args==null || args.length!=1) {\r
 747               System.err.println("Takes one argument - file name of a newick tree file.");\r
 748               System.exit(0);\r
 749             }\r
 750 \r
 751             File fn = new File(args[0]);\r
 752 \r
 753             StringBuffer newickfile = new StringBuffer();\r
 754             BufferedReader treefile = new BufferedReader(new FileReader(fn));\r
 755             String l;\r
 756 \r
 757             while ((l = treefile.readLine()) != null)\r
 758             {\r
 759                 newickfile.append(l);\r
 760             }\r
 761 \r
 762             treefile.close();\r
 763             System.out.println("Read file :\n");\r
 764 \r
 765             NewickFile trf = new NewickFile(args[0], "File");\r
 766             trf.parse();\r
 767             System.out.println("Original file :\n");\r
 768 \r
 769             com.stevesoft.pat.Regex nonl = new com.stevesoft.pat.Regex("\n+", "");\r
 770             System.out.println(nonl.replaceAll(newickfile.toString()) + "\n");\r
 771 \r
 772             System.out.println("Parsed file.\n");\r
 773             System.out.println("Default output type for original input.\n");\r
 774             System.out.println(trf.print());\r
 775             System.out.println("Without bootstraps.\n");\r
 776             System.out.println(trf.print(false));\r
 777             System.out.println("Without distances.\n");\r
 778             System.out.println(trf.print(true, false));\r
 779             System.out.println("Without bootstraps but with distanecs.\n");\r
 780             System.out.println(trf.print(false, true));\r
 781             System.out.println("Without bootstraps or distanecs.\n");\r
 782             System.out.println(trf.print(false, false));\r
 783             System.out.println("With bootstraps and with distances.\n");\r
 784             System.out.println(trf.print(true, true));\r
 785         }\r
 786         catch (java.io.IOException e)\r
 787         {\r
 788             System.err.println("Exception\n" + e);\r
 789             e.printStackTrace();\r
 790         }\r
 791     }\r
 792 }\r