Coverage Report

Coverage Report - org.apache.commons.clazz.reflect.common.ReflectedListPropertyParseResults

Classes in this File

Line Coverage

Branch Coverage

Complexity

ReflectedListPropertyParseResults

0/184

0/158

4.958

 /*
  * Copyright 2002-2004 The Apache Software Foundation
  *
  * Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0
  *
  * 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.apache.commons.clazz.reflect.common;
 
 import java.lang.reflect.Method;
 import java.util.List;
 
 import org.apache.commons.clazz.Clazz;
 import org.apache.commons.clazz.reflect.ReflectedClazz;
 
 /**
  * Holds parse results for individual accessor methods for a 
  * list property.
  * 
  * @author <a href="mailto:dmitri@apache.org">Dmitri Plotnikov</a>
  * @version $Id: ReflectedListPropertyParseResults.java 155436 2005-02-26 13:17:48Z dirkv $
  */
 public class ReflectedListPropertyParseResults 
             extends ReflectedPropertyParseResults
 {
     private AccessorMethodParseResults getMethodParseResults;
     private AccessorMethodParseResults setMethodParseResults;
     private AccessorMethodParseResults addMethodParseResults;
     private AccessorMethodParseResults addIndexedMethodParseResults;
     private AccessorMethodParseResults removeMethodParseResults;
     private AccessorMethodParseResults removeIndexedMethodParseResults;
     
     private AccessorMethodParseResults sizeMethodParseResults;
     
 
     /**
      * Constructor for ReflectedMappedPropertyParseResults.
      */
     public ReflectedListPropertyParseResults(
             ReflectedClazz clazz, String propertyName) 
     {
         super(clazz, propertyName);
     }
     
     protected String getPropertyCategory() {
         return "list";
     }
     
     /**
      * Returns <code>true</code> if the property is an array or 
      * implements java.util.List.
      */
     public boolean isList() {
         if (readMethodParseResults != null
             && isList(readMethodParseResults.getType())) {
             return true;
         }
         if (writeMethodParseResults != null
             && isList(writeMethodParseResults.getType())) {
             return true;
         }
         return false;
     }
         
     /**
      * Returns <code>true</code> if javaClass is an array or 
      * implements java.util.List.
      */
     protected boolean isList(Class javaClass) {
         return javaClass != null
             && (List.class.isAssignableFrom(javaClass) || javaClass.isArray());
     }
     
     /**
      * Returns the type of the list/array element, if known. 
      * Returns <code>null</code> otherwise.
      */
     public Class getContentType() {
         if (getMethodParseResults != null) {
             return getMethodParseResults.getType();
         }
         if (setMethodParseResults != null) {
             return setMethodParseResults.getType();
         }
         if (addMethodParseResults != null) {
             return addMethodParseResults.getType();
         }
         if (addIndexedMethodParseResults != null) {
             return addIndexedMethodParseResults.getType();
         }
         if (removeMethodParseResults != null) {
             return removeMethodParseResults.getType();
         }
         if (readMethodParseResults != null) {
             Class type = readMethodParseResults.getType();
             if (type.isArray()) {
                 return type.getComponentType();
             }
         }
         if (writeMethodParseResults != null) {
             Class type = writeMethodParseResults.getType();
             if (type.isArray()) {
                 return type.getComponentType();
             }
         }
         return null;
     }
 
     public void setGetMethodParseResults(
                 AccessorMethodParseResults getMethodParseResults) 
     {
         checkForExtraneousAccessor(
             this.getMethodParseResults,
             getMethodParseResults);
         this.getMethodParseResults = getMethodParseResults;
     }
 
     public Method getGetMethod() {
         if (getMethodParseResults == null) {
             return null;
         }
         return getMethodParseResults.getMethod();
     }
     
     public void setSetMethodParseResults(
                 AccessorMethodParseResults setMethodParseResults) 
     {
         checkForExtraneousAccessor(
             this.setMethodParseResults,
             setMethodParseResults);
         this.setMethodParseResults = setMethodParseResults;
     }
 
     public Method getSetMethod() {
         if (setMethodParseResults == null) {
             return null;
         }
         return setMethodParseResults.getMethod();
     }
     
     public void setAddMethodParseResults(
                 AccessorMethodParseResults addMethodParseResults) 
     {
         checkForExtraneousAccessor(
             this.addMethodParseResults,
             addMethodParseResults);
         this.addMethodParseResults = addMethodParseResults;
     }
 
     public Method getAddMethod() {
         if (addMethodParseResults == null) {
             return null;
         }
         return addMethodParseResults.getMethod();
     }
     
     public void setAddIndexedMethodParseResults(
                 AccessorMethodParseResults addIndexedMethodParseResults) 
     {
         checkForExtraneousAccessor(
             this.addIndexedMethodParseResults,
             addIndexedMethodParseResults);
         this.addIndexedMethodParseResults = addIndexedMethodParseResults;
     }
     
     public Method getAddIndexedMethod() {
         if (addIndexedMethodParseResults == null) {
             return null;
         }
         return addIndexedMethodParseResults.getMethod();
     }
         
     public void setRemoveMethodParseResults(
                 AccessorMethodParseResults removeMethodParseResults) 
     {
         checkForExtraneousAccessor(
             this.removeMethodParseResults,
             removeMethodParseResults);
         this.removeMethodParseResults = removeMethodParseResults;
     }
     
     public Method getRemoveMethod() {
         if (removeMethodParseResults == null) {
             return null;
         }
         return removeMethodParseResults.getMethod();
     }
     
     public void setRemoveIndexedMethodParseResults(
                 AccessorMethodParseResults removeIndexedMethodParseResults)
     {
         checkForExtraneousAccessor(
             this.removeIndexedMethodParseResults,
             removeIndexedMethodParseResults);
         this.removeIndexedMethodParseResults = removeIndexedMethodParseResults;
     }
 
     public Method getRemoveIndexedMethod() {
         if (removeIndexedMethodParseResults == null) {
             return null;
         }
         return removeIndexedMethodParseResults.getMethod();
     }
 
 
     public void setSizeMethodParseResults(
                 AccessorMethodParseResults sizeMethodParseResults) 
     {
         checkForExtraneousAccessor(
             this.sizeMethodParseResults,
             sizeMethodParseResults);
         this.sizeMethodParseResults = sizeMethodParseResults;
     }
     
     public Method getSizeMethod() {
         if (sizeMethodParseResults == null) {
             return null;
         }
         return sizeMethodParseResults.getMethod();
     }
     
     /**
      * Combines parse results from another instance of 
      * <code>ReflectedMappedPropertyParseResults</code> with
      * results contained by this object.
      * <p>
      * Node that the property name is not copied from the 
      * <code>other</code> object.
      */        
     public void merge(ReflectedListPropertyParseResults other) {
         super.merge(other);
         if (other.readMethodParseResults != null) {
             setReadMethodParseResults(other.readMethodParseResults);
         }
         if (other.writeMethodParseResults != null) {
             setWriteMethodParseResults(other.writeMethodParseResults);
         }
         if (other.getMethodParseResults != null) {
             setGetMethodParseResults(other.getMethodParseResults);
         }
         if (other.setMethodParseResults != null) {
             setSetMethodParseResults(other.setMethodParseResults);
         }
         if (other.addMethodParseResults != null) {
             setAddMethodParseResults(other.addMethodParseResults);
         }
         if (other.addIndexedMethodParseResults != null) {
             setAddIndexedMethodParseResults(other.addIndexedMethodParseResults);
         }
         if (other.removeMethodParseResults != null) {
             setRemoveMethodParseResults(other.removeMethodParseResults);
         }
         if (other.sizeMethodParseResults != null) {
             setSizeMethodParseResults(other.sizeMethodParseResults);
         }
     }
     
     protected void appendDescription(StringBuffer buffer) {
         super.appendDescription(buffer);
         Class contentType = getContentType();
         if (contentType != null) {
             buffer.append("\n  [content type]   ");
             buffer.append(Clazz.getCanonicalClassName(contentType));
         }
     }
     
     protected void appendMethodDescriptions(StringBuffer buffer) {
         super.appendMethodDescriptions(buffer);
         if (getMethodParseResults != null) {
             buffer.append("\n    [get~(int)]    ");
             buffer.append(getMethodParseResults.getMethod());
         }
         if (setMethodParseResults != null) {
             buffer.append("\n    [set~(int,v)]  ");
             buffer.append(setMethodParseResults.getMethod());
         }
         if (addMethodParseResults != null) {
             buffer.append("\n    [add~(v)]      ");
             buffer.append(addMethodParseResults.getMethod());
         }
         if (addIndexedMethodParseResults != null) {
             buffer.append("\n    [add~(int,v)]  ");
             buffer.append(addIndexedMethodParseResults.getMethod());
         }
         if (removeMethodParseResults != null) {
             buffer.append("\n    [remove~(v)]   ");
             buffer.append(removeMethodParseResults.getMethod());
         }
         if (removeIndexedMethodParseResults != null) {
             buffer.append("\n    [remove~(i)]   ");
             buffer.append(removeIndexedMethodParseResults.getMethod());
         }
         if (sizeMethodParseResults != null) {
             buffer.append("\n    [get~Count()]  ");
             buffer.append(sizeMethodParseResults.getMethod());
         }
     }
     
     public boolean checkConsistency() {        
         if (!super.checkConsistency()) {
             return false;
         }
                 
         if (readMethodParseResults == null && getMethodParseResults == null) {
             return false;
         }
 
         if (readMethodParseResults != null) {
             Class type = readMethodParseResults.getType();
             if (writeMethodParseResults != null) {
                 if (!type.equals(writeMethodParseResults.getType())) {
                     return false;
                 }
             }
         }
                 
         Class contentType = null;
          
         if (getMethodParseResults != null) {
             contentType = getMethodParseResults.getType();
         }
         
         if (setMethodParseResults != null) {
             if (contentType == null) {
                 contentType = setMethodParseResults.getType();
             }
             else {
                 if (!contentType.equals(setMethodParseResults.getType())) {
                     return false;
                 }
             }
         }
         
         if (addMethodParseResults != null) {
             if (contentType == null) {
                 contentType = addMethodParseResults.getType();
             }
             else {
                 if (!contentType.equals(addMethodParseResults.getType())) {
                     return false;
                 }
             }
         }
         
         if (addIndexedMethodParseResults != null) {
             if (contentType == null) {
                 contentType = addIndexedMethodParseResults.getType();
             }
             else {
                 if (!contentType.equals(
                         addIndexedMethodParseResults.getType())) {
                     return false;
                 }
             }
         }
         
         if (removeMethodParseResults != null) {
             if (contentType != null) {
                 if (!contentType.equals(removeMethodParseResults.getType())) {
                     return false;
                 }
             }
         }
         
         return true;
     }
         
     protected boolean appendInconsistencyDescriptions(StringBuffer buffer) {
         if (!super.appendInconsistencyDescriptions(buffer)) {
             return false;
         }        
         
         if (readMethodParseResults == null && getMethodParseResults == null) {
             buffer.append(
                 "\n     - Does not have either get() or get(int) method");
             return true;
         }
 
         if (readMethodParseResults != null) {
             Class type = readMethodParseResults.getType();
             if (writeMethodParseResults != null) {
                 if (!type.equals(writeMethodParseResults.getType())) {
                     buffer.append(
                         "\n     - Get() and set(v) types do not match");
                 }
             }
         }
         
         Class contentType = null;
          
         if (getMethodParseResults != null) {
             contentType = getMethodParseResults.getType();
         }
         
         if (setMethodParseResults != null) {
             if (contentType == null) {
                 contentType = setMethodParseResults.getType();
             }
             else {
                 if (!contentType.equals(setMethodParseResults.getType())) {
                     buffer.append(
                         "\n     - Content type mismatch between "
                             + "get(int) and set(int,v)");
                 }
             }
         }
         
         if (addMethodParseResults != null) {
             if (contentType == null) {
                 contentType = addMethodParseResults.getType();
             }
             else {
                 if (!contentType.equals(addMethodParseResults.getType())) {
                     buffer.append(
                         "\n     - Content type mismatch between "
                             + "get(int) and add(v)");
                 }
             }
         }
         
         if (addIndexedMethodParseResults != null) {
             if (contentType == null) {
                 contentType = addIndexedMethodParseResults.getType();
             }
             else {
                 if (!contentType.equals(
                         addIndexedMethodParseResults.getType())) {
                     buffer.append(
                         "\n     - Content type mismatch between "
                             + "get(int) and add(int,v)");
                 }
             }
         }
         
         if (removeMethodParseResults != null) {
             if (contentType != null) {
                 Class removeType = removeMethodParseResults.getType(); 
                 if (removeType != null && !contentType.equals(removeType)) {
                     buffer.append(
                         "\n     - Content type mismatch between "
                             + "get(int) and remove(v)");
                 }
             }
         }        
         return true;
     }  
 }

