Coverage Report

Coverage Report - org.kuali.rice.kns.datadictionary.MaintainableCollectionDefinition

Classes in this File

0/98

0/36

 /*
  * Copyright 2005-2007 The Kuali Foundation
  * 
  * Licensed under the Educational Community License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * 
  * http://www.opensource.org/licenses/ecl2.php
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.kuali.rice.kns.datadictionary;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import org.apache.commons.lang.StringUtils;
 import org.kuali.rice.kns.bo.BusinessObject;
 import org.kuali.rice.kns.datadictionary.exception.AttributeValidationException;
 import org.kuali.rice.kns.datadictionary.exception.DuplicateEntryException;
 
 /**
     The maintainableCollection element defines a set of data fields, nested
     collections, summaryFields and duplicateIdentificationsFields.
 
     JSTL: maintainableCollection is a Map which is accessed using a
     key of the name of the maintainableCollection.  Each entry
     contains the following keys and values:
         **Key**                **Value**
         collection             true
         name                   name of collection
         businessObjectClass    name of collection class
         
 * name is the name of the collection
 * businessObjectClass is the class name of the objects in the collection
 * sourceClassName is the class name of the BO used in a lookup
 * sourceAttributeName is the name of the attribute which returns the collection
 * includeAddLine is true if the user is given the ability to add multiple lines.
 * includeMultipleLookupLine whether to render a quickfinder icon for multiple value lookups on the collection.  Defaults to true
 * summaryTitle is the label of the summary
 * attributeToHighlightOnDuplicateKey is the name of an attribute to highlight
     if two records in the collection are the same based on the
     duplicateIdentificationFields element.
 
  *
  */
 public class MaintainableCollectionDefinition extends MaintainableItemDefinition implements CollectionDefinitionI{
     private static final long serialVersionUID = -5617868782623587053L;
 
         // logger
     //private static Log LOG = LogFactory.getLog(MaintainableCollectionDefinition.class);
 
         protected Class<? extends BusinessObject> businessObjectClass;
 
     protected Class<? extends BusinessObject> sourceClassName;
     protected String summaryTitle;
     protected String attributeToHighlightOnDuplicateKey;
 
     protected boolean includeAddLine = true;
     protected boolean includeMultipleLookupLine = true;
     private boolean alwaysAllowCollectionDeletion = false;
 
     protected Map<String,MaintainableFieldDefinition> maintainableFieldMap = new HashMap<String, MaintainableFieldDefinition>();
     protected Map<String,MaintainableCollectionDefinition> maintainableCollectionMap = new HashMap<String, MaintainableCollectionDefinition>();
     protected Map<String,MaintainableFieldDefinition> summaryFieldMap = new HashMap<String, MaintainableFieldDefinition>();
     protected Map<String,MaintainableFieldDefinition> duplicateIdentificationFieldMap = new HashMap<String, MaintainableFieldDefinition>();
     protected List<MaintainableFieldDefinition> maintainableFields = new ArrayList<MaintainableFieldDefinition>();
     protected List<MaintainableCollectionDefinition> maintainableCollections = new ArrayList<MaintainableCollectionDefinition>();
     protected List<MaintainableFieldDefinition> summaryFields = new ArrayList<MaintainableFieldDefinition>();
     protected List<MaintainableFieldDefinition> duplicateIdentificationFields = new ArrayList<MaintainableFieldDefinition>();
 
     public MaintainableCollectionDefinition() {}
 
 
 
     /**
      * @return businessObjectClass
      */
     public Class<? extends BusinessObject> getBusinessObjectClass() {
         return businessObjectClass;
     }
 
     /**
      * The BusinessObject class used for each row of this collection.
      */
     public void setBusinessObjectClass(Class<? extends BusinessObject> businessObjectClass) {
         if (businessObjectClass == null) {
             throw new IllegalArgumentException("invalid (null) businessObjectClass");
         }
 
         this.businessObjectClass = businessObjectClass;
     }
 
     /**
      * @return Collection of all lookupField MaintainableFieldDefinitions associated with this MaintainableCollectionDefinition, in
      *         the order in which they were added
      */
     public List<MaintainableFieldDefinition> getMaintainableFields() {
         return maintainableFields;
     }
 
     public List<? extends FieldDefinitionI> getFields() {
         return maintainableFields;
     }
 
     /**
      * Directly validate simple fields, call completeValidation on Definition fields.
      * 
      * @see org.kuali.rice.kns.datadictionary.DataDictionaryDefinition#completeValidation(java.lang.Class, java.lang.Object)
      */
     public void completeValidation(Class rootBusinessObjectClass, Class otherBusinessObjectClass) {
         if (!DataDictionary.isCollectionPropertyOf(rootBusinessObjectClass, getName())) {
             throw new AttributeValidationException("unable to find collection named '" + getName() + "' in rootBusinessObjectClass '" + rootBusinessObjectClass.getName() + "' (" + "" + ")");
         }
 
         if (dissallowDuplicateKey()) {
             if (!DataDictionary.isPropertyOf(businessObjectClass, attributeToHighlightOnDuplicateKey)) {
                 throw new AttributeValidationException("unable to find attribute named '" + attributeToHighlightOnDuplicateKey + "'in businessObjectClass '" + businessObjectClass.getName() + "' of collection '" + getName() + "' in rootBusinessObjectClass '" + rootBusinessObjectClass.getName() + "' (" + "" + ")");
             }
         }
         
         for (MaintainableFieldDefinition maintainableField : maintainableFields ) {
             maintainableField.completeValidation(businessObjectClass, null);
         }
 
         for (MaintainableCollectionDefinition maintainableCollection : maintainableCollections ) {
             maintainableCollection.completeValidation(businessObjectClass, null);
         }
 
 //        for (MaintainableFieldDefinition summaryField : summaryFields ) {
 //            summaryField.completeValidation(businessObjectClass, null, validationCompletionUtils);
 //        }
 //        
 //        for (MaintainableFieldDefinition identifierField : duplicateIdentificationFields) {
 //            identifierField.completeValidation(businessObjectClass, null, validationCompletionUtils);
 //        }
     }
 
 
     /**
      * @see java.lang.Object#toString()
      */
     public String toString() {
         return "MaintainableCollectionDefinition for " + getName();
     }
 
 
     public Class<? extends BusinessObject> getSourceClassName() {
         return sourceClassName;
     }
 
 
     /** BusinessObject class which should be used for multiple value lookups for this collection.
      */
     public void setSourceClassName(Class<? extends BusinessObject> sourceClass) {
         this.sourceClassName = sourceClass;
     }
 
     public boolean getIncludeAddLine() {
         return includeAddLine;
     }
 
 
     /** Control whether an "add" line should be included at the top of this collection. */
     public void setIncludeAddLine(boolean includeAddLine) {
         this.includeAddLine = includeAddLine;
     }
 
     /**
      * @return Collection of all lookupField MaintainableCollectionDefinitions associated with this
      *         MaintainableCollectionDefinition, in the order in which they were added
      */
     public List<MaintainableCollectionDefinition> getMaintainableCollections() {
         return maintainableCollections;
     }
 
     public List<? extends CollectionDefinitionI> getCollections() {
         return maintainableCollections;
     }
 
     
     /**
      * @return Collection of all SummaryFieldDefinitions associated with this SummaryFieldDefinition, in the order in which they
      *         were added
      */
     public List<? extends FieldDefinitionI> getSummaryFields() {
         return summaryFields;
     }
 
     public boolean hasSummaryField(String key) {
         return summaryFieldMap.containsKey(key);
     }
 
     public boolean isIncludeMultipleLookupLine() {
         return includeMultipleLookupLine;
     }
 
     /** Set whether the multiple lookup line (and link) should appear above this collection. */
     public void setIncludeMultipleLookupLine(boolean includeMultipleLookupLine) {
         this.includeMultipleLookupLine = includeMultipleLookupLine;
     }
 
     public String getSummaryTitle() {
         return summaryTitle;
     }
 
     /**
 summaryTitle is the label of the summary
      */
     public void setSummaryTitle(String overrideSummaryName) {
         this.summaryTitle = overrideSummaryName;
     }
 
 
     public String getAttributeToHighlightOnDuplicateKey() {
         return attributeToHighlightOnDuplicateKey;
     }
 
     /**
  attributeToHighlightOnDuplicateKey is the name of an attribute to highlight
                             if two records in the collection are the same based on the
                             duplicateIdentificationFields element.
     */
     public void setAttributeToHighlightOnDuplicateKey(String attributeToHighlightOnDuplicate) {
         this.attributeToHighlightOnDuplicateKey = attributeToHighlightOnDuplicate;
     }
 
     public boolean dissallowDuplicateKey() {
         return StringUtils.isNotBlank(getAttributeToHighlightOnDuplicateKey());
     }
 
     public List<MaintainableFieldDefinition> getDuplicateIdentificationFields() {
         return duplicateIdentificationFields;
     }
 
     /** The list of fields to include in this collection. */
     public void setMaintainableFields(List<MaintainableFieldDefinition> maintainableFields) {
         maintainableFieldMap.clear();
         for ( MaintainableFieldDefinition maintainableField : maintainableFields ) {
             if (maintainableField == null) {
                 throw new IllegalArgumentException("invalid (null) maintainableField");
             }
 
             String fieldName = maintainableField.getName();
             if (maintainableFieldMap.containsKey(fieldName)) {
                 throw new DuplicateEntryException("duplicate fieldName entry for field '" + fieldName + "'");
             }
 
             maintainableFieldMap.put(fieldName, maintainableField);
         }
         this.maintainableFields = maintainableFields;
     }
 
     /** The list of sub-collections to include in this collection. */
     public void setMaintainableCollections(List<MaintainableCollectionDefinition> maintainableCollections) {
         maintainableCollectionMap.clear();
         for (MaintainableCollectionDefinition maintainableCollection : maintainableCollections ) {
             if (maintainableCollection == null) {
                 throw new IllegalArgumentException("invalid (null) maintainableCollection");
             }
 
             String fieldName = maintainableCollection.getName();
             if (maintainableCollectionMap.containsKey(fieldName)) {
                 throw new DuplicateEntryException("duplicate fieldName entry for field '" + fieldName + "'");
             }
 
             maintainableCollectionMap.put(fieldName, maintainableCollection);
         }
         this.maintainableCollections = maintainableCollections;
     }
 
     /**
 
                         The summaryFields element defines a set of summaryField
                         elements.
      */
     public void setSummaryFields(List<MaintainableFieldDefinition> summaryFields) {
         summaryFieldMap.clear();
         for (MaintainableFieldDefinition summaryField : summaryFields ) {
             if (summaryField == null) {
                 throw new IllegalArgumentException("invalid (null) summaryField");
             }
 
             String fieldName = summaryField.getName();
             if (summaryFieldMap.containsKey(fieldName)) {
                 throw new DuplicateEntryException("duplicate fieldName entry for field '" + fieldName + "'");
             }
 
             summaryFieldMap.put(fieldName, summaryField);
         }
         this.summaryFields = summaryFields;
     }
 
     /**
     The duplicateIdentificationFields element is used to define a set of
     fields that will be used to determine if two records in the collection
     are duplicates.
     */
     public void setDuplicateIdentificationFields(List<MaintainableFieldDefinition> duplicateIdentificationFields) {
         duplicateIdentificationFieldMap.clear();
         for (MaintainableFieldDefinition identifierField : duplicateIdentificationFields) {
             if (identifierField == null) {
                 throw new IllegalArgumentException("invalid (null) identifierField");
             }
 
             String fieldName = identifierField.getName();
             if (duplicateIdentificationFieldMap.containsKey(fieldName)) {
                 throw new DuplicateEntryException("duplicate fieldName entry for field '" + fieldName + "'");
             }
 
             duplicateIdentificationFieldMap.put(fieldName, identifierField);            
         }
         this.duplicateIdentificationFields = duplicateIdentificationFields;
     }
 
 
 
         public boolean isAlwaysAllowCollectionDeletion() {
                 return this.alwaysAllowCollectionDeletion;
         }
 
 
 
         public void setAlwaysAllowCollectionDeletion(
                         boolean alwaysAllowCollectionDeletion) {
                 this.alwaysAllowCollectionDeletion = alwaysAllowCollectionDeletion;
         }
     
 }

