Coverage report

  %line %branch
org.apache.jetspeed.om.folder.impl.FolderOrderList
0% 
0% 

 1   
 /*
 2   
  * Licensed to the Apache Software Foundation (ASF) under one or more
 3   
  * contributor license agreements.  See the NOTICE file distributed with
 4   
  * this work for additional information regarding copyright ownership.
 5   
  * The ASF licenses this file to You under the Apache License, Version 2.0
 6   
  * (the "License"); you may not use this file except in compliance with
 7   
  * the License.  You may obtain a copy of the License at
 8   
  *
 9   
  *      http://www.apache.org/licenses/LICENSE-2.0
 10   
  *
 11   
  * Unless required by applicable law or agreed to in writing, software
 12   
  * distributed under the License is distributed on an "AS IS" BASIS,
 13   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14   
  * See the License for the specific language governing permissions and
 15   
  * limitations under the License.
 16   
  */
 17   
 package org.apache.jetspeed.om.folder.impl;
 18   
 
 19   
 import java.util.AbstractList;
 20   
 import java.util.List;
 21   
 
 22   
 import org.apache.jetspeed.page.impl.DatabasePageManagerUtils;
 23   
 
 24   
 /**
 25   
  * FolderOrderList
 26   
  *
 27   
  * @author <a href="mailto:rwatler@apache.org">Randy Watler</a>
 28   
  * @version $Id$
 29   
  */
 30   
 class FolderOrderList extends AbstractList
 31   
 {
 32   
     private FolderImpl folder;
 33   
 
 34   
     private List removedFolderOrders;
 35   
 
 36   
     FolderOrderList(FolderImpl folder)
 37   
     {
 38  0 
         super();
 39  0 
         this.folder = folder;
 40  0 
     }
 41   
 
 42   
     /**
 43   
      * wrapNameStringForAdd
 44   
      *
 45   
      * Wraps and validates folder order name string
 46   
      * to be added to this list.
 47   
      *
 48   
      * @param name folder order name string to add
 49   
      * @return list element to add
 50   
      */
 51   
     private FolderOrder wrapNameStringForAdd(String name)
 52   
     {
 53   
         // only non-null names supported
 54  0 
         if (name == null)
 55   
         {
 56  0 
             throw new NullPointerException("Unable to add null to list.");
 57   
         }
 58   
         // wrap folder order name string
 59  0 
         FolderOrder folderOrder = new FolderOrder();
 60  0 
         folderOrder.setName(name);
 61   
         // make sure element is unique
 62  0 
         if (folder.accessFolderOrders().contains(folderOrder))
 63   
         {
 64  0 
             throw new IllegalArgumentException("Unable to add duplicate entry to list: " + folderOrder.getName());
 65   
         }
 66   
         // retrieve from removed list to reuse
 67   
         // previously removed element
 68  0 
         if (removedFolderOrders != null)
 69   
         {
 70  0 
             int removedIndex = removedFolderOrders.indexOf(folderOrder);
 71  0 
             if (removedIndex >= 0)
 72   
             {
 73  0 
                 folderOrder = (FolderOrder)removedFolderOrders.remove(removedIndex);
 74   
             }
 75   
         }
 76  0 
         return folderOrder;
 77   
     }
 78   
 
 79   
     /**
 80   
      * getRemovedFolderOrders
 81   
      *
 82   
      * @return removed folder orders tracking collection
 83   
      */
 84   
     private List getRemovedFolderOrders()
 85   
     {
 86  0 
         if (removedFolderOrders == null)
 87   
         {
 88  0 
             removedFolderOrders = DatabasePageManagerUtils.createList();
 89   
         }
 90  0 
         return removedFolderOrders;
 91   
     }
 92   
 
 93   
     /* (non-Javadoc)
 94   
      * @see java.util.List#add(int,java.lang.Object)
 95   
      */
 96   
     public void add(int index, Object element)
 97   
     {
 98   
         // implement for modifiable AbstractList:
 99   
         // validate index
 100  0 
         if ((index < 0) || (index > folder.accessFolderOrders().size()))
 101   
         {
 102  0 
             throw new IndexOutOfBoundsException("Unable to add to list at index: " + index);
 103   
         }
 104   
         // wrap and verify folder order name string
 105  0 
         FolderOrder folderOrder = wrapNameStringForAdd((String)element);
 106   
         // add to underlying ordered list
 107  0 
         folder.accessFolderOrders().add(index, folderOrder);
 108   
         // set sort order in added element
 109  0 
         if (index > 0)
 110   
         {
 111  0 
             folderOrder.setSortOrder(((FolderOrder)folder.accessFolderOrders().get(index-1)).getSortOrder() + 1);
 112   
         }
 113   
         else
 114   
         {
 115  0 
             folderOrder.setSortOrder(0);
 116   
         }
 117   
         // maintain sort order in subsequent elements
 118  0 
         for (int i = index, limit = folder.accessFolderOrders().size() - 1; (i < limit); i++)
 119   
         {
 120  0 
             FolderOrder nextFolderOrder = (FolderOrder)folder.accessFolderOrders().get(i + 1);
 121  0 
             if (nextFolderOrder.getSortOrder() <= folderOrder.getSortOrder())
 122   
             {
 123   
                 // adjust sort order for next element
 124  0 
                 nextFolderOrder.setSortOrder(folderOrder.getSortOrder() + 1);
 125  0 
                 folderOrder = nextFolderOrder;
 126   
             }
 127   
             else
 128   
             {
 129   
                 // sort order maintained for remaining list elements
 130   
                 break;
 131   
             }
 132   
         }
 133   
         // clear all cached folder ordering
 134  0 
         folder.clearDocumentOrderComparator();
 135  0 
     }
 136   
 
 137   
     /* (non-Javadoc)
 138   
      * @see java.util.List#get(int)
 139   
      */
 140   
     public Object get(int index)
 141   
     {
 142   
         // implement for modifiable AbstractList:
 143   
         // unwrap folder order name string
 144  0 
         return ((FolderOrder)folder.accessFolderOrders().get(index)).getName();
 145   
     }
 146   
 
 147   
     /* (non-Javadoc)
 148   
      * @see java.util.List#remove(int)
 149   
      */
 150   
     public Object remove(int index)
 151   
     {
 152   
         // implement for modifiable AbstractList
 153  0 
         FolderOrder removed = (FolderOrder)folder.accessFolderOrders().remove(index);
 154  0 
         if (removed != null)
 155   
         {
 156   
             // save removed element
 157  0 
             getRemovedFolderOrders().add(removed);
 158   
             // clear all cached folder ordering
 159  0 
             folder.clearDocumentOrderComparator();
 160   
         }
 161  0 
         return removed;
 162   
     }
 163   
 
 164   
     /* (non-Javadoc)
 165   
      * @see java.util.List#set(int,java.lang.Object)
 166   
      */
 167   
     public Object set(int index, Object element)
 168   
     {
 169   
         // implement for modifiable AbstractList:
 170   
         // wrap and verify folder order name string
 171  0 
         FolderOrder newFolderOrder = wrapNameStringForAdd((String)element);
 172   
         // set in underlying ordered list
 173  0 
         FolderOrder folderOrder = (FolderOrder)folder.accessFolderOrders().set(index, newFolderOrder);
 174   
         // set sort order in new element
 175  0 
         newFolderOrder.setSortOrder(folderOrder.getSortOrder());
 176   
         // save replaced element
 177  0 
         getRemovedFolderOrders().add(folderOrder);
 178   
         // clear all cached folder ordering
 179  0 
         folder.clearDocumentOrderComparator();
 180   
         // return unwrapped folder order name string
 181  0 
         return folderOrder.getName();
 182   
     }
 183   
 
 184   
     /* (non-Javadoc)
 185   
      * @see java.util.List#size()
 186   
      */
 187   
     public int size()
 188   
     {
 189   
         // implement for modifiable AbstractList
 190  0 
         return folder.accessFolderOrders().size();
 191   
     }
 192   
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.