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.impl;
18  
19  import java.util.ArrayList;
20  import java.util.Collection;
21  import java.util.Iterator;
22  import java.util.Locale;
23  
24  import org.apache.commons.collections.map.MultiValueMap;
25  import org.apache.jetspeed.om.common.GenericMetadata;
26  import org.apache.jetspeed.om.common.LocalizedField;
27  
28  /***
29   * GenericMetadataImpl
30   * <br/>
31   * Implementation that allows retrieving localized information 
32   * 
33   * @author <a href="mailto:jford@apache.org">Jeremy Ford</a>
34   * @version $Id: GenericMetadataImpl.java 551866 2007-06-29 12:15:40Z ate $
35   *
36   */
37  public abstract class GenericMetadataImpl implements GenericMetadata
38  {   
39      private Collection fields = null;
40      private transient MultiValueMap fieldMap = null;
41      
42      private MultiValueMap getFieldMap(boolean create)
43      {
44          if (fieldMap == null && create)
45          {
46              synchronized(this)
47              {
48                  if (fieldMap == null)
49                  {
50                      fieldMap = new MultiValueMap();
51                  }
52              }
53          }
54          return fieldMap;
55      }
56  
57      
58      /* (non-Javadoc)
59       * @see org.apache.jetspeed.om.common.GenericMetadata#addField(java.util.Locale, java.lang.String, java.lang.String)
60       */
61      public void addField(Locale locale, String name, String value)
62      {
63          LocalizedField field = createLocalizedField();
64          field.setName(name);
65          field.setValue(value);
66          field.setLocale(locale);
67          
68          addField(field);
69      }
70  
71      /* (non-Javadoc)
72       * @see org.apache.jetspeed.om.common.GenericMetadata#addField(org.apache.jetspeed.om.common.LocalizedField)
73       */
74      public void addField(LocalizedField field)
75      {
76          if(fields == null)
77          {
78              fields = new ArrayList();
79          }
80          
81          fields.add(field);
82          getFieldMap(true).put(field.getName(), field);
83      }
84  
85      /* (non-Javadoc)
86       * @see org.apache.jetspeed.om.common.GenericMetadata#getFields(java.lang.String)
87       */
88      public Collection getFields(String name)
89      {
90      	//TODO:  return an immutable version?
91          MultiValueMap fieldMap = getFieldMap(false);
92          return (Collection)(fieldMap !=null ? fieldMap.get(name) : null);
93      }
94  
95      /* (non-Javadoc)
96       * @see org.apache.jetspeed.om.common.GenericMetadata#setFields(java.lang.String, java.util.Collection)
97       */
98      public void setFields(String name, Collection values)
99      {
100         MultiValueMap fieldMap = getFieldMap(false);
101         if (fieldMap != null)
102         {
103             fieldMap.remove(name);
104         }
105         
106         Iterator fieldIter = fields.iterator();
107         while(fieldIter.hasNext())
108         {
109             LocalizedField field = (LocalizedField)fieldIter.next();
110             if(field != null && field.getName() != null && field.getName().equals(name))
111             {
112                 fieldIter.remove();
113             }
114         }
115         
116         if(values != null)
117         {    
118             Iterator iter = values.iterator();
119             while(iter.hasNext())
120             {
121                 LocalizedField field = (LocalizedField)iter.next();
122                 getFieldMap(true).put(field.getName(), field);
123             }
124             
125             fields.addAll(values);
126         }
127     }
128     
129     /* (non-Javadoc)
130      * @see org.apache.jetspeed.om.common.GenericMetadata#getFields()
131      */
132     public Collection getFields() {
133         return fields;
134     }
135 
136     /* (non-Javadoc)
137      * @see org.apache.jetspeed.om.common.GenericMetadata#setFields(java.util.Collection)
138      */
139     public void setFields(Collection fields)
140     {
141         this.fields = fields;
142 
143         MultiValueMap fieldMap = getFieldMap(false);
144         if (fieldMap != null)
145         {
146             fieldMap.clear();
147         }
148         
149         if(fields != null)
150         {    
151             Iterator fieldIter = fields.iterator();
152             while(fieldIter.hasNext())
153             {
154                 LocalizedField field = (LocalizedField)fieldIter.next();
155                 if (field.getName() != null)
156                 {
157                     getFieldMap(true).put(field.getName(), field);
158                 }
159             }
160         }
161         
162     }
163 
164     /* (non-Javadoc)
165      * @see org.apache.jetspeed.om.common.GenericMetadata#copyFields(java.util.Collection)
166      */
167     public void copyFields(Collection fields)
168     {
169         // preserve matching fields during copy to
170         // minimize persistent store thrash and
171         // field uniqueness constraint violations
172         // that may occur if identical field is
173         // removed and reinserted
174         if ((this.fields != null) && !this.fields.isEmpty())
175         {
176             // remove unique existing fields
177             if (fields != null)
178             {
179                 this.fields.retainAll(fields);
180             }
181             else
182             {
183                 this.fields = null;
184             }
185         }
186         if ((fields != null) && !fields.isEmpty())
187         {
188             // create new fields collection if necessary
189             if (this.fields == null)
190             {
191                 this.fields = new ArrayList();
192             }
193             // copy unique new metadata members
194             Iterator fieldIter = fields.iterator();
195             while (fieldIter.hasNext())
196             {
197                 LocalizedField field = (LocalizedField)fieldIter.next();
198                 if (!this.fields.contains(field))
199                 {
200                     addField(field.getLocale(), field.getName(), field.getValue());
201                 }
202             }
203         }
204         
205         // update field map
206         MultiValueMap fieldMap = getFieldMap(false);
207         if (fieldMap != null)
208         {
209             fieldMap.clear();
210         }
211         
212         if (this.fields != null)
213         {    
214             Iterator fieldIter = this.fields.iterator();
215             while (fieldIter.hasNext())
216             {
217                 LocalizedField field = (LocalizedField)fieldIter.next();
218                 getFieldMap(true).put(field.getName(), field);
219             }
220         }
221     }
222 }