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