Coverage Report

Coverage Report - org.apache.ojb.broker.PBStateEvent

Classes in this File

Line Coverage

Branch Coverage

3.333

3.333

 package org.apache.ojb.broker;
 
 /* Copyright 2003-2005 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.
  */
 
 import org.apache.commons.lang.builder.ToStringBuilder;
 
 /**
  * The <code>PBStateEvent</code> encapsulates information about
  * the life-cycle/transaction demarcation of the used {@link org.apache.ojb.broker.PersistenceBroker}
  * instance.
  *
  * @author Armin Waibel
  * @version $Id: PBStateEvent.java,v 1.1 2007-08-24 22:17:35 ewestfal Exp $
  */
 public final class PBStateEvent extends PersistenceBrokerEvent
 {
     /** Denotes an event that happens before the broker will be closed. */
     public static final int KEY_BEFORE_CLOSE = 1;
     /** Denotes an event that happens before a transaction will be started. */
     public static final int KEY_BEFORE_BEGIN = 2;
     /** Denotes an event that happens before a transaction will be comitted. */
     public static final int KEY_BEFORE_COMMIT = 3;
     /** Denotes an event that happens before a transaction will be rolled back. */
     public static final int KEY_BEFORE_ROLLBACK = 4;
     /** Denotes an event that happens after a transaction was started. */
     public static final int KEY_AFTER_BEGIN = 5;
     /** Denotes an event that happens after a transaction was comitted. */
     public static final int KEY_AFTER_COMMIT = 6;
     /** Denotes an event that happens after a broker was opened. */
     public static final int KEY_AFTER_OPEN = 7;
     /** Denotes an event that happens after a transaction was rolled back. */
     public static final int KEY_AFTER_ROLLBACK = 8;
 
     private Type eventType;
 
     /**
      * Creates a new event instance.
      * 
      * @param broker    The broker
      * @param eventType The type of the event
      */
     public PBStateEvent(PersistenceBroker broker, Type eventType)
     {
         super(broker);
         this.eventType = eventType;
     }
 
     /**
      * {@inheritDoc}
      */
     public String toString()
     {
         ToStringBuilder buf = new ToStringBuilder(this);
         buf.append("type", eventType.toString()).
                 append("source object", getSource());
         return buf.toString();
     }
 
     /**
      * Returns the event type.
      * 
      * @return The event type
      */
     public Type getEventType()
     {
         return eventType;
     }
 
     /**
      * Enum-like class for the event types.
      */
     public static class Type
     {
         /** Denotes an event that happens before a transaction will be started. */
         public static final Type BEFORE_BEGIN = new Type(KEY_BEFORE_BEGIN);
         /** Denotes an event that happens after a transaction was started. */
         public static final Type AFTER_BEGIN = new Type(KEY_AFTER_BEGIN);
         /** Denotes an event that happens before a transaction will be comitted. */
         public static final Type BEFORE_COMMIT = new Type(KEY_BEFORE_COMMIT);
         /** Denotes an event that happens after a transaction was comitted. */
         public static final Type AFTER_COMMIT = new Type(KEY_AFTER_COMMIT);
         /** Denotes an event that happens before a transaction will be rolled back. */
         public static final Type BEFORE_ROLLBACK = new Type(KEY_BEFORE_ROLLBACK);
         /** Denotes an event that happens after a transaction was rolled back. */
         public static final Type AFTER_ROLLBACK = new Type(KEY_AFTER_ROLLBACK);
         /** Denotes an event that happens after a broker was opened. */
         public static final Type AFTER_OPEN = new Type(KEY_AFTER_OPEN);
         /** Denotes an event that happens before the broker will be closed. */
         public static final Type BEFORE_CLOSE = new Type(KEY_BEFORE_CLOSE);
 
         private int type;
 
         /**
          * Creates a new instance.
          * 
          * @param type The type value
          */
         protected Type(int type)
         {
             this.type = type;
         }
 
         /**
          * {@inheritDoc}
          */
         public final boolean equals(Object obj)
         {
             if (obj == this)
             {
                 return true;
             }
             if (!(obj instanceof PBStateEvent))
             {
                 return false;
             }
 
             return type == ((Type) obj).type;
         }
 
         /**
          * {@inheritDoc}
          */
         public final int hashCode()
         {
             return type;
         }
         
         /**
          * Returns the type id.
          * 
          * @return The type id
          */
         public final int typeId()
         {
             return type;
         }
 
         /**
          * {@inheritDoc}
          */
         public String toString()
         {
             return this.getClass().getName() + " [type= " + typeAsName(type) + "]";
         }
 
         private String typeAsName(int aType)
         {
             if (aType == KEY_AFTER_BEGIN)
             {
                 return "AFTER_BEGIN";
             }
             else if (aType == KEY_AFTER_COMMIT)
             {
                 return "AFTER_COMMIT";
             }
             else if (aType == KEY_AFTER_OPEN)
             {
                 return "AFTER_OPEN";
             }
             else if (aType == KEY_AFTER_ROLLBACK)
             {
                 return "AFTER_ROLLBACK";
             }
             else if (aType == KEY_BEFORE_BEGIN)
             {
                 return "BEFORE_BEGIN";
             }
             else if (aType == KEY_BEFORE_CLOSE)
             {
                 return "BEFORE_CLOSE";
             }
             else if (aType == KEY_BEFORE_COMMIT)
             {
                 return "BEFORE_COMMIT";
             }
             else if (aType == KEY_BEFORE_ROLLBACK)
             {
                 return "BEFORE_ROLLBACK";
             }
             else
             {
                 throw new OJBRuntimeException("Could not find type " + aType);
             }
         }
     }
 }

