/*
* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
* Copyright (C) $$Year-Rel$$ The Jalview Authors
*
* This file is part of Jalview.
*
* Jalview is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 3
* of the License, or (at your option) any later version.
*
* Jalview is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Jalview. If not, see .
* The Jalview Authors are detailed in the 'AUTHORS' file.
*/
package jalview.util;
import jalview.datamodel.SequenceI;
import java.util.Hashtable;
import com.stevesoft.pat.Regex;
/**
* This class is not implemented because Preferences never puts anything in
* groupURLLinks.
*
* @author hansonr
*
*/
public class GroupUrlLink
{
@SuppressWarnings("serial")
public class UrlStringTooLongException extends Exception
{
public UrlStringTooLongException(int lng)
{
urlLength = lng;
}
public int urlLength;
@Override
public String toString()
{
return "Generated url is estimated to be too long (" + urlLength
+ ")";
}
}
/**
* Helper class based on the UrlLink class which enables URLs to be
* constructed from sequences or IDs associated with a group of sequences. URL
* definitions consist of a pipe separated string containing a ||[|]. The url
* construct includes regex qualified tokens which are replaced with seuqence
* IDs ($SEQUENCE_IDS$) and/or seuqence regions ($SEQUENCES$) that are
* extracted from the group. See UrlLink
for more information
* about the approach, and the original implementation. Documentation to come.
* Note - groupUrls can be very big!
*/
private String url_prefix, target, label;
/**
* these are all filled in order of the occurence of each token in the url
* string template
*/
private String url_suffix[], separators[], regexReplace[];
private String invalidMessage = null;
/**
* position of each token (which can appear once only) in the url
*/
private int[] segs;
/**
* contains tokens in the order they appear in the URL template.
*/
private String[] mtch;
/**
* tokens that can be replaced in the URL.
*/
private static final String[] tokens = new String[] { "SEQUENCEIDS",
"SEQUENCES", "DATASETID" };
// /**
// * test for GroupURLType bitfield (with default tokens)
// */
// private static final int SEQUENCEIDS = 1;
//
// /**
// * test for GroupURLType bitfield (with default tokens)
// */
// private static final int SEQUENCES = 2;
//
// /**
// * test for GroupURLType bitfield (with default tokens)
// */
// private static final int DATASETID = 4;
//
// private int idseg = -1, seqseg = -1;
/**
*
* called by PopupMenu.buildGroupURLMenu()
*
* parse the given linkString of the form '||separator
* char[|optional sequence separator char]' into parts. url may contain a
* string $SEQUENCEIDS<=optional regex=>$ where <=optional regex=> must be of
* the form =//=$ or $SEQUENCES<=optional regex=>$ or
* $SEQUENCES<=optional regex=>$.
*
* @param link
*/
public GroupUrlLink(String link)
{
int sep = link.indexOf("|");
segs = new int[tokens.length];
int ntoks = 0;
for (int i = 0; i < segs.length; i++)
{
if ((segs[i] = link.indexOf("$" + tokens[i])) > -1)
{
ntoks++;
}
}
// expect at least one token
if (ntoks == 0)
{
invalidMessage = "Group URL string must contain at least one of ";
for (int i = 0; i < segs.length; i++)
{
invalidMessage += " '$" + tokens[i] + "[=/regex=/]$'";
}
return;
}
int[] ptok = new int[ntoks + 1];
String[] tmtch = new String[ntoks + 1];
mtch = new String[ntoks];
for (int i = 0, t = 0; i < segs.length; i++)
{
if (segs[i] > -1)
{
ptok[t] = segs[i];
tmtch[t++] = tokens[i];
}
}
ptok[ntoks] = link.length();
tmtch[ntoks] = "$$$$$$$$$";
jalview.util.QuickSort.sort(ptok, tmtch);
for (int i = 0; i < ntoks; i++)
{
mtch[i] = tmtch[i]; // TODO: check order is ascending
}
/*
* replaces the specific code below {}; if (psqids > -1 && pseqs > -1) { if
* (psqids > pseqs) { idseg = 1; seqseg = 0;
*
* ptok = new int[] { pseqs, psqids, link.length() }; mtch = new String[] {
* "$SEQUENCES", "$SEQUENCEIDS" }; } else { idseg = 0; seqseg = 1; ptok =
* new int[] { psqids, pseqs, link.length() }; mtch = new String[] {
* "$SEQUENCEIDS", "$SEQUENCES" }; } } else { if (psqids != -1) { idseg = 0;
* ptok = new int[] { psqids, link.length() }; mtch = new String[] {
* "$SEQUENCEIDS" }; } else { seqseg = 0; ptok = new int[] { pseqs,
* link.length() }; mtch = new String[] { "$SEQUENCES" }; } }
*/
int p = sep;
// first get the label and target part before the first |
do
{
sep = p;
p = link.indexOf("|", sep + 1);
} while (p > sep && p < ptok[0]);
// Assuming that the URL itself does not contain any '|' symbols
// sep now contains last pipe symbol position prior to any regex symbols
label = link.substring(0, sep);
if (label.indexOf("|") > -1)
{
// | terminated database name / www target at start of Label
target = label.substring(0, label.indexOf("|"));
}
else if (label.indexOf(" ") > 2)
{
// space separated Label - matches database name
target = label.substring(0, label.indexOf(" "));
}
else
{
target = label;
}
// Now Parse URL : Whole URL string first
url_prefix = link.substring(sep + 1, ptok[0]);
url_suffix = new String[mtch.length];
regexReplace = new String[mtch.length];
// and loop through tokens
for (int pass = 0; pass < mtch.length; pass++)
{
int mlength = 3 + mtch[pass].length();
if (link.indexOf("$" + mtch[pass] + "=/") == ptok[pass] && (p = link
.indexOf("/=$", ptok[pass] + mlength)) > ptok[pass] + mlength)
{
// Extract Regex and suffix
if (ptok[pass + 1] < p + 3)
{
// tokens are not allowed inside other tokens - e.g. inserting a
// $sequences$ into the regex match for the sequenceid
invalidMessage = "Token regexes cannot contain other regexes (did you terminate the $"
+ mtch[pass] + " regex with a '/=$' ?";
return;
}
url_suffix[pass] = link.substring(p + 3, ptok[pass + 1]);
regexReplace[pass] = link.substring(ptok[pass] + mlength, p);
try
{
Regex rg = Platform.newRegexPerl("/" + regexReplace[pass] + "/");
if (rg == null)
{
invalidMessage = "Invalid Regular Expression : '"
+ regexReplace[pass] + "'\n";
}
} catch (Exception e)
{
invalidMessage = "Invalid Regular Expression : '"
+ regexReplace[pass] + "'\n";
}
}
else
{
regexReplace[pass] = null;
// verify format is really correct.
if ((p = link.indexOf("$" + mtch[pass] + "$")) == ptok[pass])
{
url_suffix[pass] = link.substring(p + mtch[pass].length() + 2,
ptok[pass + 1]);
}
else
{
invalidMessage = "Warning: invalid regex structure (after '"
+ mtch[0] + "') for URL link : " + link;
}
}
}
int pass = 0;
separators = new String[url_suffix.length];
String suffices = url_suffix[url_suffix.length - 1], lastsep = ",";
// have a look in the last suffix for any more separators.
while ((p = suffices.indexOf('|')) > -1)
{
separators[pass] = suffices.substring(p + 1);
if (pass == 0)
{
// trim the original suffix string
url_suffix[url_suffix.length - 1] = suffices.substring(0, p);
}
else
{
lastsep = (separators[pass - 1] = separators[pass - 1].substring(0,
p));
}
suffices = separators[pass];
pass++;
}
if (pass > 0)
{
lastsep = separators[pass - 1];
}
// last separator is always used for all the remaining separators
while (pass < separators.length)
{
separators[pass++] = lastsep;
}
}
/**
* @return the url_suffix
*/
public String getUrl_suffix()
{
return url_suffix[url_suffix.length - 1];
}
/**
*
* called by PopupMenu.addShowLink()
*
* @return the url_prefix
*/
public String getUrl_prefix()
{
return url_prefix;
}
/**
* called by PopupMenu.buildGroupURLMenu()
*
* @return the target
*/
public String getTarget()
{
return target;
}
/**
*
* called by PopupMenu.buildGroupURLMenu()
*
* @return the label
*/
public String getLabel()
{
return label;
}
/**
*
* called by PopupMenu.buildGroupURLMenu()
*
* @return the invalidMessage
*/
public String getInvalidMessage()
{
return invalidMessage;
}
/**
* called by PopupMenu.buildGroupURLMenu()
*
* Check if URL string was parsed properly.
*
* @return boolean - if false then getInvalidMessage
returns an
* error message
*/
public boolean isValid()
{
return invalidMessage == null;
}
/**
*
* called by PopupMenu.buildGroupURLMenu()
*
* This method is never called, because PopupMenu.buildGroupMenu() is never
* called. It relates to the popup menu for the idPanel.
*
* @param ids
* @param seqstr
* @param string
* @param onlyIfMatches
* @return URL stub objects ready to pass to constructFrom in the form of
* Object[] { int[], boolean[], Hashtable<String, String[]>,
* boolean[] }
* @throws UrlStringTooLongException
*/
public Object[] makeUrlStubs(String[] ids, String[] seqstr, String string,
boolean onlyIfMatches) throws UrlStringTooLongException
{
Hashtable rstrings = replacementArgs(ids, seqstr,
string);
boolean createFullURL = false;
Object[] stubs = makeUrlsIf(createFullURL, rstrings, onlyIfMatches);
// stubs is just { int[] boolean[] }
return stubs == null ? null
: new Object[]
{ stubs[0], stubs[1], rstrings,
new boolean[]
{ onlyIfMatches } }; // int[] boolean[] Hashtable boolean[]
}
/**
* gathers input into a hashtable
*
* @param idstrings
* @param seqstrings
* @param dsstring
* @return
*/
private Hashtable replacementArgs(String[] idstrings,
String[] seqstrings, String dsstring)
{
Hashtable rstrings = new Hashtable<>();
rstrings.put(tokens[0], idstrings);
rstrings.put(tokens[1], seqstrings);
rstrings.put(tokens[2], new String[] { dsstring });
if (idstrings.length != seqstrings.length)
{
throw new Error(MessageManager.getString(
"error.idstring_seqstrings_only_one_per_sequence"));
}
return rstrings;
}
/**
* Called from PopupMenu.addShowLink action listener
*
* generate the URL for the given URL stub object array returned from
* makeUrlStubs
*
* @param stubs
* Object[] { int[] { number of matches seqs }, boolean[] { which
* matched }, (if createFullUrl also has StringBuffer[] { segment
* generated from inputs that is used in URL }, String[] { url })}
* @return URL string
* @throws UrlStringTooLongException
*/
@SuppressWarnings("unchecked")
public String constructFrom(Object[] stubs)
throws UrlStringTooLongException
{
// Object[] {
// int[] { number of matches seqs },
// boolean[] { which matched }
// }
boolean createFullURL = true;
Hashtable repstrings = (Hashtable) stubs[2];
boolean onlyIfMatches = ((boolean[]) stubs[3])[0];
String url = ((String[]) makeUrlsIf(createFullURL, repstrings,
onlyIfMatches)[3])[0];
return url;
}
/**
* conditionally generate urls or stubs for a given input.
*
* @param createFullUrl
* set to false if you only want to test if URLs would be generated.
* @param repstrings
* @param onlyIfMatches
* @return null if no url is generated. Object[] { int[] { number of matches
* seqs }, boolean[] { which matched }, (if createFullUrl also has
* StringBuffer[] { segment generated from inputs that is used in URL
* }, String[] { url })}
* @throws UrlStringTooLongException
*/
private Object[] makeUrlsIf(boolean createFullUrl,
Hashtable repstrings,
boolean onlyIfMatches) throws UrlStringTooLongException
{
int pass = 0;
// prepare string arrays in correct order to be assembled into URL input
String[][] idseq = new String[mtch.length][]; // indexed by pass
int mins = 0, maxs = 0; // allowed two values, 1 or n-sequences.
for (int i = 0; i < mtch.length; i++)
{
idseq[i] = repstrings.get(mtch[i]);
if (idseq[i].length >= 1)
{
if (mins == 0 && idseq[i].length == 1)
{
mins = 1;
}
if (maxs < 2)
{
maxs = idseq[i].length;
}
else
{
if (maxs != idseq[i].length)
{
throw new Error(MessageManager.formatMessage(
"error.cannot_have_mixed_length_replacement_vectors",
new String[]
{ (mtch[i]),
Integer.valueOf(idseq[i].length).toString(),
Integer.valueOf(maxs).toString() }));
}
}
}
else
{
throw new Error(MessageManager.getString(
"error.cannot_have_zero_length_vector_replacement_strings"));
}
}
// iterate through input, collating segments to be inserted into url
StringBuffer matched[] = new StringBuffer[idseq.length];
// and precompile regexes
Regex[] rgxs = new Regex[matched.length];
for (pass = 0; pass < matched.length; pass++)
{
matched[pass] = new StringBuffer();
if (regexReplace[pass] != null)
{
rgxs[pass] = Platform.newRegexPerl("/" + regexReplace[pass] + "/");
}
else
{
rgxs[pass] = null;
}
}
// tot up the invariant lengths for this url
int urllength = url_prefix.length();
for (pass = 0; pass < matched.length; pass++)
{
urllength += url_suffix[pass].length();
}
// flags to record which of the input sequences were actually used to
// generate the
// url
boolean[] thismatched = new boolean[maxs];
int seqsmatched = 0;
for (int sq = 0; sq < maxs; sq++)
{
// initialise flag for match
thismatched[sq] = false;
StringBuffer[] thematches = new StringBuffer[rgxs.length];
for (pass = 0; pass < rgxs.length; pass++)
{
thematches[pass] = new StringBuffer(); // initialise - in case there are
// no more
// matches.
// if a regex is provided, then it must match for all sequences in all
// tokens for it to be considered.
if (idseq[pass].length <= sq)
{
// no more replacement strings to try for this token
continue;
}
if (rgxs[pass] != null)
{
com.stevesoft.pat.Regex rg = rgxs[pass];
int rematchat = 0;
// concatenate all matches of re in the given string!
while (rg.searchFrom(idseq[pass][sq], rematchat))
{
rematchat = rg.matchedTo();
thismatched[sq] |= true;
urllength += rg.charsMatched(); // count length
if ((urllength + 32) > Platform.getMaxCommandLineLength())
{
throw new UrlStringTooLongException(urllength);
}
if (!createFullUrl)
{
continue; // don't bother making the URL replacement text.
}
// do we take the cartesian products of the substituents ?
int ns = rg.numSubs();
if (ns == 0)
{
thematches[pass].append(rg.stringMatched());// take whole regex
}
/*
* else if (ns==1) { // take only subgroup match return new String[]
* { rg.stringMatched(1), url_prefix+rg.stringMatched(1)+url_suffix
* }; }
*/
// deal with multiple submatch case - for moment we do the simplest
// - concatenate the matched regions, instead of creating a complete
// list for each alternate match over all sequences.
// TODO: specify a 'replace pattern' - next refinement
else
{
// debug
/*
* for (int s = 0; s <= rg.numSubs(); s++) {
* System.err.println("Sub " + s + " : " + rg.matchedFrom(s) +
* " : " + rg.matchedTo(s) + " : '" + rg.stringMatched(s) + "'");
* }
*/
// try to collate subgroup matches
StringBuffer subs = new StringBuffer();
// have to loop through submatches, collating them at top level
// match
int s = 0; // 1;
while (s <= ns)
{
if (s + 1 <= ns && rg.matchedTo(s) > -1
&& rg.matchedTo(s + 1) > -1
&& rg.matchedTo(s + 1) < rg.matchedTo(s))
{
// s is top level submatch. search for submatches enclosed by
// this one
int r = s + 1;
StringBuffer rmtch = new StringBuffer();
while (r <= ns && rg.matchedTo(r) <= rg.matchedTo(s))
{
if (rg.matchedFrom(r) > -1)
{
rmtch.append(rg.stringMatched(r));
}
r++;
}
if (rmtch.length() > 0)
{
subs.append(rmtch); // simply concatenate
}
s = r;
}
else
{
if (rg.matchedFrom(s) > -1)
{
subs.append(rg.stringMatched(s)); // concatenate
}
s++;
}
}
thematches[pass].append(subs);
}
}
}
else
{
// are we only supposed to take regex matches ?
if (!onlyIfMatches)
{
thismatched[sq] |= true;
urllength += idseq[pass][sq].length(); // tot up length
if (createFullUrl)
{
thematches[pass] = new StringBuffer(idseq[pass][sq]); // take
// whole
// string -
// regardless - probably not a
// good idea!
/*
* TODO: do some boilerplate trimming of the fields to make them
* sensible e.g. trim off any 'prefix' in the id string (see
* UrlLink for the below) - pre 2.4 Jalview behaviour if
* (idstring.indexOf("|") > -1) { idstring =
* idstring.substring(idstring.lastIndexOf("|") + 1); }
*/
}
}
}
}
// check if we are going to add this sequence's results ? all token
// replacements must be valid for this to happen!
// (including single value replacements - eg. dataset name)
if (thismatched[sq])
{
if (createFullUrl)
{
for (pass = 0; pass < matched.length; pass++)
{
if (idseq[pass].length > 1 && matched[pass].length() > 0)
{
matched[pass].append(separators[pass]);
}
matched[pass].append(thematches[pass]);
}
}
seqsmatched++;
}
}
// finally, if any sequences matched, then form the URL and return
if (seqsmatched == 0 || (createFullUrl && matched[0].length() == 0))
{
// no matches - no url generated
return null;
}
// check if we are beyond the feasible command line string limit for this
// platform
if ((urllength + 32) > Platform.getMaxCommandLineLength())
{
throw new UrlStringTooLongException(urllength);
}
if (!createFullUrl)
{
// just return the essential info about what the URL would be generated
// from
return new Object[] { new int[] { seqsmatched }, thismatched // boolean[]
};
}
// otherwise, create the URL completely.
StringBuffer submiturl = new StringBuffer();
submiturl.append(url_prefix);
for (pass = 0; pass < matched.length; pass++)
{
submiturl.append(matched[pass]);
if (url_suffix[pass] != null)
{
submiturl.append(url_suffix[pass]);
}
}
// full return
return new Object[] { new int[] { seqsmatched }, thismatched, // boolean[]
matched, // StringBuffer[]
new String[]
{ submiturl.toString() } };
}
/**
*
* Called by PopupMenu.addShowLinks()
*
* @param urlstub
* @return number of distinct sequence (id or seuqence) replacements predicted
* for this stub
*/
public int getNumberInvolved(Object[] urlstub)
{
return ((int[]) urlstub[0])[0]; // returns seqsmatched from
// makeUrlsIf(false,...)
}
/**
* called by PopupMenu.buildGroupURLMenu()
*
* get token types present in this url as a bitfield indicating presence of
* each token from tokens (LSB->MSB).
*
* @return groupURL class as integer
*/
public int getGroupURLType()
{
int r = 0;
for (int pass = 0; pass < tokens.length; pass++)
{
for (int i = 0; i < mtch.length; i++)
{
if (mtch[i].equals(tokens[pass]))
{
r += 1 << pass;
}
}
}
return r;
}
/**
* called by PopupMenu.buildGroupURLMenu()
*
* covenience method to generate the id and sequence string vector from a set
* of seuqences using each sequence's getName() and getSequenceAsString()
* method
*
* @param seqs
* @return String[][] {{sequence ids},{sequence strings}}
*/
public static String[][] formStrings(SequenceI[] seqs)
{
String[][] idset = new String[2][seqs.length];
for (int i = 0; i < seqs.length; i++)
{
idset[0][i] = seqs[i].getName();
idset[1][i] = seqs[i].getSequenceAsString();
}
return idset;
}
// commented out test code
//
// /**
// *
// * @param argv
// * @j2sIgnore
// */
// public static void main(String argv[])
// {
// // note - JAL-1383 - these services are all dead
// String[] links = new String[] {
// "EnVision2|IDS|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=linkInDatasetFromJalview&input=$SEQUENCEIDS$&inputType=0|,",
// "EnVision2|Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=linkInDatasetFromJalview&input=$SEQUENCES$&inputType=1|,",
// "EnVision2|IDS|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=$DATASETID$&input=$SEQUENCEIDS$&inputType=0|,",
// "EnVision2|Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=Enfin%20Default%20Workflow&datasetName=$DATASETID$&input=$SEQUENCES$&inputType=1|,",
// "EnVision2|IDS|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=$SEQUENCEIDS$&datasetName=linkInDatasetFromJalview&input=$SEQUENCEIDS$&inputType=0|,",
// "EnVision2|Seqs|http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?workflow=$SEQUENCEIDS$&datasetName=$DATASETID$&input=$SEQUENCES$&inputType=1|,",
// "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|,",
// "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|,"
// /*
// *
// http://www.ebi.ac.uk/enfin-srv/envision2/pages/linkin.jsf?input=P38389,P38398
// * &inputType=0&workflow=Enfin%20Default%20Workflow&datasetName=
// * linkInDatasetFromPRIDE
// */
// };
//
// SequenceI[] seqs = new SequenceI[] {
// new Sequence("StupidLabel:gi|9234|pdb|102L|A",
// "asdiasdpasdpadpwpadasdpaspdw"), };
// String[][] seqsandids = formStrings(seqs);
// for (int i = 0; i < links.length; i++)
// {
// GroupUrlLink ul = new GroupUrlLink(links[i]);
// if (ul.isValid())
// {
// System.out.println("\n\n\n");
// System.out.println(
// "Link " + i + " " + links[i] + " : " + ul.toString());
// System.out.println(" pref : " + ul.getUrl_prefix());
// System.out.println(" IdReplace : " + ul.getIDRegexReplace());
// System.out.println(" SeqReplace : " + ul.getSeqRegexReplace());
// System.out.println(" Suffixes : " + ul.getUrl_suffix());
//
// System.out.println(
// " Without onlyIfMatches:");
// Object[] urls;
// try
// {
// urls = ul.makeUrls(seqsandids[0], seqsandids[1], "mydataset",
// false);
// testUrls(ul, seqsandids, urls);
// } catch (UrlStringTooLongException ex)
// {
// System.out.println("too long exception " + ex);
// }
// System.out.println(
// " With onlyIfMatches set:");
// try
// {
// urls = ul.makeUrls(seqsandids[0], seqsandids[1], "mydataset",
// true);
// testUrls(ul, seqsandids, urls);
// } catch (UrlStringTooLongException ex)
// {
// System.out.println("too long exception " + ex);
// }
// }
// else
// {
// System.err.println("Invalid URLLink : " + links[i] + " : "
// + ul.getInvalidMessage());
// }
// }
// }
// /**
// * @return the sequence ID regexReplace
// */
// private String getIDRegexReplace()
// {
// String token = tokens[0];
// for (int i = 0; i < mtch.length; i++)
// {
// if (segs[i] > -1 && mtch[i].equals(token))
// {
// return regexReplace[i];
// }
// }
// return null;
// }
//
// /**
// * @return the sequence ID regexReplace
// */
// private String getSeqRegexReplace()
// {
// return _replaceFor(tokens[1]);
// }
//
// /**
// * report stats about the generated url string given an input set
// *
// * @param ul
// * @param idstring
// * @param url
// */
// private static void testUrls(GroupUrlLink ul, String[][] idstring,
// Object[] url)
// {
//
// if (url == null)
// {
// System.out.println("Created NO urls.");
// }
// else
// {
// System.out.println("Created a url from " + ((int[]) url[0])[0]
// + "out of " + idstring[0].length + " sequences.");
// System.out.println("Sequences that did not match:");
// for (int sq = 0; sq < idstring[0].length; sq++)
// {
// if (!((boolean[]) url[1])[sq])
// {
// System.out.println("Seq " + sq + ": " + idstring[0][sq] + "\t: "
// + idstring[1][sq]);
// }
// }
// System.out.println("Sequences that DID match:");
// for (int sq = 0; sq < idstring[0].length; sq++)
// {
// if (((boolean[]) url[1])[sq])
// {
// System.out.println("Seq " + sq + ": " + idstring[0][sq] + "\t: "
// + idstring[1][sq]);
// }
// }
// System.out.println("The generated URL:");
// System.out.println(((String[]) url[3])[0]);
// }
// }
//
// public void setLabel(String newlabel)
// {
// this.label = newlabel;
// }
// /**
// * return one or more URL strings by applying regex to the given idstring
// *
// * @param idstrings
// * array of id strings to pass to service
// * @param seqstrings
// * array of seq strings to pass to service
// * @param onlyIfMatches
// * - when true url strings are only made if regex is defined and
// * matches for all qualified tokens in groupURL - TODO: consider if
// * onlyIfMatches is really a useful parameter!
// * @return null or Object[] { int[] { number of seqs substituted},boolean[]
// {
// * which seqs were substituted }, StringBuffer[] { substituted lists
// * for each token }, String[] { url } }
// * @throws UrlStringTooLongException
// */
// private Object[] makeUrls(String[] idstrings, String[] seqstrings,
// String dsstring, boolean onlyIfMatches)
// throws UrlStringTooLongException
// {
// Hashtable rstrings = replacementArgs(idstrings,
// seqstrings, dsstring);
// return makeUrls(rstrings, onlyIfMatches);
// }
//
// /**
// *
// * @param repstrings
// * @param onlyIfMatches
// * @return Object[] {int[], boolean[], StringBuffer[], String[] }
// * @throws UrlStringTooLongException
// */
// private Object[] makeUrls(Hashtable repstrings,
// boolean onlyIfMatches)
// throws UrlStringTooLongException
// {
// return makeUrlsIf(true, repstrings, onlyIfMatches);
// }
//
@Override
public String toString()
{
StringBuffer result = new StringBuffer();
result.append(label + "|" + url_prefix);
int r;
for (r = 0; r < url_suffix.length; r++)
{
result.append("$");
result.append(mtch[r]);
if (regexReplace[r] != null)
{
result.append("=/");
result.append(regexReplace[r]);
result.append("/=");
}
result.append("$");
result.append(url_suffix[r]);
}
for (r = 0; r < separators.length; r++)
{
result.append("|");
result.append(separators[r]);
}
return result.toString();
}
}