X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignment.java;h=64b79b7416d1381b1cb921bcef718354f36f41c7;hb=482e093c4670a813c9eec254990178b209e32dbc;hp=cec2abcabe44a367208caa009544dc0ca7153ca9;hpb=77b038f418aea84563953ad94f839592317ea500;p=jalview.git

diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java
index cec2abc..64b79b7 100755
--- a/src/jalview/datamodel/Alignment.java
+++ b/src/jalview/datamodel/Alignment.java
@@ -1,17 +1,17 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer
- * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
- *
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
+ * Copyright (C) 2008 AM Waterhouse, J Procter, 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 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.
- *
+ * 
  * 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
@@ -22,17 +22,23 @@ import java.util.*;
 
 import jalview.analysis.*;
 
-/** Data structure to hold and manipulate a multiple sequence alignment
+/**
+ * Data structure to hold and manipulate a multiple sequence alignment
  */
-public class Alignment
-    implements AlignmentI
+public class Alignment implements AlignmentI
 {
   protected Alignment dataset;
+
   protected Vector sequences;
+
   protected Vector groups = new Vector();
+
   protected char gapCharacter = '-';
+
   protected int type = NUCLEOTIDE;
+
   public static final int PROTEIN = 0;
+
   public static final int NUCLEOTIDE = 1;
 
   /** DOCUMENT ME!! */
@@ -64,8 +70,9 @@ public class Alignment
 
   }
 
-  /** Make an alignment from an array of Sequences.
-   *
+  /**
+   * Make an alignment from an array of Sequences.
+   * 
    * @param sequences
    */
   public Alignment(SequenceI[] seqs)
@@ -75,20 +82,25 @@ public class Alignment
 
   /**
    * Make a new alignment from an array of SeqCigars
-   * @param seqs SeqCigar[]
+   * 
+   * @param seqs
+   *                SeqCigar[]
    */
   public Alignment(SeqCigar[] alseqs)
   {
-    SequenceI[] seqs = SeqCigar.createAlignmentSequences(alseqs, gapCharacter,
-        new ColumnSelection(), null);
+    SequenceI[] seqs = SeqCigar.createAlignmentSequences(alseqs,
+            gapCharacter, new ColumnSelection(), null);
     initAlignment(seqs);
   }
 
   /**
-   * Make a new alignment from an CigarArray
-   * JBPNote - can only do this when compactAlignment does not contain hidden regions.
-   * JBPNote - must also check that compactAlignment resolves to a set of SeqCigars - or construct them appropriately.
-   * @param compactAlignment CigarArray
+   * Make a new alignment from an CigarArray JBPNote - can only do this when
+   * compactAlignment does not contain hidden regions. JBPNote - must also check
+   * that compactAlignment resolves to a set of SeqCigars - or construct them
+   * appropriately.
+   * 
+   * @param compactAlignment
+   *                CigarArray
    */
   public static AlignmentI createAlignment(CigarArray compactAlignment)
   {
@@ -98,7 +110,7 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
+   * 
    * @return DOCUMENT ME!
    */
   public Vector getSequences()
@@ -108,6 +120,8 @@ public class Alignment
 
   public SequenceI[] getSequencesArray()
   {
+    if (sequences == null)
+      return null;
     SequenceI[] reply = new SequenceI[sequences.size()];
     for (int i = 0; i < sequences.size(); i++)
     {
@@ -118,9 +132,10 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
-   * @param i DOCUMENT ME!
-   *
+   * 
+   * @param i
+   *                DOCUMENT ME!
+   * 
    * @return DOCUMENT ME!
    */
   public SequenceI getSequenceAt(int i)
@@ -133,8 +148,9 @@ public class Alignment
     return null;
   }
 
-  /** Adds a sequence to the alignment.  Recalculates maxLength and size.
-   *
+  /**
+   * Adds a sequence to the alignment. Recalculates maxLength and size.
+   * 
    * @param snew
    */
   public void addSequence(SequenceI snew)
@@ -154,17 +170,22 @@ public class Alignment
         snew = adding;
       }
     }
