##### Coverage Report - org.apache.turbine.services.security.torque.TorqueObject

Classes in this File | Line Coverage | Branch Coverage | Complexity
TorqueObject |
0% | 0/46
0% | 0/18
| 1.8;1,8

1 |  |
     package org.apache.turbine.services.security.torque;
2 |  |
3 |  |
     /*
4 |  |
      * Licensed to the Apache Software Foundation (ASF) under one
5 |  |
      * or more contributor license agreements.  See the NOTICE file
6 |  |
      * distributed with this work for additional information
7 |  |
      * regarding copyright ownership.  The ASF licenses this file
8 |  |
      * to you under the Apache License, Version 2.0 (the
9 |  |
      * "License"); you may not use this file except in compliance
10 |  |
      * with the License.  You may obtain a copy of the License at
11 |  |
      *
12 |  |
      *   http://www.apache.org/licenses/LICENSE-2.0
13 |  |
      *
14 |  |
      * Unless required by applicable law or agreed to in writing,
15 |  |
      * software distributed under the License is distributed on an
16 |  |
      * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17 |  |
      * KIND, either express or implied.  See the License for the
18 |  |
      * specific language governing permissions and limitations
19 |  |
      * under the License.
20 |  |
      */
21 |  |
22 |  |
     import java.io.Serializable;
23 |  |
24 |  |
     import java.sql.Connection;
25 |  |
26 |  |
     import org.apache.torque.om.ObjectKey;
27 |  |
     import org.apache.torque.om.Persistent;
28 |  |
29 |  |
     import org.apache.turbine.om.security.SecurityEntity;
30 |  |
     import org.apache.turbine.util.security.TurbineSecurityException;
31 |  |
32 |  |
     /**
33 |  |
      * All the Torque Security objects (User, Group, Role, Permission) are
34 |  |
      * derived from this class which contains the base compare and management
35 |  |
      * methods for all security objects.
36 |  |
      *
37 |  |
      * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
38 |  |
      * @version $Id: TorqueObject.java 1096130 2011-04-23 10:37:19Z ludwig $
39 |  |
      */
40 |  |
41 |  |
     public abstract class TorqueObject
42 |  |
         implements SecurityEntity,
43 |  |
                    Comparable,
44 |  |
                    Persistent,
45 |  |
                    Serializable
