Coverage Report

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

Classes in this File

 package org.apache.ojb.odmg;
 
 /* Copyright 2002-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.Implementation;
 
 /**
  * Offers useful none odmg-standard methods of the odmg {@link org.odmg.Implementation} 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: ImplementationExt.java,v 1.1 2007-08-24 22:17:37 ewestfal Exp $
  */
 public interface ImplementationExt extends Implementation
 {
     /**
      * The used collection type class returned by OQL queries.
      *
      * @see org.apache.ojb.odmg.oql.EnhancedOQLQuery#execute()
      * @see org.odmg.OQLQuery#execute()
      * @return The collection class type
      */
     public Class getOqlCollectionClass();
 
     /**
      * Set the used collection type class returned by OQL queries.
      * <p/>
      * NOTE: Each specified class must implement interface {@link org.apache.ojb.broker.ManageableCollection}
      * to work proper with OJB.
      *
      * @param oqlCollectionClass The collection class used in OQL queries.
      */
     public void setOqlCollectionClass(Class oqlCollectionClass);
 
     /**
      * If the OJB implicit locking feature (see {@link TransactionExt#setImplicitLocking(boolean)}) is
      * enabled, this define the lock type of all implicit locked objects.
      * <p/>
      * If set to <em>true</em>, acquiring a write-lock on a given object x implies write locks on all
      * implicit locked objects.
      * <br/>
      * If set to <em>false</em>, in any case implicit read-locks are acquired.
      * Acquiring a read- or write lock on x thus allways results in implicit read-locks
      * on all associated objects.
      *
      * @param impliciteWriteLocks If <em>true</em> implicit write locks will enabled.
      */
     public void setImpliciteWriteLocks(boolean impliciteWriteLocks);
 
     /**
      * Is <em>true</em> when implicite write locks are enabled.
      *
      * @return <em>true</em> when implicit write locks are enabled.
      * @see #setImpliciteWriteLocks(boolean)
      */
     public boolean isImpliciteWriteLocks();
 
     /**
      * Set the global property <em>implicit locking</em>. This method can be used
      * to activate or deactivate the global implicit
      * locking mechanism.
      * <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/>
      * However it's possible to set this value only for the current used {@link org.odmg.Transaction}
      * using {@link TransactionExt#setImplicitLocking(boolean)} and to detect the implicit locking
      * state of the used transaction instance call {@link TransactionExt#isImplicitLocking()}.
      * <br/>
      * Turning off implicit locking may improve performance but requires
      * additional care to make sure that all changed objects are properly
      * registered to the transaction.
      *
      * @param impliciteLocking If set <em>true</em> implicit locking is enabled,
      *        if <em>false</em>, implicit locking is disabled.
      */
     public void setImplicitLocking(boolean impliciteLocking);
 
     /**
      * Returns <em>true</em> if the global implicit locking is enabled
      * for this {@link org.odmg.Implementation} instance, else <em>false</em>.
      * <br/>
      * <strong>Important:</strong> The returned value is the global used setting for all
      * {@link org.odmg.Transaction#lock(Object, int)} calls.
      * <br/>
      * However it's possible to set this value only for the current used {@link org.odmg.Transaction}
      * using {@link TransactionExt#setImplicitLocking(boolean)} and to detect the implicit locking
      * state of the used transaction instance call {@link TransactionExt#isImplicitLocking()}.
      *
      * @return <em>true</em> if the global property <em>implicit locking</em><em>true</em> is enabled.
      * @see #setImplicitLocking(boolean)
      */
     public boolean isImplicitLocking();
 
     /**
      * Returns <em>true</em> if OJB's ordering algorithm is enabled.
      *
      * @see #setOrdering(boolean)
      */
     public boolean isOrdering();
 
     /**
      * Disable/enable OJB's ordering algorithm when insert, update, delete a
      * bunch of objects within a transaction. The ordering algorithm try to
      * calculate the correct order of the modified/new persistent objects to
      * prevent problems on commit of the transaction.
      * <br/>
      * If the used databases support 'deferred checks' it's recommended to
      * use this feature and to disable OJB's object ordering.
      * <p/>
      * However it's possible to set this value only for the current
      * used {@link org.odmg.Transaction} using {@link TransactionExt#setOrdering(boolean)}
      *
      * @param ordering If <em>true</em> OJB's ordering algorithm is used.
      */
     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 only for the current
 //     * used {@link org.odmg.Transaction} using {@link TransactionExt#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.
 //     */
 //    public void setNoteUserOrder(boolean noteUserOrder);
 
 
 //    /**
 //     * Get object by OJB's {@link org.apache.ojb.broker.Identity}.
 //     *
 //     * @param id The identity of the object to look for.
 //     * @return The matching object or <em>null</em>.
 //     */
 //    public Object getObjectByIdentity(Identity id);
 
 //    /**
 //     * If set <em>true</em> the odmg implementation do it's best to find out the user intension, if set
 //     * <em>false</em> OJB use an optimized mode and the user has to adhere strictly the odmg-api:
 //     * <ul>
 //     * <li>
 //     * New objects can only be made persistent by using {@link org.odmg.Database#makePersistent(Object)}
 //     * </li>
 //     * <li>
 //     * Only persistent objects can be locked with {@link org.odmg.Transaction#lock(Object, int)}.
 //     * </li>
 //     * <li>
 //     * When deleting an object with {@link org.odmg.Database#deletePersistent(Object)} to reuse it
 //     * within a transaction a call to {@link org.odmg.Database#makePersistent(Object)} is needed and
 //     * field changes on objects marked as "deleted" are not allowed.
 //     * </li>
 //     * </ul>
 //     * When running odmg in <em>safe-mode</em> these restrictions are "softened" and it's e.g. possible
 //     * to persist new objects with {@link org.odmg.Transaction#lock(Object, int)}.
 //     * <p/>
 //     * The <em>optimized-mode</em> show a significant better performance, but needs strictness in using the API.
 //     *
 //     * @param safeMode Set <em>true</em> to enable the <em>safe-mode</em>, use <em>false</em> to enable
 //     *                 the <em>optimized-mode</em>.
 //     */
 //    void setSafeMode(boolean safeMode);
 //
 //    /**
 //     * Returns <em>true</em> if this class use the safe-mode for
 //     * user interaction, else the optimized-mode is used.
 //     */
 //    boolean isSafeMode();
 }

