src/jalview/io/ModellerDescription.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 package jalview.io;
  22
  23 import jalview.datamodel.*;
  24
  25 public class ModellerDescription
  26 {
  27   /**
  28    * Translates between a String containing a set of colon-separated values on a
  29    * single line, and sequence start/end and other properties. See PIRFile IO
  30    * for its use.
  31    */
  32   final String[] seqTypes =
  33   { "sequence", "structure", "structureX", "structureN" };
  34
  35   final String[] Fields =
  36   { "objectType", "objectId", "startField", "startCode", "endField",
  37       "endCode", "description1", "description2", "resolutionField",
  38       "tailField" };
  39
  40   final int TYPE = 0;
  41
  42   final int LOCALID = 1;
  43
  44   final int START = 2;
  45
  46   final int START_CHAIN = 3;
  47
  48   final int END = 4;
  49
  50   final int END_CHAIN = 5;
  51
  52   final int DESCRIPTION1 = 6;
  53
  54   final int DESCRIPTION2 = 7;
  55
  56   final int RESOLUTION = 8;
  57
  58   final int TAIL = 9;
  59
  60   /**
  61    * 0 is free text or empty 1 is something that parses to an integer, or \@
  62    */
  63   final int Types[] =
  64   { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 };
  65
  66   final char Padding[] =
  67   { ' ', ' ', ' ', '.', ' ', '.', '.', '.', '.', '.' };
  68
  69   java.util.Hashtable fields = new java.util.Hashtable();
  70
  71   ModellerDescription()
  72   {
  73     fields.put(Fields[TAIL], "");
  74   }
  75
  76   class resCode
  77   {
  78     Integer val;
  79
  80     String field;
  81
  82     resCode(String f, Integer v)
  83     {
  84       val = v;
  85       field = f;
  86     }
  87
  88     resCode(int v)
  89     {
  90       val = new Integer(v);
  91       field = val.toString();
  92     }
  93   };
  94
  95   private resCode validResidueCode(String field)
  96   {
  97     Integer val = null;
  98     com.stevesoft.pat.Regex r = new com.stevesoft.pat.Regex(
  99             "\\s*((([-0-9]+).?)|FIRST|LAST|@)");
 100
 101     if (!r.search(field))
 102     {
 103       return null; // invalid
 104     }
 105     String value = r.stringMatched(3);
 106     if (value == null)
 107     {
 108       value = r.stringMatched(1);
 109     }
 110     // jalview.bin.Cache.log.debug("from '" + field + "' matched '" + value +
 111     // "'");
 112     try
 113     {
 114       val = Integer.valueOf(value);
 115       return new resCode(field, val); // successful numeric extraction
 116     } catch (Exception e)
 117     {
 118     }
 119     return new resCode(field, null);
 120   }
 121
 122   private java.util.Hashtable parseDescription(String desc)
 123   {
 124     java.util.Hashtable fields = new java.util.Hashtable();
 125     java.util.StringTokenizer st = new java.util.StringTokenizer(desc, ":",
 126             true);
 127
 128     String field;
 129     int type = -1;
 130     if (st.countTokens() > 0)
 131     {
 132       // parse colon-fields
 133       int i = 0;
 134       field = st.nextToken(":");
 135       do
 136       {
 137         if (seqTypes[i].equalsIgnoreCase(field))
 138         {
 139           break;
 140         }
 141       } while (++i < seqTypes.length);
 142
 143       if (i < seqTypes.length)
 144       {
 145         st.nextToken(); // skip ':'
 146         // valid seqType for modeller
 147         type = i;
 148         i = 1; // continue parsing fields
 149         while (i < TAIL && st.hasMoreTokens())
 150         {
 151           if ((field = st.nextToken(":")) != null)
 152           {
 153             if (!field.equals(":"))
 154             {
 155               // validate residue field value
 156               if (Types[i] == 1)
 157               {
 158                 resCode val = validResidueCode(field);
 159                 if (val != null)
 160                 {
 161                   fields.put(new String(Fields[i] + "num"), val);
 162                 }
 163                 else
 164                 {
 165                   // jalview.bin.Cache.log.debug(
 166                   // "Ignoring non-Modeller description: invalid integer-like
 167                   // field '" + field + "'");
 168                   type = -1; /* invalid field! - throw the FieldSet away */
 169                 }
 170                 ;
 171               }
 172               fields.put(Fields[i++], field);
 173               if (st.hasMoreTokens())
 174               {
 175                 st.nextToken(); // skip token sep.
 176               }
 177             }
 178             else
 179             {
 180               i++;
 181             }
 182           }
 183         }
 184         if (i == TAIL)
 185         {
 186           // slurp remaining fields
 187           while (st.hasMoreTokens())
 188           {
 189             String tl = st.nextToken(":");
 190             field += tl.equals(":") ? tl : (":" + tl);
 191           }
 192           fields.put(Fields[TAIL], field);
 193         }
 194       }
 195     }
 196     if (type == -1)
 197     {
 198       // object is not a proper ModellerPIR object
 199       fields = new java.util.Hashtable();
 200       fields.put(Fields[TAIL], new String(desc));
 201     }
 202     else
 203     {
 204       fields.put(Fields[TYPE], seqTypes[type]);
 205     }
 206     return fields;
 207   }
 208
 209   ModellerDescription(String desc)
 210   {
 211     if (desc == null)
 212     {
 213       desc = "";
 214     }
 215     fields = parseDescription(desc);
 216   }
 217
 218   void setStartCode(int v)
 219   {
 220     resCode r;
 221     fields.put(Fields[START] + "num", r = new resCode(v));
 222     fields.put(Fields[START], r.field);
 223   }
 224
 225   void setEndCode(int v)
 226   {
 227     resCode r;
 228     fields.put(Fields[END] + "num", r = new resCode(v));
 229     fields.put(Fields[END], r.field);
 230   }
 231
 232   /**
 233    * make a possibly updated modeller field line for the sequence object
 234    *
 235    * @param seq
 236    *          SequenceI
 237    */
 238   ModellerDescription(SequenceI seq)
 239   {
 240
 241     if (seq.getDescription() != null)
 242     {
 243       fields = parseDescription(seq.getDescription());
 244     }
 245
 246     if (isModellerFieldset())
 247     {
 248       // Set start and end before we update the type (in the case of a
 249       // synthesized field set)
 250       if (getStartCode() == null
 251               || (getStartNum() != seq.getStart() && getStartCode().val != null))
 252       {
 253         // unset or user updated sequence start position
 254         setStartCode(seq.getStart());
 255       }
 256
 257       if (getEndCode() == null
 258               || (getEndNum() != seq.getEnd() && getStartCode() != null && getStartCode().val != null))
 259       {
 260         setEndCode(seq.getEnd());
 261       }
 262     }
 263     else
 264     {
 265       // synthesize fields
 266       setStartCode(seq.getStart());
 267       setEndCode(seq.getEnd());
 268       fields.put(Fields[LOCALID], seq.getName()); // this may be overwritten
 269       // below...
 270       // type - decide based on evidence of PDB database references - this also
 271       // sets the local reference field
 272       int t = 0; // sequence
 273       if (seq.getDatasetSequence() != null
 274               && seq.getDatasetSequence().getDBRef() != null)
 275       {
 276         jalview.datamodel.DBRefEntry[] dbr = seq.getDatasetSequence()
 277                 .getDBRef();
 278         int i, j;
 279         for (i = 0, j = dbr.length; i < j; i++)
 280         {
 281           if (dbr[i] != null)
 282           {
 283             // JBPNote PDB dbRefEntry needs properties to propagate onto
 284             // ModellerField
 285             // JBPNote Need to get info from the user about whether the sequence
 286             // is the one being modelled, or if it is a template.
 287             if (dbr[i].getSource()
 288                     .equals(jalview.datamodel.DBRefSource.PDB))
 289             {
 290               fields.put(Fields[LOCALID], dbr[i].getAccessionId());
 291               t = 2;
 292               break;
 293             }
 294           }
 295         }
 296       }
 297       fields.put(Fields[TYPE], seqTypes[t]);
 298     }
 299
 300   }
 301
 302   /**
 303    * Indicate if fields parsed to a modeller-like colon-separated value line
 304    *
 305    * @return boolean
 306    */
 307   boolean isModellerFieldset()
 308   {
 309     return (fields.containsKey(Fields[TYPE]));
 310   }
 311
 312   String getDescriptionLine()
 313   {
 314     String desc = "";
 315     int lastfield = Fields.length - 1;
 316
 317     if (isModellerFieldset())
 318     {
 319       String value;
 320       // try to write a minimal modeller field set, so..
 321
 322       // find the last valid field in the entry
 323
 324       for (; lastfield > 6; lastfield--)
 325       {
 326         if (fields.containsKey(Fields[lastfield]))
 327         {
 328           break;
 329         }
 330       }
 331
 332       for (int i = 0; i < lastfield; i++)
 333       {
 334         value = (String) fields.get(Fields[i]);
 335         if (value != null && value.length() > 0)
 336         {
 337           desc += ((String) fields.get(Fields[i])) + ":";
 338         }
 339         else
 340         {
 341           desc += Padding[i] + ":";
 342         }
 343       }
 344     }
 345     // just return the last field if no others were defined.
 346     if (fields.containsKey(Fields[lastfield]))
 347     {
 348       desc += (String) fields.get(Fields[lastfield]);
 349     }
 350     else
 351     {
 352       desc += ".";
 353     }
 354     return desc;
 355   }
 356
 357   int getStartNum()
 358   {
 359     int start = 0;
 360     resCode val = getStartCode();
 361     if (val != null && val.val != null)
 362     {
 363       return val.val.intValue();
 364     }
 365     return start;
 366   }
 367
 368   resCode getStartCode()
 369   {
 370     if (isModellerFieldset() && fields.containsKey(Fields[START] + "num"))
 371     {
 372       return (resCode) fields.get(Fields[START] + "num");
 373     }
 374     return null;
 375   }
 376
 377   resCode getEndCode()
 378   {
 379     if (isModellerFieldset() && fields.containsKey(Fields[END] + "num"))
 380     {
 381       return (resCode) fields.get(Fields[END] + "num");
 382     }
 383     return null;
 384   }
 385
 386   int getEndNum()
 387   {
 388     int end = 0;
 389     resCode val = getEndCode();
 390     if (val != null && val.val != null)
 391     {
 392       return val.val.intValue();
 393     }
 394     return end;
 395   }
 396
 397   /**
 398    * returns true if sequence object was modifed with a valid modellerField set
 399    *
 400    * @param newSeq
 401    *          SequenceI
 402    * @return boolean
 403    */
 404   boolean updateSequenceI(SequenceI newSeq)
 405   {
 406     if (isModellerFieldset())
 407     {
 408       resCode rc = getStartCode();
 409       if (rc != null && rc.val != null)
 410       {
 411         newSeq.setStart(getStartNum());
 412       }
 413       else
 414       {
 415         newSeq.setStart(1);
 416       }
 417       rc = getEndCode();
 418       if (rc != null && rc.val != null)
 419       {
 420         newSeq.setEnd(getEndNum());
 421       }
 422       else
 423       {
 424         newSeq.setEnd(newSeq.getStart() + newSeq.getLength());
 425       }
 426       return true;
 427     }
 428     return false;
 429   }
 430 }