2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
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.
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.
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.
23 import jalview.datamodel.SequenceI;
25 import java.util.Hashtable;
28 * This class is not implemented because Preferences never puts anything in
34 public class GroupUrlLink
36 @SuppressWarnings("serial")
37 public class UrlStringTooLongException extends Exception
39 public UrlStringTooLongException(int lng)
47 public String toString()
49 return "Generated url is estimated to be too long (" + urlLength
55 * Helper class based on the UrlLink class which enables URLs to be
56 * constructed from sequences or IDs associated with a group of sequences. URL
57 * definitions consist of a pipe separated string containing a <label>|<url
58 * construct>|<separator character>[|<sequence separator character>]. The url
59 * construct includes regex qualified tokens which are replaced with seuqence
60 * IDs ($SEQUENCE_IDS$) and/or seuqence regions ($SEQUENCES$) that are
61 * extracted from the group. See <code>UrlLink</code> for more information
62 * about the approach, and the original implementation. Documentation to come.
63 * Note - groupUrls can be very big!
65 private String url_prefix, target, label;
68 * these are all filled in order of the occurence of each token in the url
71 private String url_suffix[], separators[], regexReplace[];
73 private String invalidMessage = null;
76 * position of each token (which can appear once only) in the url
81 * contains tokens in the order they appear in the URL template.
83 private String[] mtch;
86 * tokens that can be replaced in the URL.
88 private static final String[] tokens = new String[] { "SEQUENCEIDS",
89 "SEQUENCES", "DATASETID" };
92 // * test for GroupURLType bitfield (with default tokens)
94 // private static final int SEQUENCEIDS = 1;
97 // * test for GroupURLType bitfield (with default tokens)
99 // private static final int SEQUENCES = 2;
102 // * test for GroupURLType bitfield (with default tokens)
104 // private static final int DATASETID = 4;
106 // private int idseg = -1, seqseg = -1;
110 * called by PopupMenu.buildGroupURLMenu()
112 * parse the given linkString of the form '<label>|<url>|separator
113 * char[|optional sequence separator char]' into parts. url may contain a
114 * string $SEQUENCEIDS<=optional regex=>$ where <=optional regex=> must be of
115 * the form =/<perl style regex>/=$ or $SEQUENCES<=optional regex=>$ or
116 * $SEQUENCES<=optional regex=>$.
120 public GroupUrlLink(String link)
122 int sep = link.indexOf("|");
123 segs = new int[tokens.length];
125 for (int i = 0; i < segs.length; i++)
127 if ((segs[i] = link.indexOf("$" + tokens[i])) > -1)
132 // expect at least one token
135 invalidMessage = "Group URL string must contain at least one of ";
136 for (int i = 0; i < segs.length; i++)
138 invalidMessage += " '$" + tokens[i] + "[=/regex=/]$'";
143 int[] ptok = new int[ntoks + 1];
144 String[] tmtch = new String[ntoks + 1];
145 mtch = new String[ntoks];
146 for (int i = 0, t = 0; i < segs.length; i++)
151 tmtch[t++] = tokens[i];
154 ptok[ntoks] = link.length();
155 tmtch[ntoks] = "$$$$$$$$$";
156 jalview.util.QuickSort.sort(ptok, tmtch);
157 for (int i = 0; i < ntoks; i++)
159 mtch[i] = tmtch[i]; // TODO: check order is ascending
162 * replaces the specific code below {}; if (psqids > -1 && pseqs > -1) { if
163 * (psqids > pseqs) { idseg = 1; seqseg = 0;
165 * ptok = new int[] { pseqs, psqids, link.length() }; mtch = new String[] {
166 * "$SEQUENCES", "$SEQUENCEIDS" }; } else { idseg = 0; seqseg = 1; ptok =
167 * new int[] { psqids, pseqs, link.length() }; mtch = new String[] {
168 * "$SEQUENCEIDS", "$SEQUENCES" }; } } else { if (psqids != -1) { idseg = 0;
169 * ptok = new int[] { psqids, link.length() }; mtch = new String[] {
170 * "$SEQUENCEIDS" }; } else { seqseg = 0; ptok = new int[] { pseqs,
171 * link.length() }; mtch = new String[] { "$SEQUENCES" }; } }
175 // first get the label and target part before the first |
179 p = link.indexOf("|", sep + 1);
180 } while (p > sep && p < ptok[0]);
181 // Assuming that the URL itself does not contain any '|' symbols
182 // sep now contains last pipe symbol position prior to any regex symbols
183 label = link.substring(0, sep);
184 if (label.indexOf("|") > -1)
186 // | terminated database name / www target at start of Label
187 target = label.substring(0, label.indexOf("|"));
189 else if (label.indexOf(" ") > 2)
191 // space separated Label - matches database name
192 target = label.substring(0, label.indexOf(" "));
198 // Now Parse URL : Whole URL string first
199 url_prefix = link.substring(sep + 1, ptok[0]);
200 url_suffix = new String[mtch.length];
201 regexReplace = new String[mtch.length];
202 // and loop through tokens
203 for (int pass = 0; pass < mtch.length; pass++)
205 int mlength = 3 + mtch[pass].length();
206 if (link.indexOf("$" + mtch[pass] + "=/") == ptok[pass] && (p = link
207 .indexOf("/=$", ptok[pass] + mlength)) > ptok[pass] + mlength)
209 // Extract Regex and suffix
210 if (ptok[pass + 1] < p + 3)
212 // tokens are not allowed inside other tokens - e.g. inserting a
213 // $sequences$ into the regex match for the sequenceid
214 invalidMessage = "Token regexes cannot contain other regexes (did you terminate the $"
215 + mtch[pass] + " regex with a '/=$' ?";
218 url_suffix[pass] = link.substring(p + 3, ptok[pass + 1]);
219 regexReplace[pass] = link.substring(ptok[pass] + mlength, p);
222 com.stevesoft.pat.Regex rg = com.stevesoft.pat.Regex
223 .perlCode("/" + regexReplace[pass] + "/");
226 invalidMessage = "Invalid Regular Expression : '"
227 + regexReplace[pass] + "'\n";
229 } catch (Exception e)
231 invalidMessage = "Invalid Regular Expression : '"
232 + regexReplace[pass] + "'\n";
237 regexReplace[pass] = null;
238 // verify format is really correct.
239 if ((p = link.indexOf("$" + mtch[pass] + "$")) == ptok[pass])
241 url_suffix[pass] = link.substring(p + mtch[pass].length() + 2,
246 invalidMessage = "Warning: invalid regex structure (after '"
247 + mtch[0] + "') for URL link : " + link;
252 separators = new String[url_suffix.length];
253 String suffices = url_suffix[url_suffix.length - 1], lastsep = ",";
254 // have a look in the last suffix for any more separators.
255 while ((p = suffices.indexOf('|')) > -1)
257 separators[pass] = suffices.substring(p + 1);
260 // trim the original suffix string
261 url_suffix[url_suffix.length - 1] = suffices.substring(0, p);
265 lastsep = (separators[pass - 1] = separators[pass - 1].substring(0,
268 suffices = separators[pass];
273 lastsep = separators[pass - 1];
275 // last separator is always used for all the remaining separators
276 while (pass < separators.length)
278 separators[pass++] = lastsep;
283 * @return the url_suffix
285 public String getUrl_suffix()
287 return url_suffix[url_suffix.length - 1];
292 * called by PopupMenu.addShowLink()
294 * @return the url_prefix
296 public String getUrl_prefix()
302 * called by PopupMenu.buildGroupURLMenu()
306 public String getTarget()
313 * called by PopupMenu.buildGroupURLMenu()
317 public String getLabel()
324 * called by PopupMenu.buildGroupURLMenu()
326 * @return the invalidMessage
328 public String getInvalidMessage()
330 return invalidMessage;
334 * called by PopupMenu.buildGroupURLMenu()
336 * Check if URL string was parsed properly.
338 * @return boolean - if false then <code>getInvalidMessage</code> returns an
341 public boolean isValid()
343 return invalidMessage == null;
348 * called by PopupMenu.buildGroupURLMenu()
350 * This method is never called, because PopupMenu.buildGroupMenu() is never
351 * called. It relates to the popup menu for the idPanel.
356 * @param onlyIfMatches
357 * @return URL stub objects ready to pass to constructFrom in the form of
358 * Object[] { int[], boolean[], Hashtable<String, String[]>,
360 * @throws UrlStringTooLongException
362 public Object[] makeUrlStubs(String[] ids, String[] seqstr, String string,
363 boolean onlyIfMatches) throws UrlStringTooLongException
365 Hashtable<String, String[]> rstrings = replacementArgs(ids, seqstr,
367 boolean createFullURL = false;
368 Object[] stubs = makeUrlsIf(createFullURL, rstrings, onlyIfMatches);
369 // stubs is just { int[] boolean[] }
370 return stubs == null ? null
372 { stubs[0], stubs[1], rstrings,
374 { onlyIfMatches } }; // int[] boolean[] Hashtable boolean[]
378 * gathers input into a hashtable
385 private Hashtable<String, String[]> replacementArgs(String[] idstrings,
386 String[] seqstrings, String dsstring)
388 Hashtable<String, String[]> rstrings = new Hashtable<>();
389 rstrings.put(tokens[0], idstrings);
390 rstrings.put(tokens[1], seqstrings);
391 rstrings.put(tokens[2], new String[] { dsstring });
392 if (idstrings.length != seqstrings.length)
394 throw new Error(MessageManager.getString(
395 "error.idstring_seqstrings_only_one_per_sequence"));
401 * Called from PopupMenu.addShowLink action listener
403 * generate the URL for the given URL stub object array returned from
407 * Object[] { int[] { number of matches seqs }, boolean[] { which
408 * matched }, (if createFullUrl also has StringBuffer[] { segment
409 * generated from inputs that is used in URL }, String[] { url })}
411 * @throws UrlStringTooLongException
413 @SuppressWarnings("unchecked")
414 public String constructFrom(Object[] stubs)
415 throws UrlStringTooLongException
418 // int[] { number of matches seqs },
419 // boolean[] { which matched }
422 boolean createFullURL = true;
423 Hashtable<String, String[]> repstrings = (Hashtable<String, String[]>) stubs[2];
424 boolean onlyIfMatches = ((boolean[]) stubs[3])[0];
425 String url = ((String[]) makeUrlsIf(createFullURL, repstrings,
426 onlyIfMatches)[3])[0];
431 * conditionally generate urls or stubs for a given input.
433 * @param createFullUrl
434 * set to false if you only want to test if URLs would be generated.
436 * @param onlyIfMatches
437 * @return null if no url is generated. Object[] { int[] { number of matches
438 * seqs }, boolean[] { which matched }, (if createFullUrl also has
439 * StringBuffer[] { segment generated from inputs that is used in URL
440 * }, String[] { url })}
441 * @throws UrlStringTooLongException
443 private Object[] makeUrlsIf(boolean createFullUrl,
444 Hashtable<String, String[]> repstrings,
445 boolean onlyIfMatches) throws UrlStringTooLongException
449 // prepare string arrays in correct order to be assembled into URL input
450 String[][] idseq = new String[mtch.length][]; // indexed by pass
451 int mins = 0, maxs = 0; // allowed two values, 1 or n-sequences.
452 for (int i = 0; i < mtch.length; i++)
454 idseq[i] = repstrings.get(mtch[i]);
455 if (idseq[i].length >= 1)
457 if (mins == 0 && idseq[i].length == 1)
463 maxs = idseq[i].length;
467 if (maxs != idseq[i].length)
469 throw new Error(MessageManager.formatMessage(
470 "error.cannot_have_mixed_length_replacement_vectors",
473 Integer.valueOf(idseq[i].length).toString(),
474 Integer.valueOf(maxs).toString() }));
480 throw new Error(MessageManager.getString(
481 "error.cannot_have_zero_length_vector_replacement_strings"));
484 // iterate through input, collating segments to be inserted into url
485 StringBuffer matched[] = new StringBuffer[idseq.length];
486 // and precompile regexes
487 com.stevesoft.pat.Regex[] rgxs = new com.stevesoft.pat.Regex[matched.length];
488 for (pass = 0; pass < matched.length; pass++)
490 matched[pass] = new StringBuffer();
491 if (regexReplace[pass] != null)
493 rgxs[pass] = com.stevesoft.pat.Regex
494 .perlCode("/" + regexReplace[pass] + "/");
501 // tot up the invariant lengths for this url
502 int urllength = url_prefix.length();
503 for (pass = 0; pass < matched.length; pass++)
505 urllength += url_suffix[pass].length();
508 // flags to record which of the input sequences were actually used to
511 boolean[] thismatched = new boolean[maxs];
513 for (int sq = 0; sq < maxs; sq++)
515 // initialise flag for match
516 thismatched[sq] = false;
517 StringBuffer[] thematches = new StringBuffer[rgxs.length];
518 for (pass = 0; pass < rgxs.length; pass++)
520 thematches[pass] = new StringBuffer(); // initialise - in case there are
523 // if a regex is provided, then it must match for all sequences in all
524 // tokens for it to be considered.
525 if (idseq[pass].length <= sq)
527 // no more replacement strings to try for this token
530 if (rgxs[pass] != null)
532 com.stevesoft.pat.Regex rg = rgxs[pass];
534 // concatenate all matches of re in the given string!
535 while (rg.searchFrom(idseq[pass][sq], rematchat))
537 rematchat = rg.matchedTo();
538 thismatched[sq] |= true;
539 urllength += rg.charsMatched(); // count length
540 if ((urllength + 32) > Platform.getMaxCommandLineLength())
542 throw new UrlStringTooLongException(urllength);
547 continue; // don't bother making the URL replacement text.
549 // do we take the cartesian products of the substituents ?
550 int ns = rg.numSubs();
553 thematches[pass].append(rg.stringMatched());// take whole regex
556 * else if (ns==1) { // take only subgroup match return new String[]
557 * { rg.stringMatched(1), url_prefix+rg.stringMatched(1)+url_suffix
560 // deal with multiple submatch case - for moment we do the simplest
561 // - concatenate the matched regions, instead of creating a complete
562 // list for each alternate match over all sequences.
563 // TODO: specify a 'replace pattern' - next refinement
568 * for (int s = 0; s <= rg.numSubs(); s++) {
569 * System.err.println("Sub " + s + " : " + rg.matchedFrom(s) +
570 * " : " + rg.matchedTo(s) + " : '" + rg.stringMatched(s) + "'");
573 // try to collate subgroup matches
574 StringBuffer subs = new StringBuffer();
575 // have to loop through submatches, collating them at top level
580 if (s + 1 <= ns && rg.matchedTo(s) > -1
581 && rg.matchedTo(s + 1) > -1
582 && rg.matchedTo(s + 1) < rg.matchedTo(s))
584 // s is top level submatch. search for submatches enclosed by
587 StringBuffer rmtch = new StringBuffer();
588 while (r <= ns && rg.matchedTo(r) <= rg.matchedTo(s))
590 if (rg.matchedFrom(r) > -1)
592 rmtch.append(rg.stringMatched(r));
596 if (rmtch.length() > 0)
598 subs.append(rmtch); // simply concatenate
604 if (rg.matchedFrom(s) > -1)
606 subs.append(rg.stringMatched(s)); // concatenate
611 thematches[pass].append(subs);
617 // are we only supposed to take regex matches ?
620 thismatched[sq] |= true;
621 urllength += idseq[pass][sq].length(); // tot up length
624 thematches[pass] = new StringBuffer(idseq[pass][sq]); // take
627 // regardless - probably not a
630 * TODO: do some boilerplate trimming of the fields to make them
631 * sensible e.g. trim off any 'prefix' in the id string (see
632 * UrlLink for the below) - pre 2.4 Jalview behaviour if
633 * (idstring.indexOf("|") > -1) { idstring =
634 * idstring.substring(idstring.lastIndexOf("|") + 1); }
642 // check if we are going to add this sequence's results ? all token
643 // replacements must be valid for this to happen!
644 // (including single value replacements - eg. dataset name)
649 for (pass = 0; pass < matched.length; pass++)
651 if (idseq[pass].length > 1 && matched[pass].length() > 0)
653 matched[pass].append(separators[pass]);
655 matched[pass].append(thematches[pass]);
661 // finally, if any sequences matched, then form the URL and return
662 if (seqsmatched == 0 || (createFullUrl && matched[0].length() == 0))
664 // no matches - no url generated
667 // check if we are beyond the feasible command line string limit for this
669 if ((urllength + 32) > Platform.getMaxCommandLineLength())
671 throw new UrlStringTooLongException(urllength);
675 // just return the essential info about what the URL would be generated
677 return new Object[] { new int[] { seqsmatched }, thismatched // boolean[]
680 // otherwise, create the URL completely.
682 StringBuffer submiturl = new StringBuffer();
683 submiturl.append(url_prefix);
684 for (pass = 0; pass < matched.length; pass++)
686 submiturl.append(matched[pass]);
687 if (url_suffix[pass] != null)
689 submiturl.append(url_suffix[pass]);
694 return new Object[] { new int[] { seqsmatched }, thismatched, // boolean[]
695 matched, // StringBuffer[]
697 { submiturl.toString() } };
702 * Called by PopupMenu.addShowLinks()
705 * @return number of distinct sequence (id or seuqence) replacements predicted
708 public int getNumberInvolved(Object[] urlstub)
710 return ((int[]) urlstub[0])[0]; // returns seqsmatched from
711 // makeUrlsIf(false,...)
715 * called by PopupMenu.buildGroupURLMenu()
717 * get token types present in this url as a bitfield indicating presence of
718 * each token from tokens (LSB->MSB).
720 * @return groupURL class as integer
722 public int getGroupURLType()
725 for (int pass = 0; pass < tokens.length; pass++)
727 for (int i = 0; i < mtch.length; i++)
729 if (mtch[i].equals(tokens[pass]))
739 * called by PopupMenu.buildGroupURLMenu()
741 * covenience method to generate the id and sequence string vector from a set
742 * of seuqences using each sequence's getName() and getSequenceAsString()
746 * @return String[][] {{sequence ids},{sequence strings}}
748 public static String[][] formStrings(SequenceI[] seqs)
750 String[][] idset = new String[2][seqs.length];
751 for (int i = 0; i < seqs.length; i++)
753 idset[0][i] = seqs[i].getName();
754 idset[1][i] = seqs[i].getSequenceAsString();
759 // commented out test code
766 // public static void main(String argv[])
768 // // note - JAL-1383 - these services are all dead
769 // String[] links = new String[] {
770 // "EnVision2|IDS|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=linkInDatasetFromJalview&input=$SEQUENCEIDS$&inputType=0|,",
771 // "EnVision2|Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=linkInDatasetFromJalview&input=$SEQUENCES$&inputType=1|,",
772 // "EnVision2|IDS|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=$DATASETID$&input=$SEQUENCEIDS$&inputType=0|,",
773 // "EnVision2|Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=$DATASETID$&input=$SEQUENCES$&inputType=1|,",
774 // "EnVision2|IDS|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=$SEQUENCEIDS$&datasetName=linkInDatasetFromJalview&input=$SEQUENCEIDS$&inputType=0|,",
775 // "EnVision2|Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=$SEQUENCEIDS$&datasetName=$DATASETID$&input=$SEQUENCES$&inputType=1|,",
777 // Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Default&datasetName=JalviewSeqs$DATASETID$&input=$SEQUENCES=/([a-zA-Z]+)/=$&inputType=1|,",
779 // Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Default&datasetName=JalviewSeqs$DATASETID$&input=$SEQUENCES=/[A-Za-z]+/=$&inputType=1|,"
782 // http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?input=P38389,P38398
783 // * &inputType=0&workflow=Enfin%20Default%20Workflow&datasetName=
784 // * linkInDatasetFromPRIDE
788 // SequenceI[] seqs = new SequenceI[] {
789 // new Sequence("StupidLabel:gi|9234|pdb|102L|A",
790 // "asdiasdpasdpadpwpadasdpaspdw"), };
791 // String[][] seqsandids = formStrings(seqs);
792 // for (int i = 0; i < links.length; i++)
794 // GroupUrlLink ul = new GroupUrlLink(links[i]);
797 // System.out.println("\n\n\n");
798 // System.out.println(
799 // "Link " + i + " " + links[i] + " : " + ul.toString());
800 // System.out.println(" pref : " + ul.getUrl_prefix());
801 // System.out.println(" IdReplace : " + ul.getIDRegexReplace());
802 // System.out.println(" SeqReplace : " + ul.getSeqRegexReplace());
803 // System.out.println(" Suffixes : " + ul.getUrl_suffix());
805 // System.out.println(
806 // "<insert input id and sequence strings here> Without onlyIfMatches:");
810 // urls = ul.makeUrls(seqsandids[0], seqsandids[1], "mydataset",
812 // testUrls(ul, seqsandids, urls);
813 // } catch (UrlStringTooLongException ex)
815 // System.out.println("too long exception " + ex);
817 // System.out.println(
818 // "<insert input id and sequence strings here> With onlyIfMatches set:");
821 // urls = ul.makeUrls(seqsandids[0], seqsandids[1], "mydataset",
823 // testUrls(ul, seqsandids, urls);
824 // } catch (UrlStringTooLongException ex)
826 // System.out.println("too long exception " + ex);
831 // System.err.println("Invalid URLLink : " + links[i] + " : "
832 // + ul.getInvalidMessage());
837 // * @return the sequence ID regexReplace
839 // private String getIDRegexReplace()
841 // String token = tokens[0];
842 // for (int i = 0; i < mtch.length; i++)
844 // if (segs[i] > -1 && mtch[i].equals(token))
846 // return regexReplace[i];
853 // * @return the sequence ID regexReplace
855 // private String getSeqRegexReplace()
857 // return _replaceFor(tokens[1]);
861 // * report stats about the generated url string given an input set
867 // private static void testUrls(GroupUrlLink ul, String[][] idstring,
873 // System.out.println("Created NO urls.");
877 // System.out.println("Created a url from " + ((int[]) url[0])[0]
878 // + "out of " + idstring[0].length + " sequences.");
879 // System.out.println("Sequences that did not match:");
880 // for (int sq = 0; sq < idstring[0].length; sq++)
882 // if (!((boolean[]) url[1])[sq])
884 // System.out.println("Seq " + sq + ": " + idstring[0][sq] + "\t: "
885 // + idstring[1][sq]);
888 // System.out.println("Sequences that DID match:");
889 // for (int sq = 0; sq < idstring[0].length; sq++)
891 // if (((boolean[]) url[1])[sq])
893 // System.out.println("Seq " + sq + ": " + idstring[0][sq] + "\t: "
894 // + idstring[1][sq]);
897 // System.out.println("The generated URL:");
898 // System.out.println(((String[]) url[3])[0]);
902 // public void setLabel(String newlabel)
904 // this.label = newlabel;
907 // * return one or more URL strings by applying regex to the given idstring
909 // * @param idstrings
910 // * array of id strings to pass to service
911 // * @param seqstrings
912 // * array of seq strings to pass to service
913 // * @param onlyIfMatches
914 // * - when true url strings are only made if regex is defined and
915 // * matches for all qualified tokens in groupURL - TODO: consider if
916 // * onlyIfMatches is really a useful parameter!
917 // * @return null or Object[] { int[] { number of seqs substituted},boolean[]
919 // * which seqs were substituted }, StringBuffer[] { substituted lists
920 // * for each token }, String[] { url } }
921 // * @throws UrlStringTooLongException
923 // private Object[] makeUrls(String[] idstrings, String[] seqstrings,
924 // String dsstring, boolean onlyIfMatches)
925 // throws UrlStringTooLongException
927 // Hashtable<String, String[]> rstrings = replacementArgs(idstrings,
928 // seqstrings, dsstring);
929 // return makeUrls(rstrings, onlyIfMatches);
934 // * @param repstrings
935 // * @param onlyIfMatches
936 // * @return Object[] {int[], boolean[], StringBuffer[], String[] }
937 // * @throws UrlStringTooLongException
939 // private Object[] makeUrls(Hashtable<String, String[]> repstrings,
940 // boolean onlyIfMatches)
941 // throws UrlStringTooLongException
943 // return makeUrlsIf(true, repstrings, onlyIfMatches);
948 public String toString()
950 StringBuffer result = new StringBuffer();
951 result.append(label + "|" + url_prefix);
953 for (r = 0; r < url_suffix.length; r++)
956 result.append(mtch[r]);
957 if (regexReplace[r] != null)
960 result.append(regexReplace[r]);
964 result.append(url_suffix[r]);
966 for (r = 0; r < separators.length; r++)
969 result.append(separators[r]);
971 return result.toString();