Coverage Report

Coverage Report - org.kuali.rice.core.framework.persistence.jpa.CompositePrimaryKeyBase

Classes in this File

Line Coverage

Branch Coverage

Complexity

CompositePrimaryKeyBase

0/62

0/34

8.8

CompositePrimaryKeyBase$1

0/2

N/A

8.8

 /*
  * Copyright 2006-2011 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.core.framework.persistence.jpa;
 
 import org.apache.commons.lang.builder.HashCodeBuilder;
 
 import javax.persistence.Id;
 import java.io.Serializable;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Comparator;
 
 public abstract class CompositePrimaryKeyBase implements Serializable {
 
     public boolean equals(Object o) {
         Class thisClass = (this.getClass());
         Class otherClass = thisClass.cast(o).getClass();
 
         if (o == this) return true;
         if (!(thisClass.isInstance(o))) return false;
         if (o == null) return false;
         
         Method[] methods = thisClass.getMethods();
         for (Method method : methods) {
             if (isGetter(method)) {
                 try {
                      if (method.invoke(this) != null) {
                         if (method.getReturnType().isInstance(Object.class)                      
                             && !method.invoke(this).equals(method.invoke(o))) {
                              return false;
                          } else if (method.invoke(this) != method.invoke(o)) {
                              return false;
                          }
                     } else {
                         return false;
                     }
                 }
                 catch (IllegalArgumentException ex) {
                     ex.printStackTrace();
                     return false;
                 }
                 catch (SecurityException ex) {
                     ex.printStackTrace();
                     return false;
                 }
                 catch (IllegalAccessException ex) {
                     ex.printStackTrace();
                     return false;
                 }
                 catch (InvocationTargetException ex) {
                     ex.printStackTrace();
                     return false;
                 }
             }
         }
         return true;
     }
 
     public int hashCode() {
         HashCodeBuilder hashCodeBuilder = new HashCodeBuilder();
         Class thisClass = (this.getClass());
         
         Method[] methods = thisClass.getMethods();
         
         //need to sort methods so we can be sure they are ordered correctly every time.
         Arrays.sort(methods, new Comparator() {
             public int compare(Object a, Object b) {
                 return ((Method)a).getName().compareTo(((Method)b).getName());
             }
         });
         for (Method method : methods) {
             if (isGetter(method)) {
                 try {
                     hashCodeBuilder.append(method.invoke(this));
                 }
                 catch (IllegalArgumentException ex) {
                     ex.printStackTrace();
                 }
                 catch (IllegalAccessException ex) {
                     ex.printStackTrace();
                 }
                 catch (InvocationTargetException ex) {
                     ex.printStackTrace();
                 } 
             } 
         }
         
         return hashCodeBuilder.toHashCode();
     }
     
     protected static boolean isGetter(Method method){
         if(!(method.getName().startsWith("get") 
                 || method.getName().startsWith("is"))) {
             return false;
         }
         if(method.getParameterTypes().length != 0) {
             return false;  
         }
         if(void.class.equals(method.getReturnType())) { 
             return false;
         }
         
         return true;
       }
     
     public String toString() {
             StringBuilder s = new StringBuilder();
             
             try {
                         for (Field field : this.getClass().getDeclaredFields()) {
                                 field.setAccessible(true);
                                 
                                 if (field.isAnnotationPresent(Id.class)) {
                                         s.append(field.getName());
                                         s.append(": ");
                                         s.append(field.get(this));
                                         s.append(", ");
                                 }
                         }
                         
                         return s.substring(0, s.length() - 2).toString();
                 } catch (Exception e) {
                         return s.toString();
                 }
     }
     
 }

1		/*
2		* Copyright 2006-2011 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
17		package org.kuali.rice.core.framework.persistence.jpa;
18
19		import org.apache.commons.lang.builder.HashCodeBuilder;
20
21		import javax.persistence.Id;
22		import java.io.Serializable;
23		import java.lang.reflect.Field;
24		import java.lang.reflect.InvocationTargetException;
25		import java.lang.reflect.Method;
26		import java.util.Arrays;
27		import java.util.Comparator;
28
29	0	public abstract class CompositePrimaryKeyBase implements Serializable {
30
31		public boolean equals(Object o) {
32	0	Class thisClass = (this.getClass());
33	0	Class otherClass = thisClass.cast(o).getClass();
34
35	0	if (o == this) return true;
36	0	if (!(thisClass.isInstance(o))) return false;
37	0	if (o == null) return false;
38
39	0	Method[] methods = thisClass.getMethods();
40	0	for (Method method : methods) {
41	0	if (isGetter(method)) {
42		try {
43	0	if (method.invoke(this) != null) {
44	0	if (method.getReturnType().isInstance(Object.class)
45		&& !method.invoke(this).equals(method.invoke(o))) {
46	0	return false;
47	0	} else if (method.invoke(this) != method.invoke(o)) {
48	0	return false;
49		}
50		} else {
51	0	return false;
52		}
53		}
54	0	catch (IllegalArgumentException ex) {
55	0	ex.printStackTrace();
56	0	return false;
57		}
58	0	catch (SecurityException ex) {
59	0	ex.printStackTrace();
60	0	return false;
61		}
62	0	catch (IllegalAccessException ex) {
63	0	ex.printStackTrace();
64	0	return false;
65		}
66	0	catch (InvocationTargetException ex) {
67	0	ex.printStackTrace();
68	0	return false;
69	0	}
70		}
71		}
72	0	return true;
73		}
74
75		public int hashCode() {
76	0	HashCodeBuilder hashCodeBuilder = new HashCodeBuilder();
77	0	Class thisClass = (this.getClass());
78
79	0	Method[] methods = thisClass.getMethods();
80
81		//need to sort methods so we can be sure they are ordered correctly every time.
82	0	Arrays.sort(methods, new Comparator() {
83		public int compare(Object a, Object b) {
84	0	return ((Method)a).getName().compareTo(((Method)b).getName());
85		}
86		});
87	0	for (Method method : methods) {
88	0	if (isGetter(method)) {
89		try {
90	0	hashCodeBuilder.append(method.invoke(this));
91		}
92	0	catch (IllegalArgumentException ex) {
93	0	ex.printStackTrace();
94		}
95	0	catch (IllegalAccessException ex) {
96	0	ex.printStackTrace();
97		}
98	0	catch (InvocationTargetException ex) {
99	0	ex.printStackTrace();
100	0	}
101		}
102		}
103
104	0	return hashCodeBuilder.toHashCode();
105		}
106
107		protected static boolean isGetter(Method method){
108	0	if(!(method.getName().startsWith("get")
109		\|\| method.getName().startsWith("is"))) {
110	0	return false;
111		}
112	0	if(method.getParameterTypes().length != 0) {
113	0	return false;
114		}
115	0	if(void.class.equals(method.getReturnType())) {
116	0	return false;
117		}
118
119	0	return true;
120		}
121
122		public String toString() {
123	0	StringBuilder s = new StringBuilder();
124
125		try {
126	0	for (Field field : this.getClass().getDeclaredFields()) {
127	0	field.setAccessible(true);
128
129	0	if (field.isAnnotationPresent(Id.class)) {
130	0	s.append(field.getName());
131	0	s.append(": ");
132	0	s.append(field.get(this));
133	0	s.append(", ");
134		}
135		}
136
137	0	return s.substring(0, s.length() - 2).toString();
138	0	} catch (Exception e) {
139	0	return s.toString();
140		}
141		}
142
143		}