-    if (sequences==null) {
-      initAlignment(new SequenceI[] { snew });
-    } else {
+    if (sequences == null)
+    {
+      initAlignment(new SequenceI[]
+      { snew });
+    }
+    else
+    {
       sequences.addElement(snew);
     }
-    if (hiddenSequences!=null)
+    if (hiddenSequences != null)
       hiddenSequences.adjustHeightSequenceAdded();
   }
 
-  /** Adds a sequence to the alignment.  Recalculates maxLength and size.
-   *
+  /**
+   * Adds a sequence to the alignment. Recalculates maxLength and size.
+   * 
    * @param snew
    */
   public void setSequenceAt(int i, SequenceI snew)
@@ -177,7 +198,7 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
+   * 
    * @return DOCUMENT ME!
    */
   public Vector getGroups()
@@ -187,8 +208,8 @@ public class Alignment
 
   public void finalize()
   {
-    if(getDataset()!=null)
-      getDataset().finalize();
+    if (getDataset() != null)
+      getDataset().removeAlignmentRef();
 
     dataset = null;
     sequences = null;
@@ -197,11 +218,23 @@ public class Alignment
     hiddenSequences = null;
   }
 
+  /**
+   * decrement the alignmentRefs counter by one and call finalize if it goes to
+   * zero.
+   */
+  private void removeAlignmentRef()
+  {
+    if (--alignmentRefs == 0)
+    {
+      finalize();
+    }
+  }
 
   /**
    * DOCUMENT ME!
-   *
-   * @param s DOCUMENT ME!
+   * 
+   * @param s
+   *                DOCUMENT ME!
    */
   public void deleteSequence(SequenceI s)
   {
@@ -210,8 +243,9 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
-   * @param i DOCUMENT ME!
+   * 
+   * @param i
+   *                DOCUMENT ME!
    */
   public void deleteSequence(int i)
   {
@@ -240,9 +274,10 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
-   * @param s DOCUMENT ME!
-   *
+   * 
+   * @param s
+   *                DOCUMENT ME!
+   * 
    * @return DOCUMENT ME!
    */
   public SequenceGroup[] findAllGroups(SequenceI s)
@@ -324,11 +359,55 @@ public class Alignment
   /**    */
   public SequenceI findName(String name)
   {
-    int i = 0;
+    return findName(name, false);
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see jalview.datamodel.AlignmentI#findName(java.lang.String, boolean)
+   */
+  public SequenceI findName(String token, boolean b)
+  {
+    return findName(null, token, b);
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see jalview.datamodel.AlignmentI#findName(SequenceI, java.lang.String,
+   *      boolean)
+   */
+  public SequenceI findName(SequenceI startAfter, String token, boolean b)
+  {
 
+    int i = 0;
+    SequenceI sq = null;
+    String sqname = null;
+    if (startAfter != null)
+    {
+      // try to find the sequence in the alignment
+      boolean matched = false;
+      while (i < sequences.size())
+      {
+        if (getSequenceAt(i++) == startAfter)
+        {
+          matched = true;
+          break;
+        }
+      }
+      if (!matched)
+      {
+        i = 0;
+      }
+    }
     while (i < sequences.size())
     {
-      if (getSequenceAt(i).getName().equals(name))
+      sq = getSequenceAt(i);
+      sqname = sq.getName();
+      if (sqname.equals(token) // exact match
+              || (b && // allow imperfect matches - case varies
+              (sqname.equalsIgnoreCase(token))))
       {
         return getSequenceAt(i);
       }
@@ -363,7 +442,11 @@ public class Alignment
 
   }
 
-  /**    */
+  /*
+   * (non-Javadoc)
+   * 
+   * @see jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SequenceI)
+   */
   public int findIndex(SequenceI s)
   {
     int i = 0;
@@ -381,9 +464,29 @@ public class Alignment
     return -1;
   }
 
+  /*
+   * (non-Javadoc)
+   * 
+   * @see jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SearchResults)
+   */
+  public int findIndex(SearchResults results)
+  {
+    int i = 0;
+
+    while (i < sequences.size())
+    {
+      if (results.involvesSequence(getSequenceAt(i)))
+      {
+        return i;
+      }
+      i++;
+    }
+    return -1;
+  }
+
   /**
    * DOCUMENT ME!
-   *
+   * 
    * @return DOCUMENT ME!
    */
   public int getHeight()
@@ -393,7 +496,7 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
+   * 
    * @return DOCUMENT ME!
    */
   public int getWidth()
@@ -413,8 +516,9 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
-   * @param gc DOCUMENT ME!
+   * 
+   * @param gc
+   *                DOCUMENT ME!
    */
   public void setGapCharacter(char gc)
   {
@@ -423,17 +527,14 @@ public class Alignment
     for (int i = 0; i < sequences.size(); i++)
     {
       Sequence seq = (Sequence) sequences.elementAt(i);
-      seq.setSequence(seq.getSequenceAsString()
-                      .replace('.', gc)
-                      .replace('-', gc)
-                      .replace(' ', gc)
-          );
+      seq.setSequence(seq.getSequenceAsString().replace('.', gc).replace(
+              '-', gc).replace(' ', gc));
     }
   }
 
   /**
    * DOCUMENT ME!
-   *
+   * 
    * @return DOCUMENT ME!
    */
   public char getGapCharacter()
@@ -443,7 +544,7 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
+   * 
    * @return DOCUMENT ME!
    */
   public boolean isAligned()
@@ -460,7 +561,10 @@ public class Alignment
 
     return true;
   }
-  /* (non-Javadoc)
+
+  /*
+   * (non-Javadoc)
+   * 
    * @see jalview.datamodel.AlignmentI#deleteAnnotation(jalview.datamodel.AlignmentAnnotation)
    */
   public boolean deleteAnnotation(AlignmentAnnotation aa)
@@ -479,25 +583,24 @@ public class Alignment
 
     AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize - 1];
 
-    boolean swap=false;
+    boolean swap = false;
     int tIndex = 0;
 
-    for (int i = 0; tIndex<temp.length && i < aSize; i++)
+    for (int i = 0; i < aSize; i++)
     {
       if (annotations[i] == aa)
       {
-        swap=true;
+        swap = true;
         continue;
       }
-
-      temp[tIndex] = annotations[i];
-      tIndex++;
+      if (tIndex < temp.length)
+        temp[tIndex++] = annotations[i];
     }
 
     if (swap)
     {
       annotations = temp;
-      if(aa.sequenceRef!=null)
+      if (aa.sequenceRef != null)
         aa.sequenceRef.removeAlignmentAnnotation(aa);
     }
     return swap;
@@ -505,8 +608,9 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
-   * @param aa DOCUMENT ME!
+   * 
+   * @param aa
+   *                DOCUMENT ME!
    */
   public void addAnnotation(AlignmentAnnotation aa)
   {
@@ -567,7 +671,7 @@ public class Alignment
 
   /**
    * DOCUMENT ME!
-   *
+   * 
    * @return DOCUMENT ME!
    */
   public AlignmentAnnotation[] getAlignmentAnnotation()
@@ -606,7 +710,7 @@ public class Alignment
       // Create a new dataset for this alignment.
       // Can only be done once, if dataset is not null
       // This will not be performed
-      Sequence[] seqs = new Sequence[getHeight()];
+      SequenceI[] seqs = new SequenceI[getHeight()];
       SequenceI currentSeq;
       for (int i = 0; i < getHeight(); i++)
       {
@@ -617,17 +721,7 @@ public class Alignment
         }
         else
         {
-          seqs[i] = new Sequence(currentSeq.getName(),
-                                 AlignSeq.extractGaps(
-                                     jalview.util.Comparison.GapChars,
-                                     currentSeq.getSequenceAsString()
-                                 ),
-                                 currentSeq.getStart(),
-                                 currentSeq.getEnd());
-          seqs[i].sequenceFeatures = currentSeq.getSequenceFeatures();
-          seqs[i].setDescription(currentSeq.getDescription());
-          getSequenceAt(i).setSequenceFeatures(null);
-          getSequenceAt(i).setDatasetSequence(seqs[i]);
+          seqs[i] = currentSeq.createDatasetSequence();
         }
       }
 
@@ -637,6 +731,20 @@ public class Alignment
     {
       dataset = data;
     }
+    dataset.addAlignmentRef();
+  }
+
+  /**
+   * reference count for number of alignments referencing this one.
+   */
+  int alignmentRefs = 0;
+
+  /**
+   * increase reference count to this alignment.
+   */
+  private void addAlignmentRef()
+  {
+    alignmentRefs++;
   }
 
   public Alignment getDataset()
@@ -648,7 +756,7 @@ public class Alignment
   {
     boolean modified = false;
 
-    //Remove excess gaps from the end of alignment
+    // Remove excess gaps from the end of alignment
     int maxLength = -1;
 
     SequenceI current;
@@ -657,8 +765,8 @@ public class Alignment
       current = getSequenceAt(i);
       for (int j = current.getLength(); j > maxLength; j--)
       {
-        if (j > maxLength && !jalview.util.Comparison.isGap(
-            current.getCharAt(j)))
+        if (j > maxLength
+                && !jalview.util.Comparison.isGap(current.getCharAt(j)))
         {
           maxLength = j;
           break;
@@ -669,16 +777,14 @@ public class Alignment
     maxLength++;
 
     int cLength;
-    for (int i = 0; i < sequences.size();
-         i++)
+    for (int i = 0; i < sequences.size(); i++)
     {
       current = getSequenceAt(i);
       cLength = current.getLength();
 
       if (cLength < maxLength)
       {
-        current.insertCharAt(cLength,
-                             maxLength - cLength, gapCharacter);
+        current.insertCharAt(cLength, maxLength - cLength, gapCharacter);
         modified = true;
       }
       else if (current.getLength() > maxLength)
@@ -688,6 +794,98 @@ public class Alignment
     }
     return modified;
   }
+  /**
+   * Justify the sequences to the left or right by deleting and inserting gaps before the initial residue or after the terminal residue
+   * @param right true if alignment padded to right, false to justify to left
+   * @return true if alignment was changed
+   */
+  public boolean justify(boolean right)
+  {
+    boolean modified = false;
+
+    // Remove excess gaps from the end of alignment
+    int maxLength = -1;
+    int ends[] = new int[sequences.size()*2];
+    SequenceI current;
+    for (int i = 0; i < sequences.size(); i++)
+    {
+      current = getSequenceAt(i);
+      // This should really be a sequence method
+      ends[i*2] = current.findIndex(current.getStart());
+      ends[i*2+1] = current.findIndex(current.getStart()+current.getLength());
+      boolean hitres=false;
+      for (int j = 0,rs=0,ssiz=current.getLength(); j<ssiz; j++)
+      {
+        if (!jalview.util.Comparison.isGap(current.getCharAt(j)))
+        {
+          if (!hitres)
+          {
+            ends[i*2] = j;
+            hitres=true;
+          } else {
+            ends[i*2+1] = j;
+            if (j-ends[i*2]>maxLength)
+            {
+              maxLength = j-ends[i*2];
+            }
+          }
+        }
+      }
+    }
+
+    maxLength++;
+    // now edit the flanking gaps to justify to either left or right
+    int cLength,extent,diff;
+    for (int i = 0; i < sequences.size(); i++)
+    {
+      current = getSequenceAt(i);
+      
+      cLength = 1+ends[i*2+1]-ends[i*2];
+      diff = maxLength-cLength; // number of gaps to indent
+      extent = current.getLength();
+      if (right)
+      {
+        // right justify
+        if (extent>ends[i*2+1])
+        {
+          current.deleteChars(ends[i*2+1]+1, extent);
+          modified = true;
+        }
+        if (ends[i*2]>diff)
+        {
+          current.deleteChars(0, ends[i*2]-diff);
+          modified = true;
+        } else {
+          if (ends[i*2]<diff)
+          {
+            current.insertCharAt(0, diff-ends[i*2],gapCharacter);
+            modified = true;
+          }
+        }
+      } else {
+        // left justify
+        if (ends[i*2]>0)
+        {
+          current.deleteChars(0, ends[i*2]);
+          modified = true;
+          ends[i*2+1]-=ends[i*2];
+          extent-=ends[i*2];
+        }
+        if (extent>maxLength)
+        {
+          current.deleteChars(maxLength+1, extent);
+          modified = true;
+        } else {
+          if (extent<maxLength)
+          {
+            current.insertCharAt(extent, maxLength-extent,gapCharacter);
+            modified = true;
+          }
+        }
+      }
+    }
+    return modified;
+  }
 
   public HiddenSequences getHiddenSequences()
   {
@@ -699,7 +897,7 @@ public class Alignment
     SeqCigar alseqs[] = new SeqCigar[sequences.size()];
     for (int i = 0; i < sequences.size(); i++)
     {
-      alseqs[i] = new SeqCigar( (SequenceI) sequences.elementAt(i));
+      alseqs[i] = new SeqCigar((SequenceI) sequences.elementAt(i));
     }
     CigarArray cal = new CigarArray(alseqs);
     cal.addOperation(CigarArray.M, getWidth());
@@ -708,15 +906,15 @@ public class Alignment
 
   public void setProperty(Object key, Object value)
   {
-    if(alignmentProperties==null)
+    if (alignmentProperties == null)
       alignmentProperties = new Hashtable();
 
-    alignmentProperties.put(key,value);
+    alignmentProperties.put(key, value);
   }
 
   public Object getProperty(Object key)
   {
-    if(alignmentProperties!=null)
+    if (alignmentProperties != null)
       return alignmentProperties.get(key);
     else
       return null;
@@ -727,4 +925,205 @@ public class Alignment
     return alignmentProperties;
   }
 
+  AlignedCodonFrame[] codonFrameList = null;
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see jalview.datamodel.AlignmentI#addCodonFrame(jalview.datamodel.AlignedCodonFrame)
+   */
+  public void addCodonFrame(AlignedCodonFrame codons)
+  {
+    if (codons == null)
+      return;
+    if (codonFrameList == null)
+    {
+      codonFrameList = new AlignedCodonFrame[]
+      { codons };
+      return;
+    }
+    AlignedCodonFrame[] t = new AlignedCodonFrame[codonFrameList.length + 1];
+    System.arraycopy(codonFrameList, 0, t, 0, codonFrameList.length);
+    t[codonFrameList.length] = codons;
+    codonFrameList = t;
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see jalview.datamodel.AlignmentI#getCodonFrame(int)
+   */
+  public AlignedCodonFrame getCodonFrame(int index)
+  {
+    return codonFrameList[index];
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see jalview.datamodel.AlignmentI#getCodonFrame(jalview.datamodel.SequenceI)
+   */
+  public AlignedCodonFrame[] getCodonFrame(SequenceI seq)
+  {
+    if (seq == null || codonFrameList == null)
+      return null;
+    Vector cframes = new Vector();
+    for (int f = 0; f < codonFrameList.length; f++)
+    {
+      if (codonFrameList[f].involvesSequence(seq))
+        cframes.addElement(codonFrameList[f]);
+    }
+    if (cframes.size() == 0)
+      return null;
+    AlignedCodonFrame[] cfr = new AlignedCodonFrame[cframes.size()];
+    cframes.copyInto(cfr);
+    return cfr;
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see jalview.datamodel.AlignmentI#getCodonFrames()
+   */
+  public AlignedCodonFrame[] getCodonFrames()
+  {
+    return codonFrameList;
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see jalview.datamodel.AlignmentI#removeCodonFrame(jalview.datamodel.AlignedCodonFrame)
+   */
+  public boolean removeCodonFrame(AlignedCodonFrame codons)
+  {
+    if (codons == null || codonFrameList == null)
+      return false;
+    boolean removed = false;
+    int i = 0, iSize = codonFrameList.length;
+    while (i < iSize)
+    {
+      if (codonFrameList[i] == codons)
+      {
+        removed = true;
+        if (i + 1 < iSize)
+        {
+          System.arraycopy(codonFrameList, i + 1, codonFrameList, i, iSize
+                  - i - 1);
+        }
+        iSize--;
+      }
+      else
+      {
+        i++;
+      }
+    }
+    return removed;
+  }
+
+  public void append(AlignmentI toappend)
+  {
+    // TODO test this method for a future 2.5 release
+    // currently tested for use in jalview.gui.SequenceFetcher
+    boolean samegap = toappend.getGapCharacter()==getGapCharacter();
+    char oldc = toappend.getGapCharacter();
+    boolean hashidden = toappend.getHiddenSequences()!=null && toappend.getHiddenSequences().hiddenSequences!=null;
+    // get all sequences including any hidden ones
+    Vector sqs = (hashidden) ? toappend.getHiddenSequences().getFullAlignment().getSequences() : toappend.getSequences();
+    if (sqs != null)
+    {
+      Enumeration sq = sqs.elements();
+      while (sq.hasMoreElements())
+      {
+        SequenceI addedsq=(SequenceI) sq.nextElement();
+        if (!samegap)
+        {
+          char[] oldseq = addedsq.getSequence();
+          for (int c=0;c<oldseq.length;c++)
+          {
+            if (oldseq[c]==oldc)
+            {
+              oldseq[c] = gapCharacter;
+            }
+          }
+        }
+        addSequence(addedsq);
+      }
+    }
+    AlignmentAnnotation[] alan = toappend.getAlignmentAnnotation();
+    for (int a = 0; alan != null && a < alan.length; a++)
+    {
+      addAnnotation(alan[a]);
+    }
+    AlignedCodonFrame[] acod = toappend.getCodonFrames();
+    for (int a = 0; acod != null && a < acod.length; a++)
+    {
+      this.addCodonFrame(acod[a]);
+    }
+    Vector sg = toappend.getGroups();
+    if (sg != null)
+    {
+      Enumeration el = sg.elements();
+      while (el.hasMoreElements())
+      {
+        addGroup((SequenceGroup) el.nextElement());
+      }
+    }
+    if (toappend.getHiddenSequences()!=null)
+    {
+      HiddenSequences hs = toappend.getHiddenSequences();
+      if (hiddenSequences==null)
+      {
+        hiddenSequences = new HiddenSequences(this);
+      }
+      if (hs.hiddenSequences!=null)
+      {
+        for (int s=0;s<hs.hiddenSequences.length; s++)
+        {
+          // hide the newly appended sequence in the alignment
+          if (hs.hiddenSequences[s]!=null)
+          {
+            hiddenSequences.hideSequence(hs.hiddenSequences[s]);
+          }
+        }
+      }
+    }
+    if (toappend.getProperties()!=null)
+    {
+      // we really can't do very much here - just try to concatenate strings where property collisions occur.
+      Enumeration key = toappend.getProperties().keys();
+      while (key.hasMoreElements())
+      {
+        Object k = key.nextElement();
+        Object ourval = this.getProperty(k);
+        Object toapprop = toappend.getProperty(k);
+        if (ourval!=null)
+        {
+          if (ourval.getClass().equals(toapprop.getClass()) && !ourval.equals(toapprop))
+          {
+            if (ourval instanceof String)
+            {
+              // append strings
+              this.setProperty(k, ((String) ourval)+"; "+((String) toapprop));
+            } else {
+              if (ourval instanceof Vector)
+              {
+                // append vectors
+                Enumeration theirv = ((Vector) toapprop).elements();
+                while (theirv.hasMoreElements())
+                {
+                  ((Vector)ourval).addElement(theirv);
+                }
+              }
+            }
+          }
+        } else {
+          // just add new property directly
+          setProperty(k, toapprop);
+        }
+       
+      }
+    }
+  }
+
 }