@Override public void addElements(int index, final byte a[], int offset, int length) { synchronized (sync) { list.addElements(index, a, offset, length); } } @Override
@Override public void size(final int size) { list.size(size); } @Override
@Override public byte[] toByteArray() { return list.toByteArray(); } @Override
/** * Creates a new array list and fills it with a given type-specific list. * * @param l * a type-specific list that will be used to fill the array list. */ public ByteArrayList(final ByteList l) { this(l.size()); l.getElements(0, a, 0, size = l.size()); } /**
ByteList rightScores = new ByteArrayList(block.getQualities()); int deletionPosition = var.getPosition() - 1; leftBases = leftBases.subList(0, deletionPosition); rightBases = rightBases.subList(deletionPosition, rightBases.size()); leftScores = leftScores.subList(0, deletionPosition); rightScores = rightScores.subList(deletionPosition, rightScores.size()); leftBases.toByteArray(new byte[leftBases.size()]), leftScores.toByteArray(new byte[leftScores.size()])); AlignmentBlock right = new AlignmentBlockImpl(block.getStart() + leftBases.size() + var.getFrom().length(), rightBases.toByteArray(new byte[rightBases.size()]), rightScores.toByteArray(new byte[rightScores.size()]));
/** * Shuffles the specified list using the specified pseudorandom number * generator. * * @param l * the list to be shuffled. * @param random * a pseudorandom number generator. * @return {@code l}. */ public static ByteList shuffle(final ByteList l, final Random random) { for (int i = l.size(); i-- != 0;) { final int p = random.nextInt(i + 1); final byte t = l.getByte(i); l.set(i, l.getByte(p)); l.set(p, t); } return l; } /**
@Override public ByteList subList(final int from, final int to) { return new UnmodifiableList(list.subList(from, to)); } @Override
@Override public boolean addAll(Collection<? extends Byte> c) { return list.addAll(c); } @Override
@Override public boolean add(byte key) { return list.add(key); } @Override
@Override public boolean containsAll(ByteCollection c) { return list.containsAll(c); } @Override
@Override public int compareTo(final List<? extends Byte> o) { return list.compareTo(o); } @Override
@Override public boolean contains(final byte key) { return list.contains(key); } @Override
@Override public void clear() { list.clear(); } @Override
@Override public ByteList subList(final int from, final int to) { synchronized (sync) { return new SynchronizedList(list.subList(from, to), sync); } } @Override
@Override public boolean addAll(final int index, final ByteList l) { ensureIndex(index); final int n = l.size(); if (n == 0) return false; grow(size + n); if (index != size) System.arraycopy(a, index, a, index + n, size - index); l.getElements(0, a, index, n); size += n; assert size <= a.length; return true; } @Override
@Override public boolean addAll(final int index, final Collection<? extends Byte> c) { synchronized (sync) { return list.addAll(index, c); } } @Override
@Override public void add(final int i, final byte k) { synchronized (sync) { list.add(i, k); } } @Override
@Override public boolean containsAll(Collection<?> c) { return list.containsAll(c); } @Override
@Override public int compareTo(final List<? extends Byte> o) { synchronized (sync) { return list.compareTo(o); } } @Override
@Override public ByteList subList(final int from, final int to) { synchronized (sync) { return new SynchronizedRandomAccessList(list.subList(from, to), sync); } } }