1		/*
2		* Copyright 2002-2004 The Apache Software Foundation
3		*
4		* Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0
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.apache.commons.clazz.reflect.common;
17
18		import java.lang.reflect.Method;
19		import java.util.List;
20
21		import org.apache.commons.clazz.Clazz;
22		import org.apache.commons.clazz.reflect.ReflectedClazz;
23
24		/**
25		* Holds parse results for individual accessor methods for a
26		* list property.
27		*
28		* @author <a href="mailto:dmitri@apache.org">Dmitri Plotnikov</a>
29		* @version $Id: ReflectedListPropertyParseResults.java 155436 2005-02-26 13:17:48Z dirkv $
30		*/
31		public class ReflectedListPropertyParseResults
32		extends ReflectedPropertyParseResults
33		{
34		private AccessorMethodParseResults getMethodParseResults;
35		private AccessorMethodParseResults setMethodParseResults;
36		private AccessorMethodParseResults addMethodParseResults;
37		private AccessorMethodParseResults addIndexedMethodParseResults;
38		private AccessorMethodParseResults removeMethodParseResults;
39		private AccessorMethodParseResults removeIndexedMethodParseResults;
40
41		private AccessorMethodParseResults sizeMethodParseResults;
42
43
44		/**
45		* Constructor for ReflectedMappedPropertyParseResults.
46		*/
47		public ReflectedListPropertyParseResults(
48		ReflectedClazz clazz, String propertyName)
49		{
50	0	super(clazz, propertyName);
51	0	}
52
53		protected String getPropertyCategory() {
54	0	return "list";
55		}
56
57		/**
58		* Returns <code>true</code> if the property is an array or
59		* implements java.util.List.
60		*/
61		public boolean isList() {
62	0	if (readMethodParseResults != null
63		&& isList(readMethodParseResults.getType())) {
64	0	return true;
65		}
66	0	if (writeMethodParseResults != null
67		&& isList(writeMethodParseResults.getType())) {
68	0	return true;
69		}
70	0	return false;
71		}
72
73		/**
74		* Returns <code>true</code> if javaClass is an array or
75		* implements java.util.List.
76		*/
77		protected boolean isList(Class javaClass) {
78	0	return javaClass != null
79	0	&& (List.class.isAssignableFrom(javaClass) \|\| javaClass.isArray());
80		}
81
82		/**
83		* Returns the type of the list/array element, if known.
84		* Returns <code>null</code> otherwise.
85		*/
86		public Class getContentType() {
87	0	if (getMethodParseResults != null) {
88	0	return getMethodParseResults.getType();
89		}
90	0	if (setMethodParseResults != null) {
91	0	return setMethodParseResults.getType();
92		}
93	0	if (addMethodParseResults != null) {
94	0	return addMethodParseResults.getType();
95		}
96	0	if (addIndexedMethodParseResults != null) {
97	0	return addIndexedMethodParseResults.getType();
98		}
99	0	if (removeMethodParseResults != null) {
100	0	return removeMethodParseResults.getType();
101		}
102	0	if (readMethodParseResults != null) {
103	0	Class type = readMethodParseResults.getType();
104	0	if (type.isArray()) {
105	0	return type.getComponentType();
106		}
107		}
108	0	if (writeMethodParseResults != null) {
109	0	Class type = writeMethodParseResults.getType();
110	0	if (type.isArray()) {
111	0	return type.getComponentType();
112		}
113		}
114	0	return null;
115		}
116
117		public void setGetMethodParseResults(
118		AccessorMethodParseResults getMethodParseResults)
119		{
120	0	checkForExtraneousAccessor(
121		this.getMethodParseResults,
122		getMethodParseResults);
123	0	this.getMethodParseResults = getMethodParseResults;
124	0	}
125
126		public Method getGetMethod() {
127	0	if (getMethodParseResults == null) {
128	0	return null;
129		}
130	0	return getMethodParseResults.getMethod();
131		}
132
133		public void setSetMethodParseResults(
134		AccessorMethodParseResults setMethodParseResults)
135		{
136	0	checkForExtraneousAccessor(
137		this.setMethodParseResults,
138		setMethodParseResults);
139	0	this.setMethodParseResults = setMethodParseResults;
140	0	}
141
142		public Method getSetMethod() {
143	0	if (setMethodParseResults == null) {
144	0	return null;
145		}
146	0	return setMethodParseResults.getMethod();
147		}
148
149		public void setAddMethodParseResults(
150		AccessorMethodParseResults addMethodParseResults)
151		{
152	0	checkForExtraneousAccessor(
153		this.addMethodParseResults,
154		addMethodParseResults);
155	0	this.addMethodParseResults = addMethodParseResults;
156	0	}
157
158		public Method getAddMethod() {
159	0	if (addMethodParseResults == null) {
160	0	return null;
161		}
162	0	return addMethodParseResults.getMethod();
163		}
164
165		public void setAddIndexedMethodParseResults(
166		AccessorMethodParseResults addIndexedMethodParseResults)
167		{
168	0	checkForExtraneousAccessor(
169		this.addIndexedMethodParseResults,
170		addIndexedMethodParseResults);
171	0	this.addIndexedMethodParseResults = addIndexedMethodParseResults;
172	0	}
173
174		public Method getAddIndexedMethod() {
175	0	if (addIndexedMethodParseResults == null) {
176	0	return null;
177		}
178	0	return addIndexedMethodParseResults.getMethod();
179		}
180
181		public void setRemoveMethodParseResults(
182		AccessorMethodParseResults removeMethodParseResults)
183		{
184	0	checkForExtraneousAccessor(
185		this.removeMethodParseResults,
186		removeMethodParseResults);
187	0	this.removeMethodParseResults = removeMethodParseResults;
188	0	}
189
190		public Method getRemoveMethod() {
191	0	if (removeMethodParseResults == null) {
192	0	return null;
193		}
194	0	return removeMethodParseResults.getMethod();
195		}
196
197		public void setRemoveIndexedMethodParseResults(
198		AccessorMethodParseResults removeIndexedMethodParseResults)
199		{
200	0	checkForExtraneousAccessor(
201		this.removeIndexedMethodParseResults,
202		removeIndexedMethodParseResults);
203	0	this.removeIndexedMethodParseResults = removeIndexedMethodParseResults;
204	0	}
205
206		public Method getRemoveIndexedMethod() {
207	0	if (removeIndexedMethodParseResults == null) {
208	0	return null;
209		}
210	0	return removeIndexedMethodParseResults.getMethod();
211		}
212
213
214		public void setSizeMethodParseResults(
215		AccessorMethodParseResults sizeMethodParseResults)
216		{
217	0	checkForExtraneousAccessor(
218		this.sizeMethodParseResults,
219		sizeMethodParseResults);
220	0	this.sizeMethodParseResults = sizeMethodParseResults;
221	0	}
222
223		public Method getSizeMethod() {
224	0	if (sizeMethodParseResults == null) {
225	0	return null;
226		}
227	0	return sizeMethodParseResults.getMethod();
228		}
229
230		/**
231		* Combines parse results from another instance of
232		* <code>ReflectedMappedPropertyParseResults</code> with
233		* results contained by this object.
234		* <p>
235		* Node that the property name is not copied from the
236		* <code>other</code> object.
237		*/
238		public void merge(ReflectedListPropertyParseResults other) {
239	0	super.merge(other);
240	0	if (other.readMethodParseResults != null) {
241	0	setReadMethodParseResults(other.readMethodParseResults);
242		}
243	0	if (other.writeMethodParseResults != null) {
244	0	setWriteMethodParseResults(other.writeMethodParseResults);
245		}
246	0	if (other.getMethodParseResults != null) {
247	0	setGetMethodParseResults(other.getMethodParseResults);
248		}
249	0	if (other.setMethodParseResults != null) {
250	0	setSetMethodParseResults(other.setMethodParseResults);
251		}
252	0	if (other.addMethodParseResults != null) {
253	0	setAddMethodParseResults(other.addMethodParseResults);
254		}
255	0	if (other.addIndexedMethodParseResults != null) {
256	0	setAddIndexedMethodParseResults(other.addIndexedMethodParseResults);
257		}
258	0	if (other.removeMethodParseResults != null) {
259	0	setRemoveMethodParseResults(other.removeMethodParseResults);
260		}
261	0	if (other.sizeMethodParseResults != null) {
262	0	setSizeMethodParseResults(other.sizeMethodParseResults);
263		}
264	0	}
265
266		protected void appendDescription(StringBuffer buffer) {
267	0	super.appendDescription(buffer);
268	0	Class contentType = getContentType();
269	0	if (contentType != null) {
270	0	buffer.append("\n [content type] ");
271	0	buffer.append(Clazz.getCanonicalClassName(contentType));
272		}
273	0	}
274
275		protected void appendMethodDescriptions(StringBuffer buffer) {
276	0	super.appendMethodDescriptions(buffer);
277	0	if (getMethodParseResults != null) {
278	0	buffer.append("\n [get~(int)] ");
279	0	buffer.append(getMethodParseResults.getMethod());
280		}
281	0	if (setMethodParseResults != null) {
282	0	buffer.append("\n [set~(int,v)] ");
283	0	buffer.append(setMethodParseResults.getMethod());
284		}
285	0	if (addMethodParseResults != null) {
286	0	buffer.append("\n [add~(v)] ");
287	0	buffer.append(addMethodParseResults.getMethod());
288		}
289	0	if (addIndexedMethodParseResults != null) {
290	0	buffer.append("\n [add~(int,v)] ");
291	0	buffer.append(addIndexedMethodParseResults.getMethod());
292		}
293	0	if (removeMethodParseResults != null) {
294	0	buffer.append("\n [remove~(v)] ");
295	0	buffer.append(removeMethodParseResults.getMethod());
296		}
297	0	if (removeIndexedMethodParseResults != null) {
298	0	buffer.append("\n [remove~(i)] ");
299	0	buffer.append(removeIndexedMethodParseResults.getMethod());
300		}
301	0	if (sizeMethodParseResults != null) {
302	0	buffer.append("\n [get~Count()] ");
303	0	buffer.append(sizeMethodParseResults.getMethod());
304		}
305	0	}
306
307		public boolean checkConsistency() {
308	0	if (!super.checkConsistency()) {
309	0	return false;
310		}
311
312	0	if (readMethodParseResults == null && getMethodParseResults == null) {
313	0	return false;
314		}
315
316	0	if (readMethodParseResults != null) {
317	0	Class type = readMethodParseResults.getType();
318	0	if (writeMethodParseResults != null) {
319	0	if (!type.equals(writeMethodParseResults.getType())) {
320	0	return false;
321		}
322		}
323		}
324
325	0	Class contentType = null;
326
327	0	if (getMethodParseResults != null) {
328	0	contentType = getMethodParseResults.getType();
329		}
330
331	0	if (setMethodParseResults != null) {
332	0	if (contentType == null) {
333	0	contentType = setMethodParseResults.getType();
334		}
335		else {
336	0	if (!contentType.equals(setMethodParseResults.getType())) {
337	0	return false;
338		}
339		}
340		}
341
342	0	if (addMethodParseResults != null) {
343	0	if (contentType == null) {
344	0	contentType = addMethodParseResults.getType();
345		}
346		else {
347	0	if (!contentType.equals(addMethodParseResults.getType())) {
348	0	return false;
349		}
350		}
351		}
352
353	0	if (addIndexedMethodParseResults != null) {
354	0	if (contentType == null) {
355	0	contentType = addIndexedMethodParseResults.getType();
356		}
357		else {
358	0	if (!contentType.equals(
359		addIndexedMethodParseResults.getType())) {
360	0	return false;
361		}
362		}
363		}
364
365	0	if (removeMethodParseResults != null) {
366	0	if (contentType != null) {
367	0	if (!contentType.equals(removeMethodParseResults.getType())) {
368	0	return false;
369		}
370		}
371		}
372
373	0	return true;
374		}
375
376		protected boolean appendInconsistencyDescriptions(StringBuffer buffer) {
377	0	if (!super.appendInconsistencyDescriptions(buffer)) {
378	0	return false;
379		}
380
381	0	if (readMethodParseResults == null && getMethodParseResults == null) {
382	0	buffer.append(
383		"\n - Does not have either get() or get(int) method");
384	0	return true;
385		}
386
387	0	if (readMethodParseResults != null) {
388	0	Class type = readMethodParseResults.getType();
389	0	if (writeMethodParseResults != null) {
390	0	if (!type.equals(writeMethodParseResults.getType())) {
391	0	buffer.append(
392		"\n - Get() and set(v) types do not match");
393		}
394		}
395		}
396
397	0	Class contentType = null;
398
399	0	if (getMethodParseResults != null) {
400	0	contentType = getMethodParseResults.getType();
401		}
402
403	0	if (setMethodParseResults != null) {
404	0	if (contentType == null) {
405	0	contentType = setMethodParseResults.getType();
406		}
407		else {
408	0	if (!contentType.equals(setMethodParseResults.getType())) {
409	0	buffer.append(
410		"\n - Content type mismatch between "
411		+ "get(int) and set(int,v)");
412		}
413		}
414		}
415
416	0	if (addMethodParseResults != null) {
417	0	if (contentType == null) {
418	0	contentType = addMethodParseResults.getType();
419		}
420		else {
421	0	if (!contentType.equals(addMethodParseResults.getType())) {
422	0	buffer.append(
423		"\n - Content type mismatch between "
424		+ "get(int) and add(v)");
425		}
426		}
427		}
428
429	0	if (addIndexedMethodParseResults != null) {
430	0	if (contentType == null) {
431	0	contentType = addIndexedMethodParseResults.getType();
432		}
433		else {
434	0	if (!contentType.equals(
435		addIndexedMethodParseResults.getType())) {
436	0	buffer.append(
437		"\n - Content type mismatch between "
438		+ "get(int) and add(int,v)");
439		}
440		}
441		}
442
443	0	if (removeMethodParseResults != null) {
444	0	if (contentType != null) {
445	0	Class removeType = removeMethodParseResults.getType();
446	0	if (removeType != null && !contentType.equals(removeType)) {
447	0	buffer.append(
448		"\n - Content type mismatch between "
449		+ "get(int) and remove(v)");
450		}
451		}
452		}
453	0	return true;
454		}
455		}