46 |  |
     {
47 |  |
48 |  |
             static final long serialVersionUID = 5619862273774652856L;
49 |  |
50 |  |
         /** The underlying database Object which is proxied */
51 | 0 |
         protected Persistent obj = null;
52 |  |
53 |  |
         /**
54 |  |
          * Constructs a new TorqueObject
55 |  |
          *
56 |  |
          */
57 |  |
         public TorqueObject()
58 | 0 |
         {
59 | 0 |
         }
60 |  |
61 |  |
         /**
62 |  |
          * Constructs a new Object with the specified name.
63 |  |
          *
64 |  |
          * @param name The name of the new object.
65 |  |
          */
66 |  |
         public TorqueObject(String name)
67 | 0 |
         {
68 | 0 |
             this.setName(name);
69 | 0 |
         }
70 |  |
71 |  |
         /**
72 |  |
          * This Constructor is used when a Manager
73 |  |
          * has retrieved a list of Database Objects from the peer and
74 |  |
          * must 'wrap' them into TorqueObjects.
75 |  |
          *
76 |  |
          * @param obj An Object from the peer
77 |  |
          */
78 |  |
        public  TorqueObject(Persistent obj)
79 | 0 |
         {
80 | 0 |
             this.obj = obj;
81 | 0 |
         }
82 |  |
83 |  |
         /**
84 |  |
          * Returns the underlying Object for the Peer
85 |  |
          *
86 |  |
          * @return The underlying persistent object
87 |  |
          *
88 |  |
          */
89 |  |
         public abstract Persistent getPersistentObj();
90 |  |
91 |  |
         /**
92 |  |
          * Returns the name of this object
93 |  |
          *
94 |  |
          * @return The name of the object
95 |  |
          */
96 |  |
         public abstract String getName();
97 |  |
98 |  |
         /**
99 |  |
          * Sets the name of this object
100 |  |
          *
101 |  |
          * @param name The name of the object
102 |  |
          */
103 |  |
         public abstract void setName(String name);
104 |  |
105 |  |
         /**
106 |  |
          * getter for the object primaryKey.
107 |  |
          *
108 |  |
          * @return the object primaryKey as an Object
109 |  |
          */
110 |  |
         public ObjectKey getPrimaryKey()
111 |  |
         {
112 | 0 |
             Persistent p = getPersistentObj();
113 | 0 |
             if (p != null)
114 |  |
             {
115 | 0 |
                 return p.getPrimaryKey();
116 |  |
             }
117 |  |
             else
118 |  |
             {
119 | 0 |
                 return null;
120 |  |
             }
121 |  |
         }
122 |  |
123 |  |
         /**
124 |  |
          * Sets the PrimaryKey for the object.
125 |  |
          *
126 |  |
          * @param primaryKey The new PrimaryKey for the object.
127 |  |
          *
128 |  |
          * @exception Exception This method might throw an exceptions
129 |  |
          */
130 |  |
         public void setPrimaryKey(ObjectKey primaryKey)
131 |  |
             throws Exception
132 |  |
         {
133 | 0 |
             getPersistentObj().setPrimaryKey(primaryKey);
134 | 0 |
         }
135 |  |
136 |  |
         /**
137 |  |
          * Sets the PrimaryKey for the object.
138 |  |
          *
139 |  |
          * @param primaryKey the String should be of the form produced by
140 |  |
          *        ObjectKey.toString().
141 |  |
          *
142 |  |
          * @exception Exception This method might throw an exceptions
143 |  |
          */
144 |  |
         public void setPrimaryKey(String primaryKey)
145 |  |
             throws Exception
146 |  |
         {
147 | 0 |
             getPersistentObj().setPrimaryKey(primaryKey);
148 | 0 |
         }
149 |  |
150 |  |
         /**
151 |  |
          * Returns whether the object has been modified, since it was
152 |  |
          * last retrieved from storage.
153 |  |
          *
154 |  |
          * @return True if the object has been modified.
155 |  |
          */
156 |  |
         public boolean isModified()
157 |  |
         {
158 | 0 |
             return getPersistentObj().isModified();
159 |  |
         }
160 |  |
161 |  |
         /**
162 |  |
          * Returns whether the object has ever been saved.  This will
163 |  |
          * be false, if the object was retrieved from storage or was created
164 |  |
          * and then saved.
165 |  |
          *
166 |  |
          * @return true, if the object has never been persisted.
167 |  |
          */
168 |  |
         public boolean isNew()
169 |  |
         {
170 | 0 |
             return getPersistentObj().isNew();
171 |  |
         }
172 |  |
173 |  |
         /**
174 |  |
          * Setter for the isNew attribute.  This method will be called
175 |  |
          * by Torque-generated children and Peers.
176 |  |
          *
177 |  |
          * @param b the state of the object.
178 |  |
          */
179 |  |
         public void setNew(boolean b)
180 |  |
         {
181 | 0 |
             getPersistentObj().setNew(b);
182 | 0 |
         }
183 |  |
184 |  |
         /**
185 |  |
          * Sets the modified state for the object.
186 |  |
          *
187 |  |
          * @param m The new modified state for the object.
188 |  |
          */
189 |  |
         public void setModified(boolean m)
190 |  |
         {
191 | 0 |
             getPersistentObj().setModified(m);
192 | 0 |
         }
193 |  |
194 |  |
         /**
195 |  |
          * Stores the object in the database.  If the object is new,
196 |  |
          * it inserts it; otherwise an update is performed.
197 |  |
          *
198 |  |
          * @param torqueName The name under which the object should be stored.
199 |  |
          *
200 |  |
          * @exception Exception This method might throw an exceptions
201 |  |
          */
202 |  |
         public void save(String torqueName)
203 |  |
             throws Exception
204 |  |
         {
205 | 0 |
             getPersistentObj().save(torqueName);
206 | 0 |
         }
207 |  |
208 |  |
         /**
209 |  |
          * Stores the object in the database.  If the object is new,
210 |  |
          * it inserts it; otherwise an update is performed.  This method
211 |  |
          * is meant to be used as part of a transaction, otherwise use
212 |  |
          * the save() method and the connection details will be handled
213 |  |
          * internally
214 |  |
          *
215 |  |
          * @param con A Connection object to save the object
216 |  |
          *
217 |  |
          * @exception Exception This method might throw an exceptions
218 |  |
          */
219 |  |
         public void save(Connection con)
220 |  |
             throws Exception
221 |  |
         {
222 | 0 |
             getPersistentObj().save(con);
223 | 0 |
         }
224 |  |
225 |  |
         /**
226 |  |
          * Makes changes made to the TorqueObject permanent.
227 |  |
          *
228 |  |
          * @throws TurbineSecurityException if there is a problem while
229 |  |
          *  saving data.
230 |  |
          */
231 |  |
         public abstract void save()
232 |  |
             throws TurbineSecurityException;
233 |  |
234 |  |
         /**
235 |  |
          * Used for ordering TorqueObjects.
236 |  |
          *
237 |  |
          * @param obj The Object to compare to.
238 |  |
          * @return -1 if the name of the other object is lexically greater than this
239 |  |
          *         group, 1 if it is lexically lesser, 0 if they are equal.
240 |  |
          */
241 |  |
         public int compareTo(Object obj)
242 |  |
         {
243 | 0 |
             if (this.getClass() != obj.getClass())
244 |  |
             {
245 | 0 |
                 throw new ClassCastException();
246 |  |
             }
247 | 0 |
             String name1 = ((SecurityEntity) obj).getName();
248 | 0 |
             String name2 = this.getName();
249 |  |
250 | 0 |
             return name2.compareTo(name1);
251 |  |
         }
252 |  |
253 |  |
         /**
254 |  |
          * Compares this with another <code>BaseObject</code> instance.  If
255 |  |
          * <code>obj</code> is an instance of <code>BaseObject</code>, delegates to
256 |  |
          * <code>equals(BaseObject)</code>.  Otherwise, returns <code>false</code>.
257 |  |
          *
258 |  |
          * @param obj The object to compare to.
259 |  |
          * @return    Whether equal to the object specified.
260 |  |
          */
261 |  |
         public boolean equals(Object obj)
262 |  |
         {
263 | 0 |
             if (obj != null && obj instanceof TorqueObject)
264 |  |
             {
265 | 0 |
                 return equals((TorqueObject) obj);
266 |  |
             }
267 |  |
             else
268 |  |
             {
269 | 0 |
                 return false;
270 |  |
             }
271 |  |
         }
272 |  |
273 |  |
         /**
274 |  |
          * Compares the primary key of this instance with the key of another.
275 |  |
          *
276 |  |
          * @param torqueObject The TorqueObject to compare to.
277 |  |
          * @return   Whether the primary keys are equal.
278 |  |
          */
279 |  |
         public boolean equals(TorqueObject torqueObject)
280 |  |
         {
281 | 0 |
             if (torqueObject == null)
282 |  |
             {
283 | 0 |
                 return false;
284 |  |
             }
285 | 0 |
             if (this == torqueObject)
286 |  |
             {
287 | 0 |
                 return true;
288 |  |
             }
289 | 0 |
             else if (getPrimaryKey() == null || torqueObject.getPrimaryKey() == null)
290 |  |
             {
291 | 0 |
                 return false;
292 |  |
             }
293 |  |
             else
294 |  |
             {
295 | 0 |
                 return getPrimaryKey().equals(torqueObject.getPrimaryKey());
296 |  |
             }
297 |  |
         }
298 |  |
299 |  |
         /**
300 |  |
          * If the primary key is not <code>null</code>, return the hashcode of the
301 |  |
          * primary key.  Otherwise calls <code>Object.hashCode()</code>.
302 |  |
          *
303 |  |
          * @return an <code>int</code> value
304 |  |
          */
305 |  |
         public int hashCode()
306 |  |
         {
307 | 0 |
             ObjectKey ok = getPrimaryKey();
308 | 0 |
             if (ok == null)
309 |  |
             {
310 | 0 |
                 return super.hashCode();
311 |  |
             }
312 |  |
313 | 0 |
             return ok.hashCode();
314 |  |
         }
315 |  |
     }