1		package org.apache.ojb.broker;
2
3		/* Copyright 2003-2005 The Apache Software Foundation
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17
18		import org.apache.commons.lang.builder.ToStringBuilder;
19
20		/**
21		* The <code>PBStateEvent</code> encapsulates information about
22		* the life-cycle/transaction demarcation of the used {@link org.apache.ojb.broker.PersistenceBroker}
23		* instance.
24		*
25		* @author Armin Waibel
26		* @version $Id: PBStateEvent.java,v 1.1 2007-08-24 22:17:35 ewestfal Exp $
27		*/
28		public final class PBStateEvent extends PersistenceBrokerEvent
29		{
30		/** Denotes an event that happens before the broker will be closed. */
31		public static final int KEY_BEFORE_CLOSE = 1;
32		/** Denotes an event that happens before a transaction will be started. */
33		public static final int KEY_BEFORE_BEGIN = 2;
34		/** Denotes an event that happens before a transaction will be comitted. */
35		public static final int KEY_BEFORE_COMMIT = 3;
36		/** Denotes an event that happens before a transaction will be rolled back. */
37		public static final int KEY_BEFORE_ROLLBACK = 4;
38		/** Denotes an event that happens after a transaction was started. */
39		public static final int KEY_AFTER_BEGIN = 5;
40		/** Denotes an event that happens after a transaction was comitted. */
41		public static final int KEY_AFTER_COMMIT = 6;
42		/** Denotes an event that happens after a broker was opened. */
43		public static final int KEY_AFTER_OPEN = 7;
44		/** Denotes an event that happens after a transaction was rolled back. */
45		public static final int KEY_AFTER_ROLLBACK = 8;
46
47		private Type eventType;
48
49		/**
50		* Creates a new event instance.
51		*
52		* @param broker The broker
53		* @param eventType The type of the event
54		*/
55		public PBStateEvent(PersistenceBroker broker, Type eventType)
56		{
57		super(broker);
58		this.eventType = eventType;
59		}
60
61		/**
62		* {@inheritDoc}
63		*/
64		public String toString()
65		{
66		ToStringBuilder buf = new ToStringBuilder(this);
67		buf.append("type", eventType.toString()).
68		append("source object", getSource());
69		return buf.toString();
70		}
71
72		/**
73		* Returns the event type.
74		*
75		* @return The event type
76		*/
77		public Type getEventType()
78		{
79		return eventType;
80		}
81
82		/**
83		* Enum-like class for the event types.
84		*/
85		public static class Type
86		{
87		/** Denotes an event that happens before a transaction will be started. */
88		public static final Type BEFORE_BEGIN = new Type(KEY_BEFORE_BEGIN);
89		/** Denotes an event that happens after a transaction was started. */
90		public static final Type AFTER_BEGIN = new Type(KEY_AFTER_BEGIN);
91		/** Denotes an event that happens before a transaction will be comitted. */
92		public static final Type BEFORE_COMMIT = new Type(KEY_BEFORE_COMMIT);
93		/** Denotes an event that happens after a transaction was comitted. */
94		public static final Type AFTER_COMMIT = new Type(KEY_AFTER_COMMIT);
95		/** Denotes an event that happens before a transaction will be rolled back. */
96		public static final Type BEFORE_ROLLBACK = new Type(KEY_BEFORE_ROLLBACK);
97		/** Denotes an event that happens after a transaction was rolled back. */
98		public static final Type AFTER_ROLLBACK = new Type(KEY_AFTER_ROLLBACK);
99		/** Denotes an event that happens after a broker was opened. */
100		public static final Type AFTER_OPEN = new Type(KEY_AFTER_OPEN);
101		/** Denotes an event that happens before the broker will be closed. */
102		public static final Type BEFORE_CLOSE = new Type(KEY_BEFORE_CLOSE);
103
104		private int type;
105
106		/**
107		* Creates a new instance.
108		*
109		* @param type The type value
110		*/
111		protected Type(int type)
112		{
113		this.type = type;
114		}
115
116		/**
117		* {@inheritDoc}
118		*/
119		public final boolean equals(Object obj)
120		{
121		if (obj == this)
122		{
123		return true;
124		}
125		if (!(obj instanceof PBStateEvent))
126		{
127		return false;
128		}
129
130		return type == ((Type) obj).type;
131		}
132
133		/**
134		* {@inheritDoc}
135		*/
136		public final int hashCode()
137		{
138		return type;
139		}
140
141		/**
142		* Returns the type id.
143		*
144		* @return The type id
145		*/
146		public final int typeId()
147		{
148		return type;
149		}
150
151		/**
152		* {@inheritDoc}
153		*/
154		public String toString()
155		{
156		return this.getClass().getName() + " [type= " + typeAsName(type) + "]";
157		}
158
159		private String typeAsName(int aType)
160		{
161		if (aType == KEY_AFTER_BEGIN)
162		{
163		return "AFTER_BEGIN";
164		}
165		else if (aType == KEY_AFTER_COMMIT)
166		{
167		return "AFTER_COMMIT";
168		}
169		else if (aType == KEY_AFTER_OPEN)
170		{
171		return "AFTER_OPEN";
172		}
173		else if (aType == KEY_AFTER_ROLLBACK)
174		{
175		return "AFTER_ROLLBACK";
176		}
177		else if (aType == KEY_BEFORE_BEGIN)
178		{
179		return "BEFORE_BEGIN";
180		}
181		else if (aType == KEY_BEFORE_CLOSE)
182		{
183		return "BEFORE_CLOSE";
184		}
185		else if (aType == KEY_BEFORE_COMMIT)
186		{
187		return "BEFORE_COMMIT";
188		}
189		else if (aType == KEY_BEFORE_ROLLBACK)
190		{
191		return "BEFORE_ROLLBACK";
192		}
193		else
194		{
195		throw new OJBRuntimeException("Could not find type " + aType);
196		}
197		}
198		}
199		}