Coverage Report

Coverage Report - org.apache.ojb.odmg.TransactionExt

Classes in this File

 package org.apache.ojb.odmg;
 
 /* 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.odmg.Transaction;
 import org.apache.ojb.broker.Identity;
 
 /**
  * Offers useful none odmg-standard methods of the odmg {@link org.odmg.Transaction} interface.
  * <p>
  * Note: All listed methods are <strong>not</strong> part of the standard ODMG-api -
  * they are special (proprietary) OJB extensions.
  * </p>
  *
  * @version $Id: TransactionExt.java,v 1.1 2007-08-24 22:17:37 ewestfal Exp $
  */
 public interface TransactionExt extends Transaction, HasBroker
 {
     /**
      * Marks an object for deletion without
      * locking the object. If the object wasn't locked before,
      * OJB will ask for a WRITE lock at commit.
      *
      * @param  anObject Object to be marked
      */
     public void markDelete(Object anObject);
 
     /**
      * Marks an object as dirty without
      * locking the object. If the object wasn't locked before,
      * OJB will ask for a WRITE lock at commit.
      *
      * @param  anObject Object to be marked
      */
     public void markDirty(Object anObject);
 
     /**
      * <p>
      * Calling <code>flush</code> flushes persistent object modifications
      * made within the ODMG transaction since the last checkpoint to the underlying
      * database transaction, but does <b<not</b> commit the database transaction.
      * The ODMG transaction retains all locks it held on those objects at the time the flush
      * was invoked.
      * <p/>
      * This method is very similair to {@link org.odmg.Transaction#checkpoint}.
      */
     public void flush();
 
     /**
      * This method can be used to activate or deactivate the implicit
      * locking mechanism for the current transaction.
      * <br/>
      * If set <em>true</em> OJB implicitly locks objects to ODMG transactions
      * after performing OQL queries. Also if implicit locking is used
      * locking objects is recursive, that is associated objects are also
      * locked. If ImplicitLocking is set to 'false', no locks are obtained
      * in OQL queries, lookup objects and there is also no recursive locking.
      * <p/>
      * Turning off implicit locking may improve performance but requires
      * additional care to make sure all changed objects are properly
      * registered to the transaction.
      *
      * @param value If set <em>true</em> implicit locking is enabled,
      *        if <em>false</em>, implicit locking is disabled.
      * @see ImplementationExt#setImplicitLocking(boolean)
      **/
     public void setImplicitLocking(boolean value);
 
     /**
      * Returns <em>true</em> if implicite locking is enabled.
      * @see #setImplicitLocking(boolean)
      */
     public boolean isImplicitLocking();
 
     /**
      * Allows to change the <em>cascading delete</em> behavior of the target class's
      * reference field while this transaction is in use.
      *
      * @param target The class to change cascading delete behavior of the references.
      * @param referenceField The field name of the 1:1, 1:n or m:n reference.
      * @param doCascade If <em>true</em> cascading delete is enabled, <em>false</em> disabled.
      */
     public void setCascadingDelete(Class target, String referenceField, boolean doCascade);
 
     /**
      * Allows to change the <em>cascading delete</em> behavior of all references of the
      * specified class while this transaction is in use.
      *
      * @param target The class to change cascading delete behavior of all references.
      * @param doCascade If <em>true</em> cascading delete is enabled, <em>false</em> disabled.
      */
     public void setCascadingDelete(Class target, boolean doCascade);
 
     /**
      * Return <em>true</em> if the OJB ordering algorithm is enabled.
      * @see #setOrdering(boolean)
      */
     public boolean isOrdering();
 
     /**
      * Allows to enable/disable the OJB persistent object ordering algorithm. If
      * <em>true</em> OJB try to order the modified/new/deleted objects in a correct order
      * (based on a algorithm) before the objects are written to the persistent storage.
      * <br/>
      * If the used databases support 'deferred checks' it's recommended to
      * use this feature and to disable OJB's object ordering.
      * <p/>
      * If <em>false</em> the order of the objects rely on the order specified by
      * the user and on settings like {@link #setImplicitLocking(boolean)}.
      *
      * @param ordering Set <em>true</em> to enable object ordering on commit.
      * @see ImplementationExt#setOrdering(boolean)
      */
     public void setOrdering(boolean ordering);
 
 //    /**
 //     * Returns whether or not the persistent method calls determine
 //     * the persistent object order on commit.
 //     *
 //     * @see #setNoteUserOrder(boolean)
 //     */
 //    public boolean isNoteUserOrder();
 //
 //    /**
 //     * If <em>true</em> the order of persisting method calls like
 //     * <br/> - {@link org.odmg.Transaction#lock(Object, int)}).
 //     * <br/> - {@link org.odmg.Database#deletePersistent(Object)}).
 //     * <br/> - {@link org.odmg.Database#makePersistent(Object)})
 //     * determine the order of objects before commit.
 //     * <br/>
 //     * If <em>false</em> the ordering was determined by OJB's internal
 //     * method calls and user calls.
 //     * <br/>
 //     * However it's possible to set this value as a global property
 //     * for all transactions using {@link ImplementationExt#setNoteUserOrder(boolean)}.
 //     * <p/>
 //     * <strong>NOTE:</strong> If OJB's ordering algorithm (see
 //     * {@link #setOrdering(boolean)}) is enabled, the
 //     * order of objects may change on commit.
 //     *
 //     * @param noteUserOrder If <em>true</em> the order of persisting
 //     * method calls determine the order of objects.
 //     * @see ImplementationExt#setNoteUserOrder(boolean)
 //     */
 //    public void setNoteUserOrder(boolean noteUserOrder);
 
     /**
      * Checks if the object with the given {@link org.apache.ojb.broker.Identity}
      * has been deleted within the transaction using
      * {@link org.odmg.Database#deletePersistent(Object)} or {@link #markDelete(Object)}.
      *
      * @param id The identity of the object.
      * @return <em>true</em> if the object has been deleted within the transaction.
      */
     public boolean isDeleted(Identity id);
 }

