+ /**
+ * replaces oldref with newref in the alignment order.
+ *
+ * @param oldref
+ * @param newref
+ * @return true if oldref was contained in order and replaced with newref
+ */
+ public boolean updateSequence(SequenceI oldref, SequenceI newref)
+ {
+ int found = Order.indexOf(oldref);
+ if (found > -1)
+ {
+ Order.setElementAt(newref, found);
+ }
+ return found > -1;
+ }
+
+ /**
+ * Exact equivalence of two AlignmentOrders
+ *
+ * @param o
+ * @return true if o orders the same sequenceI objects in the same way
+ */
+ public boolean equals(AlignmentOrder o)
+ {
+ return equals(o, true);
+ }
+
+ /**
+ * Exact equivalence of two AlignmentOrders // TODO: Weak SequenceI
+ * equivalence - will throw Error at moment
+ *
+ * @param o
+ * @param identity
+ * - false - use weak equivalence (refers to same or different parts
+ * of same sequence)
+ * @return true if o orders equivalent sequenceI objects in the same way
+ */
+ public boolean equals(AlignmentOrder o, boolean identity)
+ {
+ if (o != this)
+ {
+ if (o == null)
+ {
+ return false;
+ }
+ if (Order != null && o.Order != null
+ && Order.size() == o.Order.size())
+ {
+ if (!identity)
+ {
+ throw new Error("Weak sequenceI equivalence not yet implemented.");
+ }
+ else
+ {
+ for (int i = 0, j = o.Order.size(); i < j; i++)
+ {
+ if (Order.elementAt(i) != o.Order.elementAt(i))
+ {
+ return false;
+ }
+ }
+ }
+ }
+ else
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Consistency test for alignmentOrders
+ *
+ * @param o
+ * @return true if o contains or is contained by this and the common SequenceI
+ * objects are ordered in the same way
+ */
+ public boolean isConsistent(AlignmentOrder o)
+ {
+ return isConsistent(o, true);
+ }
+
+ /**
+ * Consistency test for alignmentOrders
+ *
+ * @param o
+ * // TODO: Weak SequenceI equivalence - will throw Error at moment
+ * @param identity
+ * - false - use weak equivalence (refers to same or different parts
+ * of same sequence)
+ * @return true if o contains or is contained by this and the common SequenceI
+ * objects are ordered in the same way
+ */
+ public boolean isConsistent(AlignmentOrder o, boolean identity)
+ {
+ if (o != this)
+ {
+ if (o == null)
+ {
+ return false;
+ }
+ if (Order != null && o.Order != null)
+ {
+ Vector c, s;
+ if (o.Order.size() > Order.size())
+ {
+ c = o.Order;
+ s = Order;
+ }
+ else
+ {
+ c = Order;
+ s = o.Order;
+ }
+ if (!identity)
+ {
+ throw new Error("Weak sequenceI equivalence not yet implemented.");
+ }
+ else
+ {
+ // test if c contains s and order in s is conserved in c
+ int last = -1;
+ for (int i = 0, j = s.size(); i < j; i++)
+ {
+ int pos = c.indexOf(s.elementAt(i)); // JBPNote - optimize by
+ // incremental position search
+ if (pos > last)
+ {
+ last = pos;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ }
+ }
+ else
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+ /**
+ * AlignmentOrder
+ *
+ * @param orderThis
+ * AlignmentI
+ * @param byThat
+ * AlignmentI
+ */
+
+ /*
+ * public AlignmentOrder(AlignmentI orderThis, AlignmentI byThat) { // Vector
+ * is an ordering of this alignment using the order of sequence objects in
+ * byThat, // where ids and unaligned sequences must match }
+ */
+}