001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: package org.apache.jetspeed.om.folder.impl;
018:
019: import java.util.AbstractList;
020: import java.util.List;
021:
022: import org.apache.jetspeed.page.impl.DatabasePageManagerUtils;
023:
024: /**
025: * FolderOrderList
026: *
027: * @author <a href="mailto:rwatler@apache.org">Randy Watler</a>
028: * @version $Id$
029: */
030: class FolderOrderList extends AbstractList {
031: private FolderImpl folder;
032:
033: private List removedFolderOrders;
034:
035: FolderOrderList(FolderImpl folder) {
036: super ();
037: this .folder = folder;
038: }
039:
040: /**
041: * wrapNameStringForAdd
042: *
043: * Wraps and validates folder order name string
044: * to be added to this list.
045: *
046: * @param name folder order name string to add
047: * @return list element to add
048: */
049: private FolderOrder wrapNameStringForAdd(String name) {
050: // only non-null names supported
051: if (name == null) {
052: throw new NullPointerException(
053: "Unable to add null to list.");
054: }
055: // wrap folder order name string
056: FolderOrder folderOrder = new FolderOrder();
057: folderOrder.setName(name);
058: // make sure element is unique
059: if (folder.accessFolderOrders().contains(folderOrder)) {
060: throw new IllegalArgumentException(
061: "Unable to add duplicate entry to list: "
062: + folderOrder.getName());
063: }
064: // retrieve from removed list to reuse
065: // previously removed element
066: if (removedFolderOrders != null) {
067: int removedIndex = removedFolderOrders.indexOf(folderOrder);
068: if (removedIndex >= 0) {
069: folderOrder = (FolderOrder) removedFolderOrders
070: .remove(removedIndex);
071: }
072: }
073: return folderOrder;
074: }
075:
076: /**
077: * getRemovedFolderOrders
078: *
079: * @return removed folder orders tracking collection
080: */
081: private List getRemovedFolderOrders() {
082: if (removedFolderOrders == null) {
083: removedFolderOrders = DatabasePageManagerUtils.createList();
084: }
085: return removedFolderOrders;
086: }
087:
088: /* (non-Javadoc)
089: * @see java.util.List#add(int,java.lang.Object)
090: */
091: public void add(int index, Object element) {
092: // implement for modifiable AbstractList:
093: // validate index
094: if ((index < 0) || (index > folder.accessFolderOrders().size())) {
095: throw new IndexOutOfBoundsException(
096: "Unable to add to list at index: " + index);
097: }
098: // wrap and verify folder order name string
099: FolderOrder folderOrder = wrapNameStringForAdd((String) element);
100: // add to underlying ordered list
101: folder.accessFolderOrders().add(index, folderOrder);
102: // set sort order in added element
103: if (index > 0) {
104: folderOrder.setSortOrder(((FolderOrder) folder
105: .accessFolderOrders().get(index - 1))
106: .getSortOrder() + 1);
107: } else {
108: folderOrder.setSortOrder(0);
109: }
110: // maintain sort order in subsequent elements
111: for (int i = index, limit = folder.accessFolderOrders().size() - 1; (i < limit); i++) {
112: FolderOrder nextFolderOrder = (FolderOrder) folder
113: .accessFolderOrders().get(i + 1);
114: if (nextFolderOrder.getSortOrder() <= folderOrder
115: .getSortOrder()) {
116: // adjust sort order for next element
117: nextFolderOrder
118: .setSortOrder(folderOrder.getSortOrder() + 1);
119: folderOrder = nextFolderOrder;
120: } else {
121: // sort order maintained for remaining list elements
122: break;
123: }
124: }
125: // clear all cached folder ordering
126: folder.clearDocumentOrderComparator();
127: }
128:
129: /* (non-Javadoc)
130: * @see java.util.List#get(int)
131: */
132: public Object get(int index) {
133: // implement for modifiable AbstractList:
134: // unwrap folder order name string
135: return ((FolderOrder) folder.accessFolderOrders().get(index))
136: .getName();
137: }
138:
139: /* (non-Javadoc)
140: * @see java.util.List#remove(int)
141: */
142: public Object remove(int index) {
143: // implement for modifiable AbstractList
144: FolderOrder removed = (FolderOrder) folder.accessFolderOrders()
145: .remove(index);
146: if (removed != null) {
147: // save removed element
148: getRemovedFolderOrders().add(removed);
149: // clear all cached folder ordering
150: folder.clearDocumentOrderComparator();
151: }
152: return removed;
153: }
154:
155: /* (non-Javadoc)
156: * @see java.util.List#set(int,java.lang.Object)
157: */
158: public Object set(int index, Object element) {
159: // implement for modifiable AbstractList:
160: // wrap and verify folder order name string
161: FolderOrder newFolderOrder = wrapNameStringForAdd((String) element);
162: // set in underlying ordered list
163: FolderOrder folderOrder = (FolderOrder) folder
164: .accessFolderOrders().set(index, newFolderOrder);
165: // set sort order in new element
166: newFolderOrder.setSortOrder(folderOrder.getSortOrder());
167: // save replaced element
168: getRemovedFolderOrders().add(folderOrder);
169: // clear all cached folder ordering
170: folder.clearDocumentOrderComparator();
171: // return unwrapped folder order name string
172: return folderOrder.getName();
173: }
174:
175: /* (non-Javadoc)
176: * @see java.util.List#size()
177: */
178: public int size() {
179: // implement for modifiable AbstractList
180: return folder.accessFolderOrders().size();
181: }
182: }
|