1		package org.apache.ojb.odmg;
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.odmg.Transaction;
19		import org.apache.ojb.broker.Identity;
20
21		/**
22		* Offers useful none odmg-standard methods of the odmg {@link org.odmg.Transaction} interface.
23		* <p>
24		* Note: All listed methods are <strong>not</strong> part of the standard ODMG-api -
25		* they are special (proprietary) OJB extensions.
26		* </p>
27		*
28		* @version $Id: TransactionExt.java,v 1.1 2007-08-24 22:17:37 ewestfal Exp $
29		*/
30		public interface TransactionExt extends Transaction, HasBroker
31		{
32		/**
33		* Marks an object for deletion without
34		* locking the object. If the object wasn't locked before,
35		* OJB will ask for a WRITE lock at commit.
36		*
37		* @param anObject Object to be marked
38		*/
39		public void markDelete(Object anObject);
40
41		/**
42		* Marks an object as dirty without
43		* locking the object. If the object wasn't locked before,
44		* OJB will ask for a WRITE lock at commit.
45		*
46		* @param anObject Object to be marked
47		*/
48		public void markDirty(Object anObject);
49
50		/**
51		* <p>
52		* Calling <code>flush</code> flushes persistent object modifications
53		* made within the ODMG transaction since the last checkpoint to the underlying
54		* database transaction, but does <b<not</b> commit the database transaction.
55		* The ODMG transaction retains all locks it held on those objects at the time the flush
56		* was invoked.
57		* <p/>
58		* This method is very similair to {@link org.odmg.Transaction#checkpoint}.
59		*/
60		public void flush();
61
62		/**
63		* This method can be used to activate or deactivate the implicit
64		* locking mechanism for the current transaction.
65		* <br/>
66		* If set <em>true</em> OJB implicitly locks objects to ODMG transactions
67		* after performing OQL queries. Also if implicit locking is used
68		* locking objects is recursive, that is associated objects are also
69		* locked. If ImplicitLocking is set to 'false', no locks are obtained
70		* in OQL queries, lookup objects and there is also no recursive locking.
71		* <p/>
72		* Turning off implicit locking may improve performance but requires
73		* additional care to make sure all changed objects are properly
74		* registered to the transaction.
75		*
76		* @param value If set <em>true</em> implicit locking is enabled,
77		* if <em>false</em>, implicit locking is disabled.
78		* @see ImplementationExt#setImplicitLocking(boolean)
79		**/
80		public void setImplicitLocking(boolean value);
81
82		/**
83		* Returns <em>true</em> if implicite locking is enabled.
84		* @see #setImplicitLocking(boolean)
85		*/
86		public boolean isImplicitLocking();
87
88		/**
89		* Allows to change the <em>cascading delete</em> behavior of the target class's
90		* reference field while this transaction is in use.
91		*
92		* @param target The class to change cascading delete behavior of the references.
93		* @param referenceField The field name of the 1:1, 1:n or m:n reference.
94		* @param doCascade If <em>true</em> cascading delete is enabled, <em>false</em> disabled.
95		*/
96		public void setCascadingDelete(Class target, String referenceField, boolean doCascade);
97
98		/**
99		* Allows to change the <em>cascading delete</em> behavior of all references of the
100		* specified class while this transaction is in use.
101		*
102		* @param target The class to change cascading delete behavior of all references.
103		* @param doCascade If <em>true</em> cascading delete is enabled, <em>false</em> disabled.
104		*/
105		public void setCascadingDelete(Class target, boolean doCascade);
106
107		/**
108		* Return <em>true</em> if the OJB ordering algorithm is enabled.
109		* @see #setOrdering(boolean)
110		*/
111		public boolean isOrdering();
112
113		/**
114		* Allows to enable/disable the OJB persistent object ordering algorithm. If
115		* <em>true</em> OJB try to order the modified/new/deleted objects in a correct order
116		* (based on a algorithm) before the objects are written to the persistent storage.
117		* <br/>
118		* If the used databases support 'deferred checks' it's recommended to
119		* use this feature and to disable OJB's object ordering.
120		* <p/>
121		* If <em>false</em> the order of the objects rely on the order specified by
122		* the user and on settings like {@link #setImplicitLocking(boolean)}.
123		*
124		* @param ordering Set <em>true</em> to enable object ordering on commit.
125		* @see ImplementationExt#setOrdering(boolean)
126		*/
127		public void setOrdering(boolean ordering);
128
129		// /**
130		// * Returns whether or not the persistent method calls determine
131		// * the persistent object order on commit.
132		// *
133		// * @see #setNoteUserOrder(boolean)
134		// */
135		// public boolean isNoteUserOrder();
136		//
137		// /**
138		// * If <em>true</em> the order of persisting method calls like
139		// * <br/> - {@link org.odmg.Transaction#lock(Object, int)}).
140		// * <br/> - {@link org.odmg.Database#deletePersistent(Object)}).
141		// * <br/> - {@link org.odmg.Database#makePersistent(Object)})
142		// * determine the order of objects before commit.
143		// * <br/>
144		// * If <em>false</em> the ordering was determined by OJB's internal
145		// * method calls and user calls.
146		// * <br/>
147		// * However it's possible to set this value as a global property
148		// * for all transactions using {@link ImplementationExt#setNoteUserOrder(boolean)}.
149		// * <p/>
150		// * <strong>NOTE:</strong> If OJB's ordering algorithm (see
151		// * {@link #setOrdering(boolean)}) is enabled, the
152		// * order of objects may change on commit.
153		// *
154		// * @param noteUserOrder If <em>true</em> the order of persisting
155		// * method calls determine the order of objects.
156		// * @see ImplementationExt#setNoteUserOrder(boolean)
157		// */
158		// public void setNoteUserOrder(boolean noteUserOrder);
159
160		/**
161		* Checks if the object with the given {@link org.apache.ojb.broker.Identity}
162		* has been deleted within the transaction using
163		* {@link org.odmg.Database#deletePersistent(Object)} or {@link #markDelete(Object)}.
164		*
165		* @param id The identity of the object.
166		* @return <em>true</em> if the object has been deleted within the transaction.
167		*/
168		public boolean isDeleted(Identity id);
169		}