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