JAL-972 workaround for working out source URL for pre DAS 1.6 sources.
[jalview.git] / src / jalview / datamodel / AlignmentOrder.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
3  * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
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 of the License, or (at your option) any later version.
10  * 
11  * Jalview is distributed in the hope that it will be useful, but 
12  * WITHOUT ANY WARRANTY; without even the implied warranty 
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
14  * PURPOSE.  See the GNU General Public License for more details.
15  * 
16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 package jalview.datamodel;
19
20 import java.util.*;
21
22 public class AlignmentOrder
23 {
24   // JBPNote : this method would return a vector containing all sequences in
25   // seqset
26   // with those also contained in order at the beginning of the vector in the
27   // order
28   // given by order. AlignmentSorter.vectorSubsetToArray already does this, but
29   // that method
30   // should be here for completeness.
31
32   /*
33    * public Vector getOrder(AlignmentI seqset) { Vector perm = new
34    * Vector(seqset.getHeight()); for (i=0, o = 0, n=seqset.getHeight(), p =
35    * Order.size(); i<n; i++) perm.setElement(i,...). return Order; }
36    */
37
38   /** DOCUMENT ME!! */
39   public static final int FILE = 0;
40
41   /** DOCUMENT ME!! */
42   public static final int MSA = 1;
43
44   /** DOCUMENT ME!! */
45   public static final int USER = 2;
46
47   private int Type = 0;
48
49   private String Name;
50
51   private Vector Order = null;
52
53   /**
54    * Creates a new AlignmentOrder object.
55    */
56   public AlignmentOrder()
57   {
58   }
59
60   /**
61    * AlignmentOrder
62    * 
63    * @param anOrder
64    *          Vector
65    */
66   public AlignmentOrder(Vector anOrder)
67   {
68     Order = anOrder;
69   }
70
71   /**
72    * AlignmentOrder
73    * 
74    * @param orderFrom
75    *          AlignmentI
76    */
77   public AlignmentOrder(AlignmentI orderFrom)
78   {
79     Order = new Vector();
80
81     for (int i = 0, ns = orderFrom.getHeight(); i < ns; i++)
82     {
83       Order.addElement(orderFrom.getSequenceAt(i));
84     }
85   }
86
87   /**
88    * Creates a new AlignmentOrder object.
89    * 
90    * @param orderFrom
91    *          DOCUMENT ME!
92    */
93   public AlignmentOrder(SequenceI[] orderFrom)
94   {
95     Order = new Vector();
96
97     for (int i = 0, ns = orderFrom.length; i < ns; i++)
98     {
99       Order.addElement(orderFrom[i]);
100     }
101   }
102
103   /**
104    * DOCUMENT ME!
105    * 
106    * @param Type
107    *          DOCUMENT ME!
108    */
109   public void setType(int Type)
110   {
111     this.Type = Type;
112   }
113
114   /**
115    * DOCUMENT ME!
116    * 
117    * @return DOCUMENT ME!
118    */
119   public int getType()
120   {
121     return Type;
122   }
123
124   /**
125    * DOCUMENT ME!
126    * 
127    * @param Name
128    *          DOCUMENT ME!
129    */
130   public void setName(String Name)
131   {
132     this.Name = Name;
133   }
134
135   /**
136    * DOCUMENT ME!
137    * 
138    * @return DOCUMENT ME!
139    */
140   public String getName()
141   {
142     return Name;
143   }
144
145   /**
146    * DOCUMENT ME!
147    * 
148    * @param Order
149    *          DOCUMENT ME!
150    */
151   public void setOrder(Vector Order)
152   {
153     this.Order = Order;
154   }
155
156   /**
157    * DOCUMENT ME!
158    * 
159    * @return DOCUMENT ME!
160    */
161   public Vector getOrder()
162   {
163     return Order;
164   }
165
166   /**
167    * replaces oldref with newref in the alignment order.
168    * 
169    * @param oldref
170    * @param newref
171    * @return true if oldref was contained in order and replaced with newref
172    */
173   public boolean updateSequence(SequenceI oldref, SequenceI newref)
174   {
175     int found = Order.indexOf(oldref);
176     if (found > -1)
177     {
178       Order.setElementAt(newref, found);
179     }
180     return found > -1;
181   }
182
183   /**
184    * Exact equivalence of two AlignmentOrders
185    * 
186    * @param o
187    * @return true if o orders the same sequenceI objects in the same way
188    */
189   public boolean equals(AlignmentOrder o)
190   {
191     return equals(o, true);
192   }
193
194   /**
195    * Exact equivalence of two AlignmentOrders // TODO: Weak SequenceI
196    * equivalence - will throw Error at moment
197    * 
198    * @param o
199    * @param identity
200    *          - false - use weak equivalence (refers to same or different parts
201    *          of same sequence)
202    * @return true if o orders equivalent sequenceI objects in the same way
203    */
204   public boolean equals(AlignmentOrder o, boolean identity)
205   {
206     if (o != this)
207     {
208       if (o == null)
209       {
210         return false;
211       }
212       if (Order != null && o.Order != null
213               && Order.size() == o.Order.size())
214       {
215         if (!identity)
216         {
217           throw new Error("Weak sequenceI equivalence not yet implemented.");
218         }
219         else
220         {
221           for (int i = 0, j = o.Order.size(); i < j; i++)
222           {
223             if (Order.elementAt(i) != o.Order.elementAt(i))
224             {
225               return false;
226             }
227           }
228         }
229       }
230       else
231       {
232         return false;
233       }
234     }
235     return true;
236   }
237
238   /**
239    * Consistency test for alignmentOrders
240    * 
241    * @param o
242    * @return true if o contains or is contained by this and the common SequenceI
243    *         objects are ordered in the same way
244    */
245   public boolean isConsistent(AlignmentOrder o)
246   {
247     return isConsistent(o, true);
248   }
249
250   /**
251    * Consistency test for alignmentOrders
252    * 
253    * @param o
254    *          // TODO: Weak SequenceI equivalence - will throw Error at moment
255    * @param identity
256    *          - false - use weak equivalence (refers to same or different parts
257    *          of same sequence)
258    * @return true if o contains or is contained by this and the common SequenceI
259    *         objects are ordered in the same way
260    */
261   public boolean isConsistent(AlignmentOrder o, boolean identity)
262   {
263     if (o != this)
264     {
265       if (o == null)
266       {
267         return false;
268       }
269       if (Order != null && o.Order != null)
270       {
271         Vector c, s;
272         if (o.Order.size() > Order.size())
273         {
274           c = o.Order;
275           s = Order;
276         }
277         else
278         {
279           c = Order;
280           s = o.Order;
281         }
282         if (!identity)
283         {
284           throw new Error("Weak sequenceI equivalence not yet implemented.");
285         }
286         else
287         {
288           // test if c contains s and order in s is conserved in c
289           int last = -1;
290           for (int i = 0, j = s.size(); i < j; i++)
291           {
292             int pos = c.indexOf(s.elementAt(i)); // JBPNote - optimize by
293             // incremental position search
294             if (pos > last)
295             {
296               last = pos;
297             }
298             else
299             {
300               return false;
301             }
302           }
303         }
304       }
305       else
306       {
307         return false;
308       }
309     }
310     return true;
311   }
312   /**
313    * AlignmentOrder
314    * 
315    * @param orderThis
316    *          AlignmentI
317    * @param byThat
318    *          AlignmentI
319    */
320
321   /*
322    * public AlignmentOrder(AlignmentI orderThis, AlignmentI byThat) { // Vector
323    * is an ordering of this alignment using the order of sequence objects in
324    * byThat, // where ids and unaligned sequences must match }
325    */
326 }