+ /**
+ * Make an alignment from an array of Sequences.
+ *
+ * @param sequences
+ */
+ public Alignment(SequenceI[] seqs)
+ {
+ initAlignment(seqs);
+ }
+
+ /**
+ * Make a new alignment from an array of SeqCigars
+ *
+ * @param seqs
+ * SeqCigar[]
+ */
+ public Alignment(SeqCigar[] alseqs)
+ {
+ SequenceI[] seqs = SeqCigar.createAlignmentSequences(alseqs,
+ gapCharacter, new HiddenColumns(), 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
+ */
+ public static AlignmentI createAlignment(CigarArray compactAlignment)
+ {
+ throw new Error(MessageManager
+ .getString("error.alignment_cigararray_not_implemented"));
+ // this(compactAlignment.refCigars);
+ }
+
+ @Override
+ public List<SequenceI> getSequences()
+ {
+ return sequences;
+ }
+
+ @Override
+ public List<SequenceI> getSequences(
+ Map<SequenceI, SequenceCollectionI> hiddenReps)
+ {
+ // TODO: in jalview 2.8 we don't do anything with hiddenreps - fix design to
+ // work on this.
+ return sequences;
+ }
+
+ @Override
+ public SequenceI[] getSequencesArray()
+ {
+ if (sequences == null)
+ {
+ return null;
+ }
+ synchronized (sequences)
+ {
+ return sequences.toArray(new SequenceI[sequences.size()]);
+ }
+ }
+
+ /**
+ * Returns a map of lists of sequences keyed by sequence name.
+ *
+ * @return
+ */
+ @Override
+ public Map<String, List<SequenceI>> getSequencesByName()
+ {
+ return AlignmentUtils.getSequencesByName(this);
+ }
+
+ @Override
+ public SequenceI getSequenceAt(int i)
+ {
+ synchronized (sequences)
+ {
+ if (i > -1 && i < sequences.size())
+ {
+ return sequences.get(i);
+ }
+ }
+
+ return null;
+ }
+
+ @Override
+ public SequenceI getSequenceAtAbsoluteIndex(int i)
+ {
+ SequenceI seq = null;
+ if (getHiddenSequences().getSize() > 0)
+ {
+ seq = getHiddenSequences().getHiddenSequence(i);
+ if (seq == null)
+ {
+ // didn't find the sequence in the hidden sequences, get it from the
+ // alignment
+ int index = getHiddenSequences().findIndexWithoutHiddenSeqs(i);
+ seq = getSequenceAt(index);
+ }
+ }
+ else
+ {
+ seq = getSequenceAt(i);
+ }
+ return seq;
+ }
+
+ /**
+ * Adds a sequence to the alignment. Recalculates maxLength and size. Note
+ * this currently does not recalculate whether or not the alignment is
+ * nucleotide, so mixed alignments may have undefined behaviour.
+ *
+ * @param snew
+ */
+ @Override
+ public void addSequence(SequenceI snew)
+ {
+ if (dataset != null)
+ {
+
+ // maintain dataset integrity
+ SequenceI dsseq = snew.getDatasetSequence();
+ if (dsseq == null)
+ {
+ // derive new sequence
+ SequenceI adding = snew.deriveSequence();
+ snew = adding;
+ dsseq = snew.getDatasetSequence();
+ }
+ if (getDataset().findIndex(dsseq) == -1)
+ {
+ getDataset().addSequence(dsseq);
+ }
+
+ }
+ if (sequences == null)
+ {
+ initAlignment(new SequenceI[] { snew });
+ }
+ else
+ {
+ synchronized (sequences)
+ {
+ sequences.add(snew);
+ }
+ }
+ if (hiddenSequences != null)
+ {
+ hiddenSequences.adjustHeightSequenceAdded();
+ }
+ }
+
+ @Override
+ public SequenceI replaceSequenceAt(int i, SequenceI snew)
+ {
+ synchronized (sequences)
+ {
+ if (sequences.size() > i)
+ {
+ return sequences.set(i, snew);
+
+ }