Coverage report

  %line %branch
org.apache.jetspeed.om.page.impl.PageMenuDefinitionList
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.page.impl;
 18   
 
 19   
 import java.util.AbstractList;
 20   
 import java.util.List;
 21   
 
 22   
 import org.apache.jetspeed.page.impl.DatabasePageManagerUtils;
 23   
 
 24   
 
 25   
 /**
 26   
  * PageMenuDefinitionList
 27   
  *
 28   
  * @author <a href="mailto:rwatler@apache.org">Randy Watler</a>
 29   
  * @version $Id$
 30   
  */
 31   
 class PageMenuDefinitionList extends AbstractList
 32   
 {
 33   
     private PageImpl page;
 34   
 
 35   
     private List removedMenuDefinitions;
 36   
 
 37   
     PageMenuDefinitionList(PageImpl page)
 38   
     {
 39  0 
         super();
 40  0 
         this.page = page;
 41  0 
     }
 42   
 
 43   
     /**
 44   
      * validateDefinitionForAdd
 45   
      *
 46   
      * Validates menu definition to be added to this list.
 47   
      *
 48   
      * @param definition menu definition to add
 49   
      * @return list element to add
 50   
      */
 51   
     private PageMenuDefinitionImpl validateDefinitionForAdd(PageMenuDefinitionImpl definition)
 52   
     {
 53   
         // only non-null definitions supported
 54  0 
         if (definition == null)
 55   
         {
 56  0 
             throw new NullPointerException("Unable to add null to list.");
 57   
         }
 58   
         // make sure element is unique
 59  0 
         if (page.accessMenus().contains(definition))
 60   
         {
 61  0 
             throw new IllegalArgumentException("Unable to add duplicate entry to list: " + (definition).getName());
 62   
         }
 63   
         // retrieve from removed list to reuse
 64   
         // previously removed element copying
 65   
         // menu definition data
 66  0 
         if (removedMenuDefinitions != null)
 67   
         {
 68  0 
             int removedIndex = removedMenuDefinitions.indexOf(definition);
 69  0 
             if (removedIndex >= 0)
 70   
             {
 71   
                 // reuse menu definition with matching name
 72  0 
                 PageMenuDefinitionImpl addDefinition = definition;
 73  0 
                 definition = (PageMenuDefinitionImpl)removedMenuDefinitions.remove(removedIndex);
 74   
                 // TODO: move this logic to copy methods on implementations
 75   
                 // copy menu definition members
 76  0 
                 definition.setOptions(addDefinition.getOptions());
 77  0 
                 definition.setDepth(addDefinition.getDepth());
 78  0 
                 definition.setPaths(addDefinition.isPaths());
 79  0 
                 definition.setRegexp(addDefinition.isRegexp());
 80  0 
                 definition.setProfile(addDefinition.getProfile());
 81  0 
                 definition.setOrder(addDefinition.getOrder());
 82  0 
                 definition.setSkin(addDefinition.getSkin());
 83  0 
                 definition.setTitle(addDefinition.getTitle());
 84  0 
                 definition.setShortTitle(addDefinition.getShortTitle());
 85  0 
                 definition.setMenuElements(addDefinition.getMenuElements());
 86   
                 // copy menu definition metadata members
 87   
                 // TODO: strengthen... this code is not robust
 88   
                 // and may fail if multiple edits without a db
 89   
                 // update occur and duplicate metadata members
 90   
                 // are removed in one operation and reinserted
 91   
                 // in a subsequent operation because the
 92   
                 // metadata members are required to be unique
 93   
                 // and a removal list is not maintained for the
 94   
                 // metadata fields collections yet
 95  0 
                 definition.getMetadata().copyFields(addDefinition.getMetadata().getFields());
 96   
             }
 97   
         }
 98  0 
         return definition;
 99   
     }
 100   
 
 101   
     /**
 102   
      * getRemovedMenuDefinitions
 103   
      *
 104   
      * @return removed menu definitions tracking collection
 105   
      */
 106   
     private List getRemovedMenuDefinitions()
 107   
     {
 108  0 
         if (removedMenuDefinitions == null)
 109   
         {
 110  0 
             removedMenuDefinitions = DatabasePageManagerUtils.createList();
 111   
         }
 112  0 
         return removedMenuDefinitions;
 113   
     }
 114   
 
 115   
     /* (non-Javadoc)
 116   
      * @see java.util.List#add(int,java.lang.Object)
 117   
      */
 118   
     public void add(int index, Object element)
 119   
     {
 120   
         // implement for modifiable AbstractList:
 121   
         // validate index
 122  0 
         if ((index < 0) || (index > page.accessMenus().size()))
 123   
         {
 124  0 
             throw new IndexOutOfBoundsException("Unable to add to list at index: " + index);
 125   
         }
 126   
         // verify menu definition
 127  0 
         PageMenuDefinitionImpl definition = validateDefinitionForAdd((PageMenuDefinitionImpl)element);
 128   
         // add to underlying ordered list
 129  0 
         page.accessMenus().add(index, definition);
 130  0 
     }
 131   
 
 132   
     /* (non-Javadoc)
 133   
      * @see java.util.List#get(int)
 134   
      */
 135   
     public Object get(int index)
 136   
     {
 137   
         // implement for modifiable AbstractList
 138  0 
         return page.accessMenus().get(index);
 139   
     }
 140   
 
 141   
     /* (non-Javadoc)
 142   
      * @see java.util.List#remove(int)
 143   
      */
 144   
     public Object remove(int index)
 145   
     {
 146   
         // implement for modifiable AbstractList:
 147   
         // save removed element
 148  0 
         PageMenuDefinitionImpl removed = (PageMenuDefinitionImpl)page.accessMenus().remove(index);
 149  0 
         if (removed != null)
 150   
         {
 151  0 
             getRemovedMenuDefinitions().add(removed);
 152   
         }
 153  0 
         return removed;
 154   
     }
 155   
 
 156   
     /* (non-Javadoc)
 157   
      * @see java.util.List#set(int,java.lang.Object)
 158   
      */
 159   
     public Object set(int index, Object element)
 160   
     {
 161   
         // implement for modifiable AbstractList:
 162   
         // verify menu definition
 163  0 
         PageMenuDefinitionImpl newDefinition = validateDefinitionForAdd((PageMenuDefinitionImpl)element);
 164   
         // set in underlying ordered list
 165  0 
         PageMenuDefinitionImpl definition = (PageMenuDefinitionImpl)page.accessMenus().set(index, newDefinition);
 166   
         // save replaced element
 167  0 
         getRemovedMenuDefinitions().add(definition);
 168   
         // return menu definition
 169  0 
         return definition;
 170   
     }
 171   
 
 172   
     /* (non-Javadoc)
 173   
      * @see java.util.List#size()
 174   
      */
 175   
     public int size()
 176   
     {
 177   
         // implement for modifiable AbstractList
 178  0 
         return page.accessMenus().size();
 179   
     }
 180   
 }

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