src/jalview/urls/CustomUrlProvider.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21
  22 package jalview.urls;
  23
  24 import static jalview.util.UrlConstants.DB_ACCESSION;
  25 import static jalview.util.UrlConstants.DELIM;
  26 import static jalview.util.UrlConstants.SEP;
  27 import static jalview.util.UrlConstants.SEQUENCE_ID;
  28
  29 import jalview.util.MessageManager;
  30 import jalview.util.UrlConstants;
  31 import jalview.util.UrlLink;
  32
  33 import java.util.ArrayList;
  34 import java.util.HashMap;
  35 import java.util.Iterator;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Map.Entry;
  39 import java.util.StringTokenizer;
  40 import java.util.Vector;
  41
  42 /**
  43  *
  44  * Implements the UrlProviderI interface for a UrlProvider object which serves
  45  * custom URLs defined by the user
  46  *
  47  * @author $author$
  48  * @version $Revision$
  49  */
  50 public class CustomUrlProvider extends UrlProviderImpl
  51 {
  52   // Default sequence URL link label for SRS
  53   private static final String SRS_LABEL = "SRS";
  54
  55   // map of string ids to urlLinks (selected)
  56   private HashMap<String, UrlLink> selectedUrls;
  57
  58   // map of string ids to urlLinks (not selected)
  59   private HashMap<String, UrlLink> nonselectedUrls;
  60
  61   /**
  62    * Construct UrlProvider for custom (user-entered) URLs
  63    *
  64    * @param inMenuUrlList
  65    *          list of URLs set to be displayed in menu, in form stored in Cache.
  66    *          i.e. SEP delimited string
  67    * @param storedUrlList
  68    *          list of custom URLs entered by user but not currently displayed in
  69    *          menu, in form stored in Cache
  70    */
  71   public CustomUrlProvider(String inMenuUrlList, String storedUrlList)
  72   {
  73     try
  74     {
  75       selectedUrls = parseUrlStrings(inMenuUrlList);
  76       nonselectedUrls = parseUrlStrings(storedUrlList);
  77     } catch (Exception ex)
  78     {
  79       System.out.println(ex + "\nError parsing sequence links");
  80     }
  81   }
  82
  83   /**
  84    * Construct UrlProvider for custom (user-entered) URLs
  85    *
  86    * @param urlList
  87    *          list of URLs to be displayed in menu, as (label,url) pairs
  88    * @param storedUrlList
  89    *          list of custom URLs entered by user but not currently displayed in
  90    *          menu, as (label,url) pairs
  91    */
  92   public CustomUrlProvider(Map<String, String> inMenuUrlList,
  93           Map<String, String> storedUrlList)
  94   {
  95     try
  96     {
  97       selectedUrls = parseUrlList(inMenuUrlList);
  98       nonselectedUrls = parseUrlList(storedUrlList);
  99     } catch (Exception ex)
 100     {
 101       System.out.println(ex + "\nError parsing sequence links");
 102     }
 103   }
 104
 105   private HashMap<String, UrlLink> parseUrlStrings(String urlStrings)
 106   {
 107     // cachedUrlList is in form <label>|<url>|<label>|<url>...
 108     // parse cachedUrlList into labels (used as id) and url links
 109     HashMap<String, UrlLink> urls = new HashMap<String, UrlLink>();
 110
 111     StringTokenizer st = new StringTokenizer(urlStrings, SEP);
 112     while (st.hasMoreElements())
 113     {
 114       String name = st.nextToken();
 115
 116       if (!isMiriamId(name))
 117       {
 118         // this one of our custom urls
 119         String url = st.nextToken();
 120         // check for '|' within a regex
 121         int rxstart = url.indexOf(DELIM + DB_ACCESSION + DELIM);
 122         if (rxstart == -1)
 123         {
 124           rxstart = url.indexOf(DELIM + SEQUENCE_ID + DELIM);
 125         }
 126         while (rxstart == -1 && url.indexOf("/=" + DELIM) == -1
 127                 && st.hasMoreTokens())
 128         {
 129           url = url + SEP + st.nextToken();
 130         }
 131         urls.put(name, new UrlLink(name + SEP + url));
 132       }
 133     }
 134     upgradeOldLinks(urls);
 135     return urls;
 136   }
 137
 138   private HashMap<String, UrlLink> parseUrlList(Map<String, String> urlList)
 139   {
 140     HashMap<String, UrlLink> urls = new HashMap<String, UrlLink>();
 141     Iterator<Map.Entry<String, String>> it = urlList.entrySet().iterator();
 142     while (it.hasNext())
 143     {
 144       Map.Entry<String, String> pair = it.next();
 145       urls.put(pair.getKey(),
 146               new UrlLink(pair.getKey() + SEP + pair.getValue()));
 147     }
 148     upgradeOldLinks(urls);
 149     return urls;
 150   }
 151
 152   /*
 153    * Upgrade any legacy links which may have been left lying around
 154    */
 155   private void upgradeOldLinks(HashMap<String, UrlLink> urls)
 156   {
 157     // upgrade old SRS link
 158     if (urls.containsKey(SRS_LABEL))
 159     {
 160       urls.remove(SRS_LABEL);
 161       urls.put(UrlConstants.DEFAULT_LABEL, new UrlLink(UrlConstants.DEFAULT_STRING));
 162     }
 163   }
 164
 165   @Override
 166   public Vector<String> getLinksForMenu()
 167   {
 168     Vector<String> links = new Vector<String>();
 169     Iterator<Map.Entry<String, UrlLink>> it = selectedUrls.entrySet()
 170             .iterator();
 171     while (it.hasNext())
 172     {
 173       Map.Entry<String, UrlLink> pair = it.next();
 174       links.add(pair.getValue().toString());
 175     }
 176     return links;
 177   }
 178
 179   @Override
 180   public List<UrlLinkDisplay> getLinksForTable()
 181   {
 182     ArrayList<UrlLinkDisplay> displayLinks = new ArrayList<UrlLinkDisplay>();
 183     displayLinks = getLinksForTable(selectedUrls, true);
 184     displayLinks.addAll(getLinksForTable(nonselectedUrls, false));
 185     return displayLinks;
 186   }
 187
 188   private ArrayList<UrlLinkDisplay> getLinksForTable(
 189           HashMap<String, UrlLink> urlList, boolean selected)
 190   {
 191     return super.getLinksForTable(urlList, null, selected);
 192   }
 193
 194   @Override
 195   public boolean setDefaultUrl(String id)
 196   {
 197     if (selectedUrls.containsKey(id))
 198     {
 199       defaultUrl = id;
 200     }
 201     else if (nonselectedUrls.containsKey(id))
 202     {
 203       selectedUrls.put(id, nonselectedUrls.get(id));
 204       nonselectedUrls.remove(id);
 205       defaultUrl = id;
 206     }
 207     else
 208     {
 209       defaultUrl = null;
 210     }
 211     return (defaultUrl != null);
 212   }
 213
 214   @Override
 215   public String writeUrlsAsString(boolean selected)
 216   {
 217     StringBuffer links = new StringBuffer();
 218     HashMap<String, UrlLink> urls;
 219     if (selected)
 220     {
 221       urls = selectedUrls;
 222     }
 223     else
 224     {
 225       urls = nonselectedUrls;
 226     }
 227     if (urls.size() > 0)
 228     {
 229       for (Entry<String, UrlLink> entry : urls.entrySet())
 230       {
 231         links.append(entry.getValue().toString());
 232         links.append(SEP);
 233       }
 234
 235       // remove last SEP
 236       links.setLength(links.length() - 1);
 237     }
 238     else
 239     {
 240       urls.clear();
 241     }
 242     return links.toString();
 243   }
 244
 245   @Override
 246   public String getDefaultUrl(String seqid)
 247   {
 248     return super.getDefaultUrl(seqid, selectedUrls);
 249   }
 250
 251   @Override
 252   public String getDefaultUrlId()
 253   {
 254     return defaultUrl;
 255   }
 256
 257   @Override
 258   public String getDefaultTarget(String seqid)
 259   {
 260     return selectedUrls.get(defaultUrl).getTarget();
 261   }
 262
 263   @Override
 264   public void setUrlData(List<UrlLinkDisplay> links)
 265   {
 266     HashMap<String, UrlLink> unselurls = new HashMap<String, UrlLink>();
 267     HashMap<String, UrlLink> selurls = new HashMap<String, UrlLink>();
 268
 269     Iterator<UrlLinkDisplay> it = links.iterator();
 270     while (it.hasNext())
 271     {
 272       UrlLinkDisplay link = it.next();
 273
 274       // MIRIAM ids will be handled by a different UrlProvider class
 275       if (!isMiriamId(link.getId()))
 276       {
 277         // don't allow duplicate key names as entries will be overwritten
 278         if (unselurls.containsKey(link.getId())
 279                 || selurls.containsKey(link.getId()))
 280         {
 281           throw new IllegalArgumentException(MessageManager.formatMessage(
 282                   "exception.url_cannot_have_duplicate_id", link.getId()));
 283         }
 284         if (link.getIsSelected())
 285         {
 286           selurls.put(link.getId(),
 287                   new UrlLink(link.getId() + SEP + link.getUrl()));
 288
 289           // sort out default and selected ids
 290           if (link.getIsDefault())
 291           {
 292             setDefaultUrl(link.getId());
 293           }
 294         }
 295         else
 296         {
 297           unselurls.put(link.getId(),
 298                 new UrlLink(link.getId() + SEP + link.getUrl()));
 299         }
 300       }
 301
 302     }
 303     nonselectedUrls = unselurls;
 304     selectedUrls = selurls;
 305   }
 306
 307   @Override
 308   public String chooseDefaultUrl()
 309   {
 310     // unilaterally set the default id to the EMBL_EBI link
 311
 312     if (nonselectedUrls.containsKey(UrlConstants.DEFAULT_LABEL))
 313     {
 314       // default key must be selected so remove from nonselected list
 315       nonselectedUrls.remove(UrlConstants.DEFAULT_LABEL);
 316     }
 317
 318     if (!selectedUrls.containsKey(UrlConstants.DEFAULT_LABEL))
 319     {
 320       selectedUrls.put(UrlConstants.DEFAULT_LABEL, new UrlLink(
 321               UrlConstants.DEFAULT_STRING));
 322     }
 323     defaultUrl = UrlConstants.DEFAULT_LABEL;
 324     return UrlConstants.DEFAULT_LABEL;
 325   }
 326
 327 }