Java tutorial
/* * File : $Source: /alkacon/cvs/alkacon/com.alkacon.opencms.documentcenter/src/com/alkacon/opencms/documentcenter/CmsDocumentList.java,v $ * Date : $Date: 2010/03/19 15:31:13 $ * Version: $Revision: 1.3 $ * * This file is part of the Alkacon OpenCms Add-On Module Package * * Copyright (c) 2010 Alkacon Software GmbH (http://www.alkacon.com) * * The Alkacon OpenCms Add-On Module Package is free software: * you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The Alkacon OpenCms Add-On Module Package is distributed * in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with the Alkacon OpenCms Add-On Module Package. * If not, see http://www.gnu.org/licenses/. * * For further information about Alkacon Software GmbH, please see the * company website: http://www.alkacon.com. * * For further information about OpenCms, please see the * project website: http://www.opencms.org. */ package com.alkacon.opencms.documentcenter; import org.opencms.main.CmsLog; import java.util.AbstractList; import java.util.ArrayList; import java.util.List; import org.apache.commons.logging.Log; /** * Provides methods to create a special list of CmsDocument objects regarding language and attachment functionality.<p> * * After adding all documents to the list, the {@link #closeList()} method has to be called once * before working with the list contents, e.g. before sorting the list or iterating it.<p> * * @author Andreas Zahner * * @version $Revision: 1.3 $ * * @since 6.2.0 */ public class CmsDocumentList extends AbstractList { /** The log object for this class. */ private static final Log LOG = CmsLog.getLog(CmsDocumentList.class); private List m_attachments; private CmsDocument[] m_documents; private boolean m_onlyVersions; private int m_size; private boolean m_useAttachments; private boolean m_useLanguages; private boolean m_useTypes; private String m_defaultType; /** * Creates an empty document list with an initial capacity of 16 items.<p> */ public CmsDocumentList() { this(16); } /** * Creates an empty document list with the flags to use language versions and attachments, to show only versions and * the given initial capacity.<p> * * @param useTypes the flag if different types of a document should be considered * @param defaultType if list uses types, the default type is specified here * @param useAttachments the flag if attachments of a document should be conbsidered * @param useLanguages the flag if language versions of a document should be considered * @param onlyVersions the flag if only versions of a specific document should be added to the list * @param initialCapacity the initial capacity of the document list */ public CmsDocumentList(boolean useTypes, String defaultType, boolean useAttachments, boolean useLanguages, boolean onlyVersions, int initialCapacity) { m_documents = new CmsDocument[initialCapacity]; m_size = 0; m_attachments = new ArrayList(); m_useLanguages = useLanguages; m_onlyVersions = onlyVersions; m_useAttachments = useAttachments; m_useTypes = useTypes; m_defaultType = defaultType; } /** * Creates an empty document list with the flags to use language versions and attachments, to show only versions and * the given initial capacity.<p> * * @param useAttachments the flag is attachments of a document should be conbsidered * @param useLanguages the flag if language versions of a document should be considered * @param onlyVersions the flag if only versions of a specific document should be added to the list * @param initialCapacity the initial capacity of the document list */ public CmsDocumentList(boolean useAttachments, boolean useLanguages, boolean onlyVersions, int initialCapacity) { this(false, null, useAttachments, useLanguages, onlyVersions, initialCapacity); } /** * Creates an empty document list with the flags to use language versions, to show only versions and the given initial capacity.<p> * * @param useLanguages the flag if language versions of a document should be considered * @param onlyVersions the flag if only versions of a specific document should be added to the list * @param initialCapacity the initial capacity of the document list */ public CmsDocumentList(boolean useLanguages, boolean onlyVersions, int initialCapacity) { this(true, useLanguages, onlyVersions, initialCapacity); } /** * Creates an empty document list with the given initial capacity.<p> * * @param initialCapacity the initial capacity of the document list */ public CmsDocumentList(int initialCapacity) { this(false, false, initialCapacity); } /** * @see java.util.AbstractList#add(int, java.lang.Object) */ public void add(int index, Object element) { rangeCheck(index); CmsDocument doc = convertDocument(element); if (doc.isNullDocument() || checkContainer(doc)) { return; } ensureCapacity(m_size + 1); // Increments modCount!! System.arraycopy(m_documents, index, m_documents, index + 1, m_size - index); m_documents[index] = doc; m_size++; } /** * @see java.util.AbstractList#add(java.lang.Object) */ public boolean add(Object element) { CmsDocument doc = convertDocument(element); if (doc.isNullDocument() || checkContainer(doc)) { return true; } ensureCapacity(m_size + 1); m_documents[m_size++] = doc; return true; } /** * @see java.util.Collection#clear() */ public void clear() { modCount++; for (int i = 0; i < m_size; i++) { m_documents[i] = null; } m_size = 0; } /** * Closes the list after adding all documents to it, this is needed to assign the found attachments to the documents.<p> */ public void closeList() { for (int i = 0; i < m_attachments.size(); i++) { // loop through all attachments CmsDocument att = (CmsDocument) m_attachments.get(i); boolean added = false; for (int k = 0; k < m_size; k++) { // check if the attachment belongs to a document if (m_documents[k].isVersionOf(att)) { // found a document for the attachment if (m_documents[k].addAttachment(att)) { added = true; break; } } } if (!added) { // found no document for the attachment, add it as separate attachment to the list ensureCapacity(m_size + 1); m_documents[m_size++] = att; } } // empty the attachment list m_attachments = new ArrayList(); } /** * @see java.util.Collection#contains(java.lang.Object) */ public boolean contains(Object elem) { return indexOf(elem) >= 0; } /** * Increases the capacity of this <tt>CmsDocumentList</tt> instance, if * necessary, to ensure that it can hold at least the number of elements * specified by the minimum capacity argument. * * @param minCapacity the desired minimum capacity. */ public void ensureCapacity(int minCapacity) { modCount++; int oldCapacity = m_documents.length; if (minCapacity > oldCapacity) { CmsDocument[] oldData = m_documents; int newCapacity = (oldCapacity * 3) / 2 + 1; if (newCapacity < minCapacity) { newCapacity = minCapacity; } m_documents = new CmsDocument[newCapacity]; System.arraycopy(oldData, 0, m_documents, 0, m_size); } } /** * @see java.util.AbstractList#get(int) */ public Object get(int index) { rangeCheck(index); return m_documents[index]; } /** * @see java.util.List#indexOf(java.lang.Object) */ public int indexOf(Object elem) { if (elem == null) { for (int i = 0; i < m_size; i++) { if (m_documents[i] == null) { return i; } } } else { for (int i = 0; i < m_size; i++) { if (elem.equals(m_documents[i])) { return i; } } } return -1; } /** * @see java.util.AbstractList#remove(int) */ public Object remove(int index) { rangeCheck(index); modCount++; CmsDocument oldValue = m_documents[index]; int numMoved = m_size - index - 1; if (numMoved > 0) { System.arraycopy(m_documents, index + 1, m_documents, index, numMoved); } m_documents[--m_size] = null; return oldValue; } /** * @see java.util.AbstractList#set(int, java.lang.Object) */ public Object set(int index, Object element) { rangeCheck(index); CmsDocument newValue = (CmsDocument) element; CmsDocument oldValue = m_documents[index]; m_documents[index] = newValue; return oldValue; } /** * @see java.util.AbstractCollection#size() */ public int size() { return m_size; } /** * Checks if the document is added as a subdocument or attachment.<p> * * If the document was not merged, it is a new document that has to be added to the list depending on the only versions flag.<p> * * @param doc the document to check * @return true if the document was added as subdocument, attachment or if the document should not be added, otherwise false */ private boolean checkContainer(CmsDocument doc) { boolean docnameWithoutPostfixEquality; for (int i = 0; i < m_size; i++) { docnameWithoutPostfixEquality = doc.getDocumentNameFullWithoutPostfix() .equals(m_documents[i].getDocumentNameFullWithoutPostfix()); if (m_documents[i].isVersionOf(doc) || (m_useTypes && docnameWithoutPostfixEquality)) { if (m_useTypes) { if ((m_defaultType != null) && (m_defaultType.equals(doc.getPostfix()))) { if (m_documents[i].getTypes().size() > 0) { doc.setTypes(m_documents[i].getTypes()); } doc.addType(m_documents[i]); m_documents[i] = doc; } else { m_documents[i].addType(doc); } return true; } else if ((m_useAttachments) && (doc.isAttachment()) && (!m_documents[i].isAttachment())) { // store attachment in temporary list to assign later m_attachments.add(doc); return true; } else if ((m_useAttachments) && (m_documents[i].isAttachment()) && (!doc.isAttachment())) { if (isOnlyVersions()) { return true; } else { m_attachments.add(m_documents[i]); m_documents[i] = doc; return true; } } else if (m_useLanguages) { // merge the document if languages are used m_documents[i] = m_documents[i].mergeDocuments(doc); return true; } } else if (isOnlyVersions()) { // this is no version of a present document, do not add it at all return true; } } return false; } /** * Converts an object to a document.<p> * * @param element the object to convert * @return the document object representation */ private CmsDocument convertDocument(Object element) { try { return (CmsDocument) element; } catch (Exception e) { if (LOG.isErrorEnabled()) { LOG.error("Tried adding wrong object to document list " + e); } } return CmsDocument.getNullDocument(); } /** * Returns the flag if only versions of a specific document should be added to the list.<p> * * @return the flag if only versions of a specific document should be added to the list */ private boolean isOnlyVersions() { return m_onlyVersions; } /** * Check if the given index is in range. If not, throw an appropriate * runtime exception. This method does *not* check if the index is * negative: It is always used immediately prior to an array access, * which throws an ArrayIndexOutOfBoundsException if index is negative. * * @param index the index to check */ private void rangeCheck(int index) { if ((index > m_size) || (index < 0)) { throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + m_size); } } }