/* * Copyright (c) 2007 BUSINESS OBJECTS SOFTWARE LIMITED * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * * Neither the name of Business Objects nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * FixedSizeList.java * Created: Apr 22, 2005 * By: Bo Ilic */ package org.openquark.cal.util; import java.io.Serializable; import java.util.AbstractList; import java.util.List; import java.util.RandomAccess; /** * Provides factory methods for creating fixed sized lists with sizes * varying from 1 to 7. * * <P>These lists provide fast random access to elements and are also more memory efficient * than using ArrayList or Vector. * * <P>If the list is size 0, one can just use Collections.EMPTY_LIST. * If the list is size 1, Collections.singletonList for an unmodifiable list. However, List1 is modifiable. * * @author Bo Ilic */ public abstract class FixedSizeList { private static final class List1<T> extends AbstractList<T> implements RandomAccess, Serializable { /** Only change this when an incompatible change has been made to the class schema */ static final long serialVersionUID = -55636750666820200L; private T element0; List1(T element0) { this.element0 = element0; } /** {@inheritDoc}*/ @Override public T get(int index) { switch (index) { case 0: return element0; default: throw new IndexOutOfBoundsException("index must be be 0 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public T set(int index, T element) { T oldValue; switch (index) { case 0: oldValue = element0; element0 = element; return oldValue; default: throw new IndexOutOfBoundsException("index must be between 0 and 1 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public int size() { return 1; } } private static final class List2<T> extends AbstractList<T> implements RandomAccess, Serializable { /** Only change this when an incompatible change has been made to the class schema */ static final long serialVersionUID = -1520120374883127099L; private T element0; private T element1; List2(T element0, T element1) { this.element0 = element0; this.element1 = element1; } /** {@inheritDoc}*/ @Override public T get(int index) { switch (index) { case 0: return element0; case 1: return element1; default: throw new IndexOutOfBoundsException("index must be between 0 and 1 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public T set(int index, T element) { T oldValue; switch (index) { case 0: oldValue = element0; element0 = element; return oldValue; case 1: oldValue = element1; element1 = element; return oldValue; default: throw new IndexOutOfBoundsException("index must be between 0 and 1 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public int size() { return 2; } } private static final class List3<T> extends AbstractList<T> implements RandomAccess, Serializable { /** Only change this when an incompatible change has been made to the class schema */ static final long serialVersionUID = 5775458853820390711L; private T element0; private T element1; private T element2; List3(T element0, T element1, T element2) { this.element0 = element0; this.element1 = element1; this.element2 = element2; } /** {@inheritDoc}*/ @Override public T get(int index) { switch (index) { case 0: return element0; case 1: return element1; case 2: return element2; default: throw new IndexOutOfBoundsException("index must be between 0 and 2 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public T set(int index, T element) { T oldValue; switch (index) { case 0: oldValue = element0; element0 = element; return oldValue; case 1: oldValue = element1; element1 = element; return oldValue; case 2: oldValue = element2; element2 = element; return oldValue; default: throw new IndexOutOfBoundsException("index must be between 0 and 1 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public int size() { return 3; } } private static final class List4<T> extends AbstractList<T> implements RandomAccess, Serializable { /** Only change this when an incompatible change has been made to the class schema */ static final long serialVersionUID = 1199643529534887277L; private T element0; private T element1; private T element2; private T element3; List4(T element0, T element1, T element2, T element3) { this.element0 = element0; this.element1 = element1; this.element2 = element2; this.element3 = element3; } /** {@inheritDoc}*/ @Override public T get(int index) { switch (index) { case 0: return element0; case 1: return element1; case 2: return element2; case 3: return element3; default: throw new IndexOutOfBoundsException("index must be between 0 and 3 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public T set(int index, T element) { T oldValue; switch (index) { case 0: oldValue = element0; element0 = element; return oldValue; case 1: oldValue = element1; element1 = element; return oldValue; case 2: oldValue = element2; element2 = element; return oldValue; case 3: oldValue = element3; element3 = element; return oldValue; default: throw new IndexOutOfBoundsException("index must be between 0 and 1 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public int size() { return 4; } } private static final class List5<T> extends AbstractList<T> implements RandomAccess, Serializable { /** Only change this when an incompatible change has been made to the class schema */ static final long serialVersionUID = -6168645202459303757L; private T element0; private T element1; private T element2; private T element3; private T element4; List5(T element0, T element1, T element2, T element3, T element4) { this.element0 = element0; this.element1 = element1; this.element2 = element2; this.element3 = element3; this.element4 = element4; } /** {@inheritDoc}*/ @Override public T get(int index) { switch (index) { case 0: return element0; case 1: return element1; case 2: return element2; case 3: return element3; case 4: return element4; default: throw new IndexOutOfBoundsException("index must be between 0 and 4 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public T set(int index, T element) { T oldValue; switch (index) { case 0: oldValue = element0; element0 = element; return oldValue; case 1: oldValue = element1; element1 = element; return oldValue; case 2: oldValue = element2; element2 = element; return oldValue; case 3: oldValue = element3; element3 = element; return oldValue; case 4: oldValue = element4; element4 = element; return oldValue; default: throw new IndexOutOfBoundsException("index must be between 0 and 1 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public int size() { return 5; } } private static final class List6<T> extends AbstractList<T> implements RandomAccess, Serializable { /** Only change this when an incompatible change has been made to the class schema */ static final long serialVersionUID = -8214268383872794025L; private T element0; private T element1; private T element2; private T element3; private T element4; private T element5; List6(T element0, T element1, T element2, T element3, T element4, T element5) { this.element0 = element0; this.element1 = element1; this.element2 = element2; this.element3 = element3; this.element4 = element4; this.element5 = element5; } /** {@inheritDoc}*/ @Override public T get(int index) { switch (index) { case 0: return element0; case 1: return element1; case 2: return element2; case 3: return element3; case 4: return element4; case 5: return element5; default: throw new IndexOutOfBoundsException("index must be between 0 and 5 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public T set(int index, T element) { T oldValue; switch (index) { case 0: oldValue = element0; element0 = element; return oldValue; case 1: oldValue = element1; element1 = element; return oldValue; case 2: oldValue = element2; element2 = element; return oldValue; case 3: oldValue = element3; element3 = element; return oldValue; case 4: oldValue = element4; element4 = element; return oldValue; case 5: oldValue = element5; element5 = element; return oldValue; default: throw new IndexOutOfBoundsException("index must be between 0 and 1 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public int size() { return 6; } } private static final class List7<T> extends AbstractList<T> implements RandomAccess, Serializable { /** Only change this when an incompatible change has been made to the class schema */ static final long serialVersionUID = 2104497566436723863L; private T element0; private T element1; private T element2; private T element3; private T element4; private T element5; private T element6; List7(T element0, T element1, T element2, T element3, T element4, T element5, T element6) { this.element0 = element0; this.element1 = element1; this.element2 = element2; this.element3 = element3; this.element4 = element4; this.element5 = element5; this.element6 = element6; } /** {@inheritDoc}*/ @Override public T get(int index) { switch (index) { case 0: return element0; case 1: return element1; case 2: return element2; case 3: return element3; case 4: return element4; case 5: return element5; case 6: return element6; default: throw new IndexOutOfBoundsException("index must be between 0 and 6 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public T set(int index, T element) { T oldValue; switch (index) { case 0: oldValue = element0; element0 = element; return oldValue; case 1: oldValue = element1; element1 = element; return oldValue; case 2: oldValue = element2; element2 = element; return oldValue; case 3: oldValue = element3; element3 = element; return oldValue; case 4: oldValue = element4; element4 = element; return oldValue; case 5: oldValue = element5; element5 = element; return oldValue; case 6: oldValue = element6; element6 = element; return oldValue; default: throw new IndexOutOfBoundsException("index must be between 0 and 1 but was " + index + "."); } } /** {@inheritDoc}*/ @Override public int size() { return 7; } } /** * Non-instantiable factory class. */ private FixedSizeList() {} /** * @return a two element fixed-size modifiable random-access list. The returned list is Serializable. */ public static final <T> List<T> make(T e0) { return new List1<T>(e0); } /** * @return a two element fixed-size modifiable random-access list. The returned list is Serializable. */ public static final <T> List<T> make(T e0, T e1) { return new List2<T>(e0, e1); } /** * @return a three element fixed-size modifiable random-access list. The returned list is Serializable. */ public static final <T> List<T> make(T e0, T e1, T e2) { return new List3<T>(e0, e1, e2); } /** * @return a four element fixed-size modifiable random-access list. The returned list is Serializable. */ public static final <T> List<T> make(T e0, T e1, T e2, T e3) { return new List4<T>(e0, e1, e2, e3); } /** * @return a five element fixed-size modifiable random-access list. The returned list is Serializable. */ public static final <T> List<T> make(T e0, T e1, T e2, T e3, T e4) { return new List5<T>(e0, e1, e2, e3, e4); } /** * @return a six element fixed-size modifiable random-access list. The returned list is Serializable. */ public static final <T> List<T> make(T e0, T e1, T e2, T e3, T e4, T e5) { return new List6<T>(e0, e1, e2, e3, e4, e5); } /** * @return a seven element fixed-size modifiable random-access list. The returned list is Serializable. */ public static final <T> List<T> make(T e0, T e1, T e2, T e3, T e4, T e5, T e6) { return new List7<T>(e0, e1, e2, e3, e4, e5, e6); } }