1		package org.apache.ojb.odmg;
2
3		/* Copyright 2002-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.Implementation;
19
20		/**
21		* Offers useful none odmg-standard methods of the odmg {@link org.odmg.Implementation} interface.
22		* <p>
23		* Note: All listed methods are <strong>not</strong> part of the standard ODMG-api -
24		* they are special (proprietary) OJB extensions.
25		* </p>
26		*
27		* @version $Id: ImplementationExt.java,v 1.1 2007-08-24 22:17:37 ewestfal Exp $
28		*/
29		public interface ImplementationExt extends Implementation
30		{
31		/**
32		* The used collection type class returned by OQL queries.
33		*
34		* @see org.apache.ojb.odmg.oql.EnhancedOQLQuery#execute()
35		* @see org.odmg.OQLQuery#execute()
36		* @return The collection class type
37		*/
38		public Class getOqlCollectionClass();
39
40		/**
41		* Set the used collection type class returned by OQL queries.
42		* <p/>
43		* NOTE: Each specified class must implement interface {@link org.apache.ojb.broker.ManageableCollection}
44		* to work proper with OJB.
45		*
46		* @param oqlCollectionClass The collection class used in OQL queries.
47		*/
48		public void setOqlCollectionClass(Class oqlCollectionClass);
49
50		/**
51		* If the OJB implicit locking feature (see {@link TransactionExt#setImplicitLocking(boolean)}) is
52		* enabled, this define the lock type of all implicit locked objects.
53		* <p/>
54		* If set to <em>true</em>, acquiring a write-lock on a given object x implies write locks on all
55		* implicit locked objects.
56		* <br/>
57		* If set to <em>false</em>, in any case implicit read-locks are acquired.
58		* Acquiring a read- or write lock on x thus allways results in implicit read-locks
59		* on all associated objects.
60		*
61		* @param impliciteWriteLocks If <em>true</em> implicit write locks will enabled.
62		*/
63		public void setImpliciteWriteLocks(boolean impliciteWriteLocks);
64
65		/**
66		* Is <em>true</em> when implicite write locks are enabled.
67		*
68		* @return <em>true</em> when implicit write locks are enabled.
69		* @see #setImpliciteWriteLocks(boolean)
70		*/
71		public boolean isImpliciteWriteLocks();
72
73		/**
74		* Set the global property <em>implicit locking</em>. This method can be used
75		* to activate or deactivate the global implicit
76		* locking mechanism.
77		* <br/>
78		* If set <em>true</em> OJB implicitly locks objects to ODMG transactions
79		* after performing OQL queries. Also if implicit locking is used
80		* locking objects is recursive, that is associated objects are also
81		* locked. If ImplicitLocking is set to 'false', no locks are obtained
82		* in OQL queries, lookup objects and there is also no recursive locking.
83		* <p/>
84		* However it's possible to set this value only for the current used {@link org.odmg.Transaction}
85		* using {@link TransactionExt#setImplicitLocking(boolean)} and to detect the implicit locking
86		* state of the used transaction instance call {@link TransactionExt#isImplicitLocking()}.
87		* <br/>
88		* Turning off implicit locking may improve performance but requires
89		* additional care to make sure that all changed objects are properly
90		* registered to the transaction.
91		*
92		* @param impliciteLocking If set <em>true</em> implicit locking is enabled,
93		* if <em>false</em>, implicit locking is disabled.
94		*/
95		public void setImplicitLocking(boolean impliciteLocking);
96
97		/**
98		* Returns <em>true</em> if the global implicit locking is enabled
99		* for this {@link org.odmg.Implementation} instance, else <em>false</em>.
100		* <br/>
101		* <strong>Important:</strong> The returned value is the global used setting for all
102		* {@link org.odmg.Transaction#lock(Object, int)} calls.
103		* <br/>
104		* However it's possible to set this value only for the current used {@link org.odmg.Transaction}
105		* using {@link TransactionExt#setImplicitLocking(boolean)} and to detect the implicit locking
106		* state of the used transaction instance call {@link TransactionExt#isImplicitLocking()}.
107		*
108		* @return <em>true</em> if the global property <em>implicit locking</em><em>true</em> is enabled.
109		* @see #setImplicitLocking(boolean)
110		*/
111		public boolean isImplicitLocking();
112
113		/**
114		* Returns <em>true</em> if OJB's ordering algorithm is enabled.
115		*
116		* @see #setOrdering(boolean)
117		*/
118		public boolean isOrdering();
119
120		/**
121		* Disable/enable OJB's ordering algorithm when insert, update, delete a
122		* bunch of objects within a transaction. The ordering algorithm try to
123		* calculate the correct order of the modified/new persistent objects to
124		* prevent problems on commit of the transaction.
125		* <br/>
126		* If the used databases support 'deferred checks' it's recommended to
127		* use this feature and to disable OJB's object ordering.
128		* <p/>
129		* However it's possible to set this value only for the current
130		* used {@link org.odmg.Transaction} using {@link TransactionExt#setOrdering(boolean)}
131		*
132		* @param ordering If <em>true</em> OJB's ordering algorithm is used.
133		*/
134		public void setOrdering(boolean ordering);
135
136		// /**
137		// * Returns whether or not the persistent method calls determine
138		// * the persistent object order on commit.
139		// *
140		// * @see #setNoteUserOrder(boolean)
141		// */
142		// public boolean isNoteUserOrder();
143		//
144		// /**
145		// * If <em>true</em> the order of persisting method calls like
146		// * <br/> - {@link org.odmg.Transaction#lock(Object, int)}).
147		// * <br/> - {@link org.odmg.Database#deletePersistent(Object)}).
148		// * <br/> - {@link org.odmg.Database#makePersistent(Object)})
149		// * determine the order of objects before commit.
150		// * <br/>
151		// * If <em>false</em> the ordering was determined by OJB's internal
152		// * method calls and user calls.
153		// * <br/>
154		// * However it's possible to set this value only for the current
155		// * used {@link org.odmg.Transaction} using {@link TransactionExt#setNoteUserOrder(boolean)}
156		// * <p/>
157		// * <strong>NOTE:</strong> If OJB's ordering algorithm (see
158		// * {@link #setOrdering(boolean)}) is enabled, the
159		// * order of objects may change on commit.
160		// *
161		// * @param noteUserOrder If <em>true</em> the order of persisting
162		// * method calls determine the order of objects.
163		// */
164		// public void setNoteUserOrder(boolean noteUserOrder);
165
166
167		// /**
168		// * Get object by OJB's {@link org.apache.ojb.broker.Identity}.
169		// *
170		// * @param id The identity of the object to look for.
171		// * @return The matching object or <em>null</em>.
172		// */
173		// public Object getObjectByIdentity(Identity id);
174
175		// /**
176		// * If set <em>true</em> the odmg implementation do it's best to find out the user intension, if set
177		// * <em>false</em> OJB use an optimized mode and the user has to adhere strictly the odmg-api:
178		// * <ul>
179		// * <li>
180		// * New objects can only be made persistent by using {@link org.odmg.Database#makePersistent(Object)}
181		// * </li>
182		// * <li>
183		// * Only persistent objects can be locked with {@link org.odmg.Transaction#lock(Object, int)}.
184		// * </li>
185		// * <li>
186		// * When deleting an object with {@link org.odmg.Database#deletePersistent(Object)} to reuse it
187		// * within a transaction a call to {@link org.odmg.Database#makePersistent(Object)} is needed and
188		// * field changes on objects marked as "deleted" are not allowed.
189		// * </li>
190		// * </ul>
191		// * When running odmg in <em>safe-mode</em> these restrictions are "softened" and it's e.g. possible
192		// * to persist new objects with {@link org.odmg.Transaction#lock(Object, int)}.
193		// * <p/>
194		// * The <em>optimized-mode</em> show a significant better performance, but needs strictness in using the API.
195		// *
196		// * @param safeMode Set <em>true</em> to enable the <em>safe-mode</em>, use <em>false</em> to enable
197		// * the <em>optimized-mode</em>.
198		// */
199		// void setSafeMode(boolean safeMode);
200		//
201		// /**
202		// * Returns <em>true</em> if this class use the safe-mode for
203		// * user interaction, else the optimized-mode is used.
204		// */
205		// boolean isSafeMode();
206		}