src/jalview/util/GroupUrlLink.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.0b1)
   3  * Copyright (C) 2014 The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  * The Jalview Authors are detailed in the 'AUTHORS' file.
  18  */
  19 package jalview.util;
  20
  21 import jalview.datamodel.Sequence;
  22 import jalview.datamodel.SequenceI;
  23
  24 import java.util.Hashtable;
  25 import java.util.Vector;
  26
  27 public class GroupUrlLink
  28 {
  29   public class UrlStringTooLongException extends Exception
  30   {
  31     public UrlStringTooLongException(int lng)
  32     {
  33       urlLength = lng;
  34     }
  35
  36     public int urlLength;
  37
  38     public String toString()
  39     {
  40       return "Generated url is estimated to be too long (" + urlLength
  41               + ")";
  42     }
  43   }
  44
  45   /**
  46    * Helper class based on the UrlLink class which enables URLs to be
  47    * constructed from sequences or IDs associated with a group of sequences. URL
  48    * definitions consist of a pipe separated string containing a <label>|<url
  49    * construct>|<separator character>[|<sequence separator character>]. The url
  50    * construct includes regex qualified tokens which are replaced with seuqence
  51    * IDs ($SEQUENCE_IDS$) and/or seuqence regions ($SEQUENCES$) that are
  52    * extracted from the group. See <code>UrlLink</code> for more information
  53    * about the approach, and the original implementation. Documentation to come.
  54    * Note - groupUrls can be very big!
  55    */
  56   private String url_prefix, target, label;
  57
  58   /**
  59    * these are all filled in order of the occurence of each token in the url
  60    * string template
  61    */
  62   private String url_suffix[], separators[], regexReplace[];
  63
  64   private String invalidMessage = null;
  65
  66   /**
  67    * tokens that can be replaced in the URL.
  68    */
  69   private static String[] tokens;
  70
  71   /**
  72    * position of each token (which can appear once only) in the url
  73    */
  74   private int[] segs;
  75
  76   /**
  77    * contains tokens in the order they appear in the URL template.
  78    */
  79   private String[] mtch;
  80   static
  81   {
  82     if (tokens == null)
  83     {
  84       tokens = new String[]
  85       { "SEQUENCEIDS", "SEQUENCES", "DATASETID" };
  86     }
  87   }
  88
  89   /**
  90    * test for GroupURLType bitfield (with default tokens)
  91    */
  92   public static final int SEQUENCEIDS = 1;
  93
  94   /**
  95    * test for GroupURLType bitfield (with default tokens)
  96    */
  97   public static final int SEQUENCES = 2;
  98
  99   /**
 100    * test for GroupURLType bitfield (with default tokens)
 101    */
 102   public static final int DATASETID = 4;
 103
 104   // private int idseg = -1, seqseg = -1;
 105
 106   /**
 107    * parse the given linkString of the form '<label>|<url>|separator
 108    * char[|optional sequence separator char]' into parts. url may contain a
 109    * string $SEQUENCEIDS<=optional regex=>$ where <=optional regex=> must be of
 110    * the form =/<perl style regex>/=$ or $SEQUENCES<=optional regex=>$ or
 111    * $SEQUENCES<=optional regex=>$.
 112    *
 113    * @param link
 114    */
 115   public GroupUrlLink(String link)
 116   {
 117     int sep = link.indexOf("|");
 118     segs = new int[tokens.length];
 119     int ntoks = 0;
 120     for (int i = 0; i < segs.length; i++)
 121     {
 122       if ((segs[i] = link.indexOf("$" + tokens[i])) > -1)
 123       {
 124         ntoks++;
 125       }
 126     }
 127     // expect at least one token
 128     if (ntoks == 0)
 129     {
 130       invalidMessage = "Group URL string must contain at least one of ";
 131       for (int i = 0; i < segs.length; i++)
 132       {
 133         invalidMessage += " '$" + tokens[i] + "[=/regex=/]$'";
 134       }
 135       return;
 136     }
 137
 138     int[] ptok = new int[ntoks + 1];
 139     String[] tmtch = new String[ntoks + 1];
 140     mtch = new String[ntoks];
 141     for (int i = 0, t = 0; i < segs.length; i++)
 142     {
 143       if (segs[i] > -1)
 144       {
 145         ptok[t] = segs[i];
 146         tmtch[t++] = tokens[i];
 147       }
 148     }
 149     ptok[ntoks] = link.length();
 150     tmtch[ntoks] = "$$$$$$$$$";
 151     jalview.util.QuickSort.sort(ptok, tmtch);
 152     for (int i = 0; i < ntoks; i++)
 153     {
 154       mtch[i] = tmtch[i]; // TODO: check order is ascending
 155     }
 156     /*
 157      * replaces the specific code below {}; if (psqids > -1 && pseqs > -1) { if
 158      * (psqids > pseqs) { idseg = 1; seqseg = 0;
 159      *
 160      * ptok = new int[] { pseqs, psqids, link.length() }; mtch = new String[] {
 161      * "$SEQUENCES", "$SEQUENCEIDS" }; } else { idseg = 0; seqseg = 1; ptok =
 162      * new int[] { psqids, pseqs, link.length() }; mtch = new String[] {
 163      * "$SEQUENCEIDS", "$SEQUENCES" }; } } else { if (psqids != -1) { idseg = 0;
 164      * ptok = new int[] { psqids, link.length() }; mtch = new String[] {
 165      * "$SEQUENCEIDS" }; } else { seqseg = 0; ptok = new int[] { pseqs,
 166      * link.length() }; mtch = new String[] { "$SEQUENCES" }; } }
 167      */
 168
 169     int p = sep;
 170     // first get the label and target part before the first |
 171     do
 172     {
 173       sep = p;
 174       p = link.indexOf("|", sep + 1);
 175     } while (p > sep && p < ptok[0]);
 176     // Assuming that the URL itself does not contain any '|' symbols
 177     // sep now contains last pipe symbol position prior to any regex symbols
 178     label = link.substring(0, sep);
 179     if (label.indexOf("|") > -1)
 180     {
 181       // | terminated database name / www target at start of Label
 182       target = label.substring(0, label.indexOf("|"));
 183     }
 184     else if (label.indexOf(" ") > 2)
 185     {
 186       // space separated Label - matches database name
 187       target = label.substring(0, label.indexOf(" "));
 188     }
 189     else
 190     {
 191       target = label;
 192     }
 193     // Now Parse URL : Whole URL string first
 194     url_prefix = link.substring(sep + 1, ptok[0]);
 195     url_suffix = new String[mtch.length];
 196     regexReplace = new String[mtch.length];
 197     // and loop through tokens
 198     for (int pass = 0; pass < mtch.length; pass++)
 199     {
 200       int mlength = 3 + mtch[pass].length();
 201       if (link.indexOf("$" + mtch[pass] + "=/") == ptok[pass]
 202               && (p = link.indexOf("/=$", ptok[pass] + mlength)) > ptok[pass]
 203                       + mlength)
 204       {
 205         // Extract Regex and suffix
 206         if (ptok[pass + 1] < p + 3)
 207         {
 208           // tokens are not allowed inside other tokens - e.g. inserting a
 209           // $sequences$ into the regex match for the sequenceid
 210           invalidMessage = "Token regexes cannot contain other regexes (did you terminate the $"
 211                   + mtch[pass] + " regex with a '/=$' ?";
 212           return;
 213         }
 214         url_suffix[pass] = link.substring(p + 3, ptok[pass + 1]);
 215         regexReplace[pass] = link.substring(ptok[pass] + mlength, p);
 216         try
 217         {
 218           com.stevesoft.pat.Regex rg = com.stevesoft.pat.Regex.perlCode("/"
 219                   + regexReplace[pass] + "/");
 220           if (rg == null)
 221           {
 222             invalidMessage = "Invalid Regular Expression : '"
 223                     + regexReplace[pass] + "'\n";
 224           }
 225         } catch (Exception e)
 226         {
 227           invalidMessage = "Invalid Regular Expression : '"
 228                   + regexReplace[pass] + "'\n";
 229         }
 230       }
 231       else
 232       {
 233         regexReplace[pass] = null;
 234         // verify format is really correct.
 235         if ((p = link.indexOf("$" + mtch[pass] + "$")) == ptok[pass])
 236         {
 237           url_suffix[pass] = link.substring(p + mtch[pass].length() + 2,
 238                   ptok[pass + 1]);
 239         }
 240         else
 241         {
 242           invalidMessage = "Warning: invalid regex structure (after '"
 243                   + mtch[0] + "') for URL link : " + link;
 244         }
 245       }
 246     }
 247     int pass = 0;
 248     separators = new String[url_suffix.length];
 249     String suffices = url_suffix[url_suffix.length - 1], lastsep = ",";
 250     // have a look in the last suffix for any more separators.
 251     while ((p = suffices.indexOf('|')) > -1)
 252     {
 253       separators[pass] = suffices.substring(p + 1);
 254       if (pass == 0)
 255       {
 256         // trim the original suffix string
 257         url_suffix[url_suffix.length - 1] = suffices.substring(0, p);
 258       }
 259       else
 260       {
 261         lastsep = (separators[pass - 1] = separators[pass - 1].substring(0,
 262                 p));
 263       }
 264       suffices = separators[pass];
 265       pass++;
 266     }
 267     if (pass > 0)
 268     {
 269       lastsep = separators[pass - 1];
 270     }
 271     // last separator is always used for all the remaining separators
 272     while (pass < separators.length)
 273     {
 274       separators[pass++] = lastsep;
 275     }
 276   }
 277
 278   /**
 279    * @return the url_suffix
 280    */
 281   public String getUrl_suffix()
 282   {
 283     return url_suffix[url_suffix.length - 1];
 284   }
 285
 286   /**
 287    * @return the url_prefix
 288    */
 289   public String getUrl_prefix()
 290   {
 291     return url_prefix;
 292   }
 293
 294   /**
 295    * @return the target
 296    */
 297   public String getTarget()
 298   {
 299     return target;
 300   }
 301
 302   /**
 303    * @return the label
 304    */
 305   public String getLabel()
 306   {
 307     return label;
 308   }
 309
 310   /**
 311    * @return the sequence ID regexReplace
 312    */
 313   public String getIDRegexReplace()
 314   {
 315     return _replaceFor(tokens[0]);
 316   }
 317
 318   private String _replaceFor(String token)
 319   {
 320     for (int i = 0; i < mtch.length; i++)
 321       if (segs[i] > -1 && mtch[i].equals(token))
 322       {
 323         return regexReplace[i];
 324       }
 325     return null;
 326   }
 327
 328   /**
 329    * @return the sequence ID regexReplace
 330    */
 331   public String getSeqRegexReplace()
 332   {
 333     return _replaceFor(tokens[1]);
 334   }
 335
 336   /**
 337    * @return the invalidMessage
 338    */
 339   public String getInvalidMessage()
 340   {
 341     return invalidMessage;
 342   }
 343
 344   /**
 345    * Check if URL string was parsed properly.
 346    *
 347    * @return boolean - if false then <code>getInvalidMessage</code> returns an
 348    *         error message
 349    */
 350   public boolean isValid()
 351   {
 352     return invalidMessage == null;
 353   }
 354
 355   /**
 356    * return one or more URL strings by applying regex to the given idstring
 357    *
 358    * @param idstrings
 359    *          array of id strings to pass to service
 360    * @param seqstrings
 361    *          array of seq strings to pass to service
 362    * @param onlyIfMatches
 363    *          - when true url strings are only made if regex is defined and
 364    *          matches for all qualified tokens in groupURL - TODO: consider if
 365    *          onlyIfMatches is really a useful parameter!
 366    * @return null or Object[] { int[] { number of seqs substituted},boolean[] {
 367    *         which seqs were substituted }, StringBuffer[] { substituted lists
 368    *         for each token }, String[] { url } }
 369    * @throws UrlStringTooLongException
 370    */
 371   public Object[] makeUrls(String[] idstrings, String[] seqstrings,
 372           String dsstring, boolean onlyIfMatches)
 373           throws UrlStringTooLongException
 374   {
 375     Hashtable rstrings = replacementArgs(idstrings, seqstrings, dsstring);
 376     return makeUrls(rstrings, onlyIfMatches);
 377   }
 378
 379   /**
 380    * gathers input into a hashtable
 381    *
 382    * @param idstrings
 383    * @param seqstrings
 384    * @param dsstring
 385    * @return
 386    */
 387   private Hashtable replacementArgs(String[] idstrings,
 388           String[] seqstrings, String dsstring)
 389   {
 390     Hashtable rstrings = new Hashtable();
 391     rstrings.put(tokens[0], idstrings);
 392     rstrings.put(tokens[1], seqstrings);
 393     rstrings.put(tokens[2], new String[]
 394     { dsstring });
 395     if (idstrings.length != seqstrings.length)
 396     {
 397       throw new Error(
 398               "idstrings and seqstrings contain one string each per sequence.");
 399     }
 400     return rstrings;
 401   }
 402
 403   public Object[] makeUrls(Hashtable repstrings, boolean onlyIfMatches)
 404           throws UrlStringTooLongException
 405   {
 406     return makeUrlsIf(true, repstrings, onlyIfMatches);
 407   }
 408
 409   /**
 410    *
 411    * @param ids
 412    * @param seqstr
 413    * @param string
 414    * @param b
 415    * @return URL stub objects ready to pass to constructFrom
 416    * @throws UrlStringTooLongException
 417    */
 418   public Object[] makeUrlStubs(String[] ids, String[] seqstr,
 419           String string, boolean b) throws UrlStringTooLongException
 420   {
 421     Hashtable rstrings = replacementArgs(ids, seqstr, string);
 422     Object[] stubs = makeUrlsIf(false, rstrings, b);
 423     if (stubs != null)
 424     {
 425       return new Object[]
 426       { stubs[0], stubs[1], rstrings, new boolean[]
 427       { b } };
 428     }
 429     // TODO Auto-generated method stub
 430     return null;
 431   }
 432
 433   /**
 434    * generate the URL for the given URL stub object array returned from
 435    * makeUrlStubs
 436    *
 437    * @param stubs
 438    * @return URL string.
 439    * @throws UrlStringTooLongException
 440    */
 441   public String constructFrom(Object[] stubs)
 442           throws UrlStringTooLongException
 443   {
 444     Object[] results = makeUrlsIf(true, (Hashtable) stubs[2],
 445             ((boolean[]) stubs[3])[0]);
 446     return ((String[]) results[3])[0];
 447   }
 448
 449   /**
 450    * conditionally generate urls or stubs for a given input.
 451    *
 452    * @param createFullUrl
 453    *          set to false if you only want to test if URLs would be generated.
 454    * @param repstrings
 455    * @param onlyIfMatches
 456    * @return null if no url is generated. Object[] { int[] { number of matches
 457    *         seqs }, boolean[] { which matched }, (if createFullUrl also has
 458    *         StringBuffer[] { segment generated from inputs that is used in URL
 459    *         }, String[] { url })}
 460    * @throws UrlStringTooLongException
 461    */
 462   protected Object[] makeUrlsIf(boolean createFullUrl,
 463           Hashtable repstrings, boolean onlyIfMatches)
 464           throws UrlStringTooLongException
 465   {
 466     int pass = 0;
 467
 468     // prepare string arrays in correct order to be assembled into URL input
 469     String[][] idseq = new String[mtch.length][]; // indexed by pass
 470     int mins = 0, maxs = 0; // allowed two values, 1 or n-sequences.
 471     for (int i = 0; i < mtch.length; i++)
 472     {
 473       idseq[i] = (String[]) repstrings.get(mtch[i]);
 474       if (idseq[i].length >= 1)
 475       {
 476         if (mins == 0 && idseq[i].length == 1)
 477         {
 478           mins = 1;
 479         }
 480         if (maxs < 2)
 481         {
 482           maxs = idseq[i].length;
 483         }
 484         else
 485         {
 486           if (maxs != idseq[i].length)
 487           {
 488             throw new Error(
 489                     "Cannot have mixed length replacement vectors. Replacement vector for "
 490                             + (mtch[i]) + " is " + idseq[i].length
 491                             + " strings long, and have already seen a "
 492                             + maxs + " length vector.");
 493           }
 494         }
 495       }
 496       else
 497       {
 498         throw new Error(
 499                 "Cannot have zero length vector of replacement strings - either 1 value or n values.");
 500       }
 501     }
 502     // iterate through input, collating segments to be inserted into url
 503     StringBuffer matched[] = new StringBuffer[idseq.length];
 504     // and precompile regexes
 505     com.stevesoft.pat.Regex[] rgxs = new com.stevesoft.pat.Regex[matched.length];
 506     for (pass = 0; pass < matched.length; pass++)
 507     {
 508       matched[pass] = new StringBuffer();
 509       if (regexReplace[pass] != null)
 510       {
 511         rgxs[pass] = com.stevesoft.pat.Regex.perlCode("/"
 512                 + regexReplace[pass] + "/");
 513       }
 514       else
 515       {
 516         rgxs[pass] = null;
 517       }
 518     }
 519     // tot up the invariant lengths for this url
 520     int urllength = url_prefix.length();
 521     for (pass = 0; pass < matched.length; pass++)
 522     {
 523       urllength += url_suffix[pass].length();
 524     }
 525
 526     // flags to record which of the input sequences were actually used to
 527     // generate the
 528     // url
 529     boolean[] thismatched = new boolean[maxs];
 530     int seqsmatched = 0;
 531     for (int sq = 0; sq < maxs; sq++)
 532     {
 533       // initialise flag for match
 534       thismatched[sq] = false;
 535       StringBuffer[] thematches = new StringBuffer[rgxs.length];
 536       for (pass = 0; pass < rgxs.length; pass++)
 537       {
 538         thematches[pass] = new StringBuffer(); // initialise - in case there are
 539                                                // no more
 540         // matches.
 541         // if a regex is provided, then it must match for all sequences in all
 542         // tokens for it to be considered.
 543         if (idseq[pass].length <= sq)
 544         {
 545           // no more replacement strings to try for this token
 546           continue;
 547         }
 548         if (rgxs[pass] != null)
 549         {
 550           com.stevesoft.pat.Regex rg = rgxs[pass];
 551           int rematchat = 0;
 552           // concatenate all matches of re in the given string!
 553           while (rg.searchFrom(idseq[pass][sq], rematchat))
 554           {
 555             rematchat = rg.matchedTo();
 556             thismatched[sq] |= true;
 557             urllength += rg.charsMatched(); // count length
 558             if ((urllength + 32) > Platform.getMaxCommandLineLength())
 559             {
 560               throw new UrlStringTooLongException(urllength);
 561             }
 562
 563             if (!createFullUrl)
 564             {
 565               continue; // don't bother making the URL replacement text.
 566             }
 567             // do we take the cartesian products of the substituents ?
 568             int ns = rg.numSubs();
 569             if (ns == 0)
 570             {
 571               thematches[pass].append(rg.stringMatched());// take whole regex
 572             }
 573             /*
 574              * else if (ns==1) { // take only subgroup match return new String[]
 575              * { rg.stringMatched(1), url_prefix+rg.stringMatched(1)+url_suffix
 576              * }; }
 577              */
 578             // deal with multiple submatch case - for moment we do the simplest
 579             // - concatenate the matched regions, instead of creating a complete
 580             // list for each alternate match over all sequences.
 581             // TODO: specify a 'replace pattern' - next refinement
 582             else
 583             {
 584               // debug
 585               /*
 586                * for (int s = 0; s <= rg.numSubs(); s++) {
 587                * System.err.println("Sub " + s + " : " + rg.matchedFrom(s) +
 588                * " : " + rg.matchedTo(s) + " : '" + rg.stringMatched(s) + "'");
 589                * }
 590                */
 591               // try to collate subgroup matches
 592               StringBuffer subs = new StringBuffer();
 593               // have to loop through submatches, collating them at top level
 594               // match
 595               int s = 0; // 1;
 596               while (s <= ns)
 597               {
 598                 if (s + 1 <= ns && rg.matchedTo(s) > -1
 599                         && rg.matchedTo(s + 1) > -1
 600                         && rg.matchedTo(s + 1) < rg.matchedTo(s))
 601                 {
 602                   // s is top level submatch. search for submatches enclosed by
 603                   // this one
 604                   int r = s + 1;
 605                   StringBuffer rmtch = new StringBuffer();
 606                   while (r <= ns && rg.matchedTo(r) <= rg.matchedTo(s))
 607                   {
 608                     if (rg.matchedFrom(r) > -1)
 609                     {
 610                       rmtch.append(rg.stringMatched(r));
 611                     }
 612                     r++;
 613                   }
 614                   if (rmtch.length() > 0)
 615                   {
 616                     subs.append(rmtch); // simply concatenate
 617                   }
 618                   s = r;
 619                 }
 620                 else
 621                 {
 622                   if (rg.matchedFrom(s) > -1)
 623                   {
 624                     subs.append(rg.stringMatched(s)); // concatenate
 625                   }
 626                   s++;
 627                 }
 628               }
 629               thematches[pass].append(subs);
 630             }
 631           }
 632         }
 633         else
 634         {
 635           // are we only supposed to take regex matches ?
 636           if (!onlyIfMatches)
 637           {
 638             thismatched[sq] |= true;
 639             urllength += idseq[pass][sq].length(); // tot up length
 640             if (createFullUrl)
 641             {
 642               thematches[pass] = new StringBuffer(idseq[pass][sq]); // take
 643                                                                     // whole
 644                                                                     // string -
 645               // regardless - probably not a
 646               // good idea!
 647               /*
 648                * TODO: do some boilerplate trimming of the fields to make them
 649                * sensible e.g. trim off any 'prefix' in the id string (see
 650                * UrlLink for the below) - pre 2.4 Jalview behaviour if
 651                * (idstring.indexOf("|") > -1) { idstring =
 652                * idstring.substring(idstring.lastIndexOf("|") + 1); }
 653                */
 654             }
 655
 656           }
 657         }
 658       }
 659
 660       // check if we are going to add this sequence's results ? all token
 661       // replacements must be valid for this to happen!
 662       // (including single value replacements - eg. dataset name)
 663       if (thismatched[sq])
 664       {
 665         if (createFullUrl)
 666         {
 667           for (pass = 0; pass < matched.length; pass++)
 668           {
 669             if (idseq[pass].length > 1 && matched[pass].length() > 0)
 670             {
 671               matched[pass].append(separators[pass]);
 672             }
 673             matched[pass].append(thematches[pass]);
 674           }
 675         }
 676         seqsmatched++;
 677       }
 678     }
 679     // finally, if any sequences matched, then form the URL and return
 680     if (seqsmatched == 0 || (createFullUrl && matched[0].length() == 0))
 681     {
 682       // no matches - no url generated
 683       return null;
 684     }
 685     // check if we are beyond the feasible command line string limit for this
 686     // platform
 687     if ((urllength + 32) > Platform.getMaxCommandLineLength())
 688     {
 689       throw new UrlStringTooLongException(urllength);
 690     }
 691     if (!createFullUrl)
 692     {
 693       // just return the essential info about what the URL would be generated
 694       // from
 695       return new Object[]
 696       { new int[]
 697       { seqsmatched }, thismatched };
 698     }
 699     // otherwise, create the URL completely.
 700
 701     StringBuffer submiturl = new StringBuffer();
 702     submiturl.append(url_prefix);
 703     for (pass = 0; pass < matched.length; pass++)
 704     {
 705       submiturl.append(matched[pass]);
 706       if (url_suffix[pass] != null)
 707       {
 708         submiturl.append(url_suffix[pass]);
 709       }
 710     }
 711
 712     return new Object[]
 713     { new int[]
 714     { seqsmatched }, thismatched, matched, new String[]
 715     { submiturl.toString() } };
 716   }
 717
 718   /**
 719    *
 720    * @param urlstub
 721    * @return number of distinct sequence (id or seuqence) replacements predicted
 722    *         for this stub
 723    */
 724   public int getNumberInvolved(Object[] urlstub)
 725   {
 726     return ((int[]) urlstub[0])[0]; // returns seqsmatched from
 727                                     // makeUrlsIf(false,...)
 728   }
 729
 730   /**
 731    * get token types present in this url as a bitfield indicating presence of
 732    * each token from tokens (LSB->MSB).
 733    *
 734    * @return groupURL class as integer
 735    */
 736   public int getGroupURLType()
 737   {
 738     int r = 0;
 739     for (int pass = 0; pass < tokens.length; pass++)
 740     {
 741       for (int i = 0; i < mtch.length; i++)
 742       {
 743         if (mtch[i].equals(tokens[pass]))
 744         {
 745           r += 1 << pass;
 746         }
 747       }
 748     }
 749     return r;
 750   }
 751
 752   public String toString()
 753   {
 754     StringBuffer result = new StringBuffer();
 755     result.append(label + "|" + url_prefix);
 756     int r;
 757     for (r = 0; r < url_suffix.length; r++)
 758     {
 759       result.append("$");
 760       result.append(mtch[r]);
 761       if (regexReplace[r] != null)
 762       {
 763         result.append("=/");
 764         result.append(regexReplace[r]);
 765         result.append("/=");
 766       }
 767       result.append("$");
 768       result.append(url_suffix[r]);
 769     }
 770     for (r = 0; r < separators.length; r++)
 771     {
 772       result.append("|");
 773       result.append(separators[r]);
 774     }
 775     return result.toString();
 776   }
 777
 778   /**
 779    * report stats about the generated url string given an input set
 780    *
 781    * @param ul
 782    * @param idstring
 783    * @param url
 784    */
 785   private static void testUrls(GroupUrlLink ul, String[][] idstring,
 786           Object[] url)
 787   {
 788
 789     if (url == null)
 790     {
 791       System.out.println("Created NO urls.");
 792     }
 793     else
 794     {
 795       System.out.println("Created a url from " + ((int[]) url[0])[0]
 796               + "out of " + idstring[0].length + " sequences.");
 797       System.out.println("Sequences that did not match:");
 798       for (int sq = 0; sq < idstring[0].length; sq++)
 799       {
 800         if (!((boolean[]) url[1])[sq])
 801         {
 802           System.out.println("Seq " + sq + ": " + idstring[0][sq] + "\t: "
 803                   + idstring[1][sq]);
 804         }
 805       }
 806       System.out.println("Sequences that DID match:");
 807       for (int sq = 0; sq < idstring[0].length; sq++)
 808       {
 809         if (((boolean[]) url[1])[sq])
 810         {
 811           System.out.println("Seq " + sq + ": " + idstring[0][sq] + "\t: "
 812                   + idstring[1][sq]);
 813         }
 814       }
 815       System.out.println("The generated URL:");
 816       System.out.println(((String[]) url[3])[0]);
 817     }
 818   }
 819
 820   public static void main(String argv[])
 821   {
 822     String[] links = new String[]
 823     {
 824         "EnVision2|IDS|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=linkInDatasetFromJalview&input=$SEQUENCEIDS$&inputType=0|,",
 825         "EnVision2|Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=linkInDatasetFromJalview&input=$SEQUENCES$&inputType=1|,",
 826         "EnVision2|IDS|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=$DATASETID$&input=$SEQUENCEIDS$&inputType=0|,",
 827         "EnVision2|Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=$DATASETID$&input=$SEQUENCES$&inputType=1|,",
 828         "EnVision2|IDS|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=$SEQUENCEIDS$&datasetName=linkInDatasetFromJalview&input=$SEQUENCEIDS$&inputType=0|,",
 829         "EnVision2|Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=$SEQUENCEIDS$&datasetName=$DATASETID$&input=$SEQUENCES$&inputType=1|,",
 830         "EnVision2 Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Default&datasetName=JalviewSeqs$DATASETID$&input=$SEQUENCES=/([a-zA-Z]+)/=$&inputType=1|,",
 831         "EnVision2 Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Default&datasetName=JalviewSeqs$DATASETID$&input=$SEQUENCES=/[A-Za-z]+/=$&inputType=1|,"
 832     /*
 833      * http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?input=P38389,P38398
 834      * &inputType=0&workflow=Enfin%20Default%20Workflow&datasetName=
 835      * linkInDatasetFromPRIDE
 836      */
 837     };
 838
 839     SequenceI[] seqs = new SequenceI[]
 840     { new Sequence("StupidLabel:gi|9234|pdb|102L|A",
 841             "asdiasdpasdpadpwpadasdpaspdw"), };
 842     String[][] seqsandids = formStrings(seqs);
 843     for (int i = 0; i < links.length; i++)
 844     {
 845       GroupUrlLink ul = new GroupUrlLink(links[i]);
 846       if (ul.isValid())
 847       {
 848         System.out.println("\n\n\n");
 849         System.out.println("Link " + i + " " + links[i] + " : "
 850                 + ul.toString());
 851         System.out.println(" pref : " + ul.getUrl_prefix());
 852         System.out.println(" IdReplace : " + ul.getIDRegexReplace());
 853         System.out.println(" SeqReplace : " + ul.getSeqRegexReplace());
 854         System.out.println(" Suffixes : " + ul.getUrl_suffix());
 855
 856         System.out
 857                 .println("<insert input id and sequence strings here> Without onlyIfMatches:");
 858         Object[] urls;
 859         try
 860         {
 861           urls = ul.makeUrls(seqsandids[0], seqsandids[1], "mydataset",
 862                   false);
 863           testUrls(ul, seqsandids, urls);
 864         } catch (UrlStringTooLongException ex)
 865         {
 866           System.out.println("too long exception " + ex);
 867         }
 868         System.out
 869                 .println("<insert input id and sequence strings here> With onlyIfMatches set:");
 870         try
 871         {
 872           urls = ul.makeUrls(seqsandids[0], seqsandids[1], "mydataset",
 873                   true);
 874           testUrls(ul, seqsandids, urls);
 875         } catch (UrlStringTooLongException ex)
 876         {
 877           System.out.println("too long exception " + ex);
 878         }
 879       }
 880       else
 881       {
 882         System.err.println("Invalid URLLink : " + links[i] + " : "
 883                 + ul.getInvalidMessage());
 884       }
 885     }
 886   }
 887
 888   /**
 889    * covenience method to generate the id and sequence string vector from a set
 890    * of seuqences using each sequence's getName() and getSequenceAsString()
 891    * method
 892    *
 893    * @param seqs
 894    * @return String[][] {{sequence ids},{sequence strings}}
 895    */
 896   public static String[][] formStrings(SequenceI[] seqs)
 897   {
 898     String[][] idset = new String[2][seqs.length];
 899     for (int i = 0; i < seqs.length; i++)
 900     {
 901       idset[0][i] = seqs[i].getName();
 902       idset[1][i] = seqs[i].getSequenceAsString();
 903     }
 904     return idset;
 905   }
 906
 907   public void setLabel(String newlabel)
 908   {
 909     this.label = newlabel;
 910   }
 911
 912 }