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