View Javadoc

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          super();
40          this.page = page;
41      }
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          if (definition == null)
55          {
56              throw new NullPointerException("Unable to add null to list.");
57          }
58          // make sure element is unique
59          if (page.accessMenus().contains(definition))
60          {
61              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          if (removedMenuDefinitions != null)
67          {
68              int removedIndex = removedMenuDefinitions.indexOf(definition);
69              if (removedIndex >= 0)
70              {
71                  // reuse menu definition with matching name
72                  PageMenuDefinitionImpl addDefinition = definition;
73                  definition = (PageMenuDefinitionImpl)removedMenuDefinitions.remove(removedIndex);
74                  // TODO: move this logic to copy methods on implementations
75                  // copy menu definition members
76                  definition.setOptions(addDefinition.getOptions());
77                  definition.setDepth(addDefinition.getDepth());
78                  definition.setPaths(addDefinition.isPaths());
79                  definition.setRegexp(addDefinition.isRegexp());
80                  definition.setProfile(addDefinition.getProfile());
81                  definition.setOrder(addDefinition.getOrder());
82                  definition.setSkin(addDefinition.getSkin());
83                  definition.setTitle(addDefinition.getTitle());
84                  definition.setShortTitle(addDefinition.getShortTitle());
85                  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                  definition.getMetadata().copyFields(addDefinition.getMetadata().getFields());
96              }
97          }
98          return definition;
99      }
100 
101     /***
102      * getRemovedMenuDefinitions
103      *
104      * @return removed menu definitions tracking collection
105      */
106     private List getRemovedMenuDefinitions()
107     {
108         if (removedMenuDefinitions == null)
109         {
110             removedMenuDefinitions = DatabasePageManagerUtils.createList();
111         }
112         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         if ((index < 0) || (index > page.accessMenus().size()))
123         {
124             throw new IndexOutOfBoundsException("Unable to add to list at index: " + index);
125         }
126         // verify menu definition
127         PageMenuDefinitionImpl definition = validateDefinitionForAdd((PageMenuDefinitionImpl)element);
128         // add to underlying ordered list
129         page.accessMenus().add(index, definition);
130     }
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         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         PageMenuDefinitionImpl removed = (PageMenuDefinitionImpl)page.accessMenus().remove(index);
149         if (removed != null)
150         {
151             getRemovedMenuDefinitions().add(removed);
152         }
153         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         PageMenuDefinitionImpl newDefinition = validateDefinitionForAdd((PageMenuDefinitionImpl)element);
164         // set in underlying ordered list
165         PageMenuDefinitionImpl definition = (PageMenuDefinitionImpl)page.accessMenus().set(index, newDefinition);
166         // save replaced element
167         getRemovedMenuDefinitions().add(definition);
168         // return menu definition
169         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         return page.accessMenus().size();
179     }
180 }