/*
- * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1)
- * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
+ * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
*
- * This program 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 2
- * of the License, or (at your option) any later version.
+ * This file is part of Jalview.
*
- * This program 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.
+ * 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.
*
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ * 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 <http://www.gnu.org/licenses/>.
*/
package jalview.util;
public class GroupUrlLink
{
+ public class UrlStringTooLongException extends Exception
+ {
+ public UrlStringTooLongException(int lng)
+ {
+ urlLength = lng;
+ }
+
+ public int urlLength;
+
+ 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
* 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 <code>UrlLink</code> for more information
- * about the approach, and the original implementation.
- *
+ * about the approach, and the original implementation. Documentation to come.
+ * Note - groupUrls can be very big!
*/
private String url_prefix, target, label;
}
}
+ /**
+ * test for GroupURLType bitfield (with default tokens)
+ */
+ public static final int SEQUENCEIDS = 1;
+
+ /**
+ * test for GroupURLType bitfield (with default tokens)
+ */
+ public static final int SEQUENCES = 2;
+
+ /**
+ * test for GroupURLType bitfield (with default tokens)
+ */
+ public static final int DATASETID = 4;
+
// private int idseg = -1, seqseg = -1;
/**
* @return null or Object[] { int[] { number of seqs substituted},boolean[] {
* which seqs were substituted }, StringBuffer[] { substituted lists
* for each token }, String[] { url } }
+ * @throws UrlStringTooLongException
*/
public Object[] makeUrls(String[] idstrings, String[] seqstrings,
String dsstring, boolean onlyIfMatches)
+ throws UrlStringTooLongException
+ {
+ Hashtable rstrings = replacementArgs(idstrings, seqstrings, dsstring);
+ return makeUrls(rstrings, onlyIfMatches);
+ }
+
+ /**
+ * 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);
throw new Error(
"idstrings and seqstrings contain one string each per sequence.");
}
- return makeUrls(rstrings, onlyIfMatches);
+ return rstrings;
}
public Object[] makeUrls(Hashtable repstrings, boolean onlyIfMatches)
+ throws UrlStringTooLongException
+ {
+ return makeUrlsIf(true, repstrings, onlyIfMatches);
+ }
+
+ /**
+ *
+ * @param ids
+ * @param seqstr
+ * @param string
+ * @param b
+ * @return URL stub objects ready to pass to constructFrom
+ * @throws UrlStringTooLongException
+ */
+ public Object[] makeUrlStubs(String[] ids, String[] seqstr,
+ String string, boolean b) throws UrlStringTooLongException
{
+ Hashtable rstrings = replacementArgs(ids, seqstr, string);
+ Object[] stubs = makeUrlsIf(false, rstrings, b);
+ if (stubs != null)
+ {
+ return new Object[]
+ { stubs[0], stubs[1], rstrings, new boolean[]
+ { b } };
+ }
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ /**
+ * generate the URL for the given URL stub object array returned from
+ * makeUrlStubs
+ *
+ * @param stubs
+ * @return URL string.
+ * @throws UrlStringTooLongException
+ */
+ public String constructFrom(Object[] stubs)
+ throws UrlStringTooLongException
+ {
+ Object[] results = makeUrlsIf(true, (Hashtable) stubs[2],
+ ((boolean[]) stubs[3])[0]);
+ return ((String[]) results[3])[0];
+ }
+
+ /**
+ * 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
+ */
+ protected 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.
"Cannot have zero length vector of replacement strings - either 1 value or n values.");
}
}
- int pass = 0;
// iterate through input, collating segments to be inserted into url
StringBuffer matched[] = new StringBuffer[idseq.length];
// and precompile regexes
matched[pass] = new StringBuffer();
if (regexReplace[pass] != null)
{
- rgxs[pass] = com.stevesoft.pat.Regex.perlCode("/" + regexReplace[pass]
- + "/");
+ rgxs[pass] = com.stevesoft.pat.Regex.perlCode("/"
+ + regexReplace[pass] + "/");
}
else
{
rgxs[pass] = null;
}
}
- // record which of the input sequences were actually used to generate the
+ // 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;
{
// initialise flag for match
thismatched[sq] = false;
- String[] thematches = new String[rgxs.length];
+ StringBuffer[] thematches = new StringBuffer[rgxs.length];
for (pass = 0; pass < rgxs.length; pass++)
{
- thematches[pass] = ""; // initialise - in case there are no more
+ 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.
{
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] += rg.stringMatched();// take whole regex
+ thematches[pass].append(rg.stringMatched());// take whole regex
}
/*
* else if (ns==1) { // take only subgroup match return new String[]
else
{
// debug
- for (int s = 0; s <= rg.numSubs(); s++)
- {
- System.err.println("Sub " + s + " : " + rg.matchedFrom(s)
- + " : " + rg.matchedTo(s) + " : '"
- + rg.stringMatched(s) + "'");
- }
+ /*
+ * 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
// s is top level submatch. search for submatches enclosed by
// this one
int r = s + 1;
- String rmtch = "";
+ StringBuffer rmtch = new StringBuffer();
while (r <= ns && rg.matchedTo(r) <= rg.matchedTo(s))
{
if (rg.matchedFrom(r) > -1)
{
- rmtch += rg.stringMatched(r);
+ rmtch.append(rg.stringMatched(r));
}
r++;
}
s++;
}
}
- thematches[pass] += subs.toString();
+ thematches[pass].append(subs);
}
}
}
if (!onlyIfMatches)
{
thismatched[sq] |= true;
- thematches[pass] = 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); }
- */
+ 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); }
+ */
+ }
}
}
// (including single value replacements - eg. dataset name)
if (thismatched[sq])
{
- for (pass = 0; pass < matched.length; pass++)
+ if (createFullUrl)
{
- if (idseq[pass].length > 1 && matched[pass].length() > 0)
+ for (pass = 0; pass < matched.length; pass++)
{
- matched[pass].append(separators[pass]);
+ if (idseq[pass].length > 1 && matched[pass].length() > 0)
+ {
+ matched[pass].append(separators[pass]);
+ }
+ matched[pass].append(thematches[pass]);
}
- matched[pass].append(thematches[pass]);
}
seqsmatched++;
}
}
// finally, if any sequences matched, then form the URL and return
- if (matched[0].length() == 0)
+ 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 };
+ }
+ // otherwise, create the URL completely.
+
StringBuffer submiturl = new StringBuffer();
submiturl.append(url_prefix);
for (pass = 0; pass < matched.length; pass++)
}
/**
- * get token types present in this url as a bitfield indicating presence of each token from tokens (LSB->MSB).
+ *
+ * @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,...)
+ }
+
+ /**
+ * 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()
System.out
.println("<insert input id and sequence strings here> Without onlyIfMatches:");
- Object[] urls = ul.makeUrls(seqsandids[0], seqsandids[1],
- "mydataset", false);
- testUrls(ul, seqsandids, urls);
+ 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("<insert input id and sequence strings here> With onlyIfMatches set:");
- urls = ul.makeUrls(seqsandids[0], seqsandids[1], "mydataset", true);
- testUrls(ul, seqsandids, urls);
+ 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
{
{
this.label = newlabel;
}
+
}
git://source.jalview.org / jalview.git / blobdiff