1		/*
2		* Copyright 2005-2007 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.kns.datadictionary;
17
18		import java.util.ArrayList;
19		import java.util.HashMap;
20		import java.util.List;
21		import java.util.Map;
22
23		import org.apache.commons.lang.StringUtils;
24		import org.kuali.rice.kns.bo.BusinessObject;
25		import org.kuali.rice.kns.datadictionary.exception.AttributeValidationException;
26		import org.kuali.rice.kns.datadictionary.exception.DuplicateEntryException;
27
28		/**
29		The maintainableCollection element defines a set of data fields, nested
30		collections, summaryFields and duplicateIdentificationsFields.
31
32		JSTL: maintainableCollection is a Map which is accessed using a
33		key of the name of the maintainableCollection. Each entry
34		contains the following keys and values:
35		Key Value
36		collection true
37		name name of collection
38		businessObjectClass name of collection class
39
40		* name is the name of the collection
41		* businessObjectClass is the class name of the objects in the collection
42		* sourceClassName is the class name of the BO used in a lookup
43		* sourceAttributeName is the name of the attribute which returns the collection
44		* includeAddLine is true if the user is given the ability to add multiple lines.
45		* includeMultipleLookupLine whether to render a quickfinder icon for multiple value lookups on the collection. Defaults to true
46		* summaryTitle is the label of the summary
47		* attributeToHighlightOnDuplicateKey is the name of an attribute to highlight
48		if two records in the collection are the same based on the
49		duplicateIdentificationFields element.
50
51		*
52		*/
53		public class MaintainableCollectionDefinition extends MaintainableItemDefinition implements CollectionDefinitionI{
54		private static final long serialVersionUID = -5617868782623587053L;
55
56		// logger
57		//private static Log LOG = LogFactory.getLog(MaintainableCollectionDefinition.class);
58
59		protected Class<? extends BusinessObject> businessObjectClass;
60
61		protected Class<? extends BusinessObject> sourceClassName;
62		protected String summaryTitle;
63		protected String attributeToHighlightOnDuplicateKey;
64
65	0	protected boolean includeAddLine = true;
66	0	protected boolean includeMultipleLookupLine = true;
67	0	private boolean alwaysAllowCollectionDeletion = false;
68
69	0	protected Map<String,MaintainableFieldDefinition> maintainableFieldMap = new HashMap<String, MaintainableFieldDefinition>();
70	0	protected Map<String,MaintainableCollectionDefinition> maintainableCollectionMap = new HashMap<String, MaintainableCollectionDefinition>();
71	0	protected Map<String,MaintainableFieldDefinition> summaryFieldMap = new HashMap<String, MaintainableFieldDefinition>();
72	0	protected Map<String,MaintainableFieldDefinition> duplicateIdentificationFieldMap = new HashMap<String, MaintainableFieldDefinition>();
73	0	protected List<MaintainableFieldDefinition> maintainableFields = new ArrayList<MaintainableFieldDefinition>();
74	0	protected List<MaintainableCollectionDefinition> maintainableCollections = new ArrayList<MaintainableCollectionDefinition>();
75	0	protected List<MaintainableFieldDefinition> summaryFields = new ArrayList<MaintainableFieldDefinition>();
76	0	protected List<MaintainableFieldDefinition> duplicateIdentificationFields = new ArrayList<MaintainableFieldDefinition>();
77
78	0	public MaintainableCollectionDefinition() {}
79
80
81
82		/**
83		* @return businessObjectClass
84		*/
85		public Class<? extends BusinessObject> getBusinessObjectClass() {
86	0	return businessObjectClass;
87		}
88
89		/**
90		* The BusinessObject class used for each row of this collection.
91		*/
92		public void setBusinessObjectClass(Class<? extends BusinessObject> businessObjectClass) {
93	0	if (businessObjectClass == null) {
94	0	throw new IllegalArgumentException("invalid (null) businessObjectClass");
95		}
96
97	0	this.businessObjectClass = businessObjectClass;
98	0	}
99
100		/**
101		* @return Collection of all lookupField MaintainableFieldDefinitions associated with this MaintainableCollectionDefinition, in
102		* the order in which they were added
103		*/
104		public List<MaintainableFieldDefinition> getMaintainableFields() {
105	0	return maintainableFields;
106		}
107
108		public List<? extends FieldDefinitionI> getFields() {
109	0	return maintainableFields;
110		}
111
112		/**
113		* Directly validate simple fields, call completeValidation on Definition fields.
114		*
115		* @see org.kuali.rice.kns.datadictionary.DataDictionaryDefinition#completeValidation(java.lang.Class, java.lang.Object)
116		*/
117		public void completeValidation(Class rootBusinessObjectClass, Class otherBusinessObjectClass) {
118	0	if (!DataDictionary.isCollectionPropertyOf(rootBusinessObjectClass, getName())) {
119	0	throw new AttributeValidationException("unable to find collection named '" + getName() + "' in rootBusinessObjectClass '" + rootBusinessObjectClass.getName() + "' (" + "" + ")");
120		}
121
122	0	if (dissallowDuplicateKey()) {
123	0	if (!DataDictionary.isPropertyOf(businessObjectClass, attributeToHighlightOnDuplicateKey)) {
124	0	throw new AttributeValidationException("unable to find attribute named '" + attributeToHighlightOnDuplicateKey + "'in businessObjectClass '" + businessObjectClass.getName() + "' of collection '" + getName() + "' in rootBusinessObjectClass '" + rootBusinessObjectClass.getName() + "' (" + "" + ")");
125		}
126		}
127
128	0	for (MaintainableFieldDefinition maintainableField : maintainableFields ) {
129	0	maintainableField.completeValidation(businessObjectClass, null);
130		}
131
132	0	for (MaintainableCollectionDefinition maintainableCollection : maintainableCollections ) {
133	0	maintainableCollection.completeValidation(businessObjectClass, null);
134		}
135
136		// for (MaintainableFieldDefinition summaryField : summaryFields ) {
137		// summaryField.completeValidation(businessObjectClass, null, validationCompletionUtils);
138		// }
139		//
140		// for (MaintainableFieldDefinition identifierField : duplicateIdentificationFields) {
141		// identifierField.completeValidation(businessObjectClass, null, validationCompletionUtils);
142		// }
143	0	}
144
145
146		/**
147		* @see java.lang.Object#toString()
148		*/
149		public String toString() {
150	0	return "MaintainableCollectionDefinition for " + getName();
151		}
152
153
154		public Class<? extends BusinessObject> getSourceClassName() {
155	0	return sourceClassName;
156		}
157
158
159		/** BusinessObject class which should be used for multiple value lookups for this collection.
160		*/
161		public void setSourceClassName(Class<? extends BusinessObject> sourceClass) {
162	0	this.sourceClassName = sourceClass;
163	0	}
164
165		public boolean getIncludeAddLine() {
166	0	return includeAddLine;
167		}
168
169
170		/** Control whether an "add" line should be included at the top of this collection. */
171		public void setIncludeAddLine(boolean includeAddLine) {
172	0	this.includeAddLine = includeAddLine;
173	0	}
174
175		/**
176		* @return Collection of all lookupField MaintainableCollectionDefinitions associated with this
177		* MaintainableCollectionDefinition, in the order in which they were added
178		*/
179		public List<MaintainableCollectionDefinition> getMaintainableCollections() {
180	0	return maintainableCollections;
181		}
182
183		public List<? extends CollectionDefinitionI> getCollections() {
184	0	return maintainableCollections;
185		}
186
187
188		/**
189		* @return Collection of all SummaryFieldDefinitions associated with this SummaryFieldDefinition, in the order in which they
190		* were added
191		*/
192		public List<? extends FieldDefinitionI> getSummaryFields() {
193	0	return summaryFields;
194		}
195
196		public boolean hasSummaryField(String key) {
197	0	return summaryFieldMap.containsKey(key);
198		}
199
200		public boolean isIncludeMultipleLookupLine() {
201	0	return includeMultipleLookupLine;
202		}
203
204		/** Set whether the multiple lookup line (and link) should appear above this collection. */
205		public void setIncludeMultipleLookupLine(boolean includeMultipleLookupLine) {
206	0	this.includeMultipleLookupLine = includeMultipleLookupLine;
207	0	}
208
209		public String getSummaryTitle() {
210	0	return summaryTitle;
211		}
212
213		/**
214		summaryTitle is the label of the summary
215		*/
216		public void setSummaryTitle(String overrideSummaryName) {
217	0	this.summaryTitle = overrideSummaryName;
218	0	}
219
220
221		public String getAttributeToHighlightOnDuplicateKey() {
222	0	return attributeToHighlightOnDuplicateKey;
223		}
224
225		/**
226		attributeToHighlightOnDuplicateKey is the name of an attribute to highlight
227		if two records in the collection are the same based on the
228		duplicateIdentificationFields element.
229		*/
230		public void setAttributeToHighlightOnDuplicateKey(String attributeToHighlightOnDuplicate) {
231	0	this.attributeToHighlightOnDuplicateKey = attributeToHighlightOnDuplicate;
232	0	}
233
234		public boolean dissallowDuplicateKey() {
235	0	return StringUtils.isNotBlank(getAttributeToHighlightOnDuplicateKey());
236		}
237
238		public List<MaintainableFieldDefinition> getDuplicateIdentificationFields() {
239	0	return duplicateIdentificationFields;
240		}
241
242		/** The list of fields to include in this collection. */
243		public void setMaintainableFields(List<MaintainableFieldDefinition> maintainableFields) {
244	0	maintainableFieldMap.clear();
245	0	for ( MaintainableFieldDefinition maintainableField : maintainableFields ) {
246	0	if (maintainableField == null) {
247	0	throw new IllegalArgumentException("invalid (null) maintainableField");
248		}
249
250	0	String fieldName = maintainableField.getName();
251	0	if (maintainableFieldMap.containsKey(fieldName)) {
252	0	throw new DuplicateEntryException("duplicate fieldName entry for field '" + fieldName + "'");
253		}
254
255	0	maintainableFieldMap.put(fieldName, maintainableField);
256	0	}
257	0	this.maintainableFields = maintainableFields;
258	0	}
259
260		/** The list of sub-collections to include in this collection. */
261		public void setMaintainableCollections(List<MaintainableCollectionDefinition> maintainableCollections) {
262	0	maintainableCollectionMap.clear();
263	0	for (MaintainableCollectionDefinition maintainableCollection : maintainableCollections ) {
264	0	if (maintainableCollection == null) {
265	0	throw new IllegalArgumentException("invalid (null) maintainableCollection");
266		}
267
268	0	String fieldName = maintainableCollection.getName();
269	0	if (maintainableCollectionMap.containsKey(fieldName)) {
270	0	throw new DuplicateEntryException("duplicate fieldName entry for field '" + fieldName + "'");
271		}
272
273	0	maintainableCollectionMap.put(fieldName, maintainableCollection);
274	0	}
275	0	this.maintainableCollections = maintainableCollections;
276	0	}
277
278		/**
279
280		The summaryFields element defines a set of summaryField
281		elements.
282		*/
283		public void setSummaryFields(List<MaintainableFieldDefinition> summaryFields) {
284	0	summaryFieldMap.clear();
285	0	for (MaintainableFieldDefinition summaryField : summaryFields ) {
286	0	if (summaryField == null) {
287	0	throw new IllegalArgumentException("invalid (null) summaryField");
288		}
289
290	0	String fieldName = summaryField.getName();
291	0	if (summaryFieldMap.containsKey(fieldName)) {
292	0	throw new DuplicateEntryException("duplicate fieldName entry for field '" + fieldName + "'");
293		}
294
295	0	summaryFieldMap.put(fieldName, summaryField);
296	0	}
297	0	this.summaryFields = summaryFields;
298	0	}
299
300		/**
301		The duplicateIdentificationFields element is used to define a set of
302		fields that will be used to determine if two records in the collection
303		are duplicates.
304		*/
305		public void setDuplicateIdentificationFields(List<MaintainableFieldDefinition> duplicateIdentificationFields) {
306	0	duplicateIdentificationFieldMap.clear();
307	0	for (MaintainableFieldDefinition identifierField : duplicateIdentificationFields) {
308	0	if (identifierField == null) {
309	0	throw new IllegalArgumentException("invalid (null) identifierField");
310		}
311
312	0	String fieldName = identifierField.getName();
313	0	if (duplicateIdentificationFieldMap.containsKey(fieldName)) {
314	0	throw new DuplicateEntryException("duplicate fieldName entry for field '" + fieldName + "'");
315		}
316
317	0	duplicateIdentificationFieldMap.put(fieldName, identifierField);
318	0	}
319	0	this.duplicateIdentificationFields = duplicateIdentificationFields;
320	0	}
321
322
323
324		public boolean isAlwaysAllowCollectionDeletion() {
325	0	return this.alwaysAllowCollectionDeletion;
326		}
327
328
329
330		public void setAlwaysAllowCollectionDeletion(
331		boolean alwaysAllowCollectionDeletion) {
332	0	this.alwaysAllowCollectionDeletion = alwaysAllowCollectionDeletion;
333	0	}
334
335		}