All Downloads are FREE. Search and download functionalities are using the official Maven repository.

oracle.toplink.essentials.descriptors.DescriptorEventManager Maven / Gradle / Ivy

There is a newer version: 2.1-60f
Show newest version
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * // Copyright (c) 1998, 2007, Oracle. All rights reserved.
 * 
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License. You can obtain
 * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
 * or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
 * Sun designates this particular file as subject to the "Classpath" exception
 * as provided by Sun in the GPL Version 2 section of the License file that
 * accompanied this code.  If applicable, add the following below the License
 * Header, with the fields enclosed by brackets [] replaced by your own
 * identifying information: "Portions Copyrighted [year]
 * [name of copyright owner]"
 * 
 * Contributor(s):
 * 
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */
package oracle.toplink.essentials.descriptors;

import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.*;
import java.lang.reflect.*;
import java.io.*;
import oracle.toplink.essentials.descriptors.DescriptorEventListener;
import oracle.toplink.essentials.descriptors.DescriptorEvent;
import oracle.toplink.essentials.internal.helper.*;
import oracle.toplink.essentials.exceptions.*;
import oracle.toplink.essentials.sessions.SessionProfiler;
import oracle.toplink.essentials.internal.security.PrivilegedAccessHelper;
import oracle.toplink.essentials.internal.security.PrivilegedMethodInvoker;
import oracle.toplink.essentials.internal.sessions.AbstractSession;

/**
 * 

Purpose: The event manager allows for a descriptor to specify that * an object should be notified when a TopLink event occurs. It also determines * how the object will be notified. To specify an event a method name can be * registered to be called on the object when the event occurs. Events can be * used to extend the TopLink reading and writing behavior. *

* These events include: *

    *
  • pre/postWrite - occurs when an object is written (occurs even if no changes to the object). *
  • pre/postInsert - occurs when an object is inserted. *
  • pre/postUpdate - occurs when an object is updated (occurs even if no changes to the object). *
  • pre/postDeleted - occurs when an object is deleted. *
  • postBuild/postRefresh - occurs after a object has been built/refreshed from its database row. *
  • aboutTo/Insert/Update - occurs when an object is about to be inserted/update allows for row modification. *
  • postClone - occurs when an object is registered/cloned in a unit of work. *
  • postMerge - occurs when an object is merged with its original in a unit of work. *
* * @see ClassDescriptor */ public class DescriptorEventManager implements Cloneable, Serializable { protected ClassDescriptor descriptor; protected Vector eventSelectors; protected transient Vector eventMethods; protected transient Vector eventListeners; // EJB 3.0 support for event listeners. protected transient Vector defaultEventListeners; protected transient Vector entityListenerEventListeners; protected transient DescriptorEventListener entityEventListener; // EJB 3.0 support - cache our parent event managers. protected transient Vector entityEventManagers; protected transient Vector entityListenerEventManagers; // EJB 3.0 support for event listener configuration flags. protected boolean excludeDefaultListeners; protected boolean excludeSuperclassListeners; /** PERF: Cache if any events listener exist. */ protected boolean hasAnyEventListeners; public static final int PreWriteEvent = 0; public static final int PostWriteEvent = 1; public static final int PreDeleteEvent = 2; public static final int PostDeleteEvent = 3; public static final int PreInsertEvent = 4; public static final int PostInsertEvent = 5; public static final int PreUpdateEvent = 6; public static final int PostUpdateEvent = 7; public static final int PostBuildEvent = 8; public static final int PostRefreshEvent = 9; public static final int PostCloneEvent = 10; public static final int PostMergeEvent = 11; public static final int AboutToInsertEvent = 12; public static final int AboutToUpdateEvent = 13; // CR#2660080 was missing aboutToDelete public static final int AboutToDeleteEvent = 14; // EJB 3.0 events public static final int PrePersistEvent = 15; public static final int PreRemoveEvent = 16; public static final int PreUpdateWithChangesEvent = 17; public static final int NumberOfEvents = 18; /** * INTERNAL: * Returns a new DescriptorEventManager for the specified Descriptor. */ public DescriptorEventManager() { this.eventSelectors = oracle.toplink.essentials.internal.helper.NonSynchronizedVector.newInstance(NumberOfEvents); this.eventMethods = oracle.toplink.essentials.internal.helper.NonSynchronizedVector.newInstance(NumberOfEvents); this.hasAnyEventListeners = false; this.excludeDefaultListeners = false; this.excludeSuperclassListeners = false; for (int index = 0; index < NumberOfEvents; index++) { this.eventSelectors.addElement(null); this.eventMethods.addElement(null); } } /** * PUBLIC: * EJB 3.0 support for default listeners. */ public void addDefaultEventListener(DescriptorEventListener listener) { getDefaultEventListeners().addElement(listener); } /** * PUBLIC: * EJB 3.0 support for lifecycle callback events defined on an entity * listener class. */ public void addEntityListenerEventListener(DescriptorEventListener listener) { getEntityListenerEventListeners().addElement(listener); } /** * PUBLIC: * Listener objects can be registered with the event manager to be notified * when an event occurs on any instance of the descriptor's class. */ public void addListener(DescriptorEventListener listener) { getEventListeners().addElement(listener); setHasAnyEventListeners(true); } /** * INTERNAL: * Clone the manager and its private parts. */ public Object clone() { DescriptorEventManager clone = null; try { clone = (DescriptorEventManager)super.clone(); clone.setEventSelectors((Vector)getEventSelectors().clone()); clone.setEventMethods((Vector)getEventMethods().clone()); clone.setEventListeners((Vector)getEventListeners()); } catch (Exception exception) { ; } return clone; } /** * INTERNAL: * EJB 3.0 support. Returns true if this event manager should exclude the * invocation of the default listeners for this descriptor. */ public boolean excludeDefaultListeners() { return excludeDefaultListeners; } /** * INTERNAL: * EJB 3.0 support. Returns true is this event manager should exclude the * invocation of the listeners defined by the entity listener classes for * the superclasses of this descriptor. */ public boolean excludeSuperclassListeners() { return excludeSuperclassListeners; } /** * INTERNAL: * Execute the given selector with the event as argument. * @exception DescriptorException - the method cannot be found or executed */ public void executeEvent(DescriptorEvent event) throws DescriptorException { try { event.getSession().startOperationProfile(SessionProfiler.DescriptorEvent); // CR#3467758, ensure the descriptor is set on the event. event.setDescriptor(getDescriptor()); notifyListeners(event); notifyEJB30Listeners(event); if (event.getSource() instanceof DescriptorEventListener) { // Allow the object itself to implement the interface. notifyListener((DescriptorEventListener)event.getSource(), event); return; } Method eventMethod = (Method)getEventMethods().elementAt(event.getEventCode()); if (eventMethod == null) { return; } // Now that I have the method, I need to invoke it try { Object[] runtimeParameters = new Object[1]; runtimeParameters[0] = event; if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){ try { AccessController.doPrivileged(new PrivilegedMethodInvoker(eventMethod, event.getSource(), runtimeParameters)); } catch (PrivilegedActionException exception) { Exception throwableException = exception.getException(); if (throwableException instanceof IllegalAccessException) { throw DescriptorException.illegalAccessWhileEventExecution(eventMethod.getName(), getDescriptor(), throwableException); } else { throw DescriptorException.targetInvocationWhileEventExecution(eventMethod.getName(), getDescriptor(), throwableException); } } } else { PrivilegedAccessHelper.invokeMethod(eventMethod, event.getSource(), runtimeParameters); } } catch (IllegalAccessException exception) { throw DescriptorException.illegalAccessWhileEventExecution(eventMethod.getName(), getDescriptor(), exception); } catch (IllegalArgumentException exception) { throw DescriptorException.illegalArgumentWhileObsoleteEventExecute(eventMethod.getName(), getDescriptor(), exception); } catch (InvocationTargetException exception) { throw DescriptorException.targetInvocationWhileEventExecution(eventMethod.getName(), getDescriptor(), exception); } } finally { event.getSession().endOperationProfile(SessionProfiler.DescriptorEvent); } } /** * Find the method corresponding to the event selector. The method MUST take * DescriptorEvent as argument, Session is also supported as argument for * backward compatibility. */ protected Method findMethod(int selector) throws DescriptorException { Class[] declarationParameters = new Class[1]; declarationParameters[0] = ClassConstants.DescriptorEvent_Class; String methodName = (String)getEventSelectors().elementAt(selector); try { return Helper.getDeclaredMethod(getDescriptor().getJavaClass(), methodName, declarationParameters); } catch (NoSuchMethodException exception) { throw DescriptorException.noSuchMethodOnFindObsoleteMethod(methodName, getDescriptor(), exception); } catch (SecurityException exception) { throw DescriptorException.securityOnFindMethod(methodName, getDescriptor(), exception); } } /** * INTERNAL: */ public String getAboutToInsertSelector() { return (String)getEventSelectors().elementAt(AboutToInsertEvent); } /** * INTERNAL: */ public String getAboutToUpdateSelector() { return (String)getEventSelectors().elementAt(AboutToUpdateEvent); } /** * INTERNAL: * EJB 3.0 support. Returns the default listeners. */ public Vector getDefaultEventListeners() { if (defaultEventListeners == null) { defaultEventListeners = new Vector(); } return defaultEventListeners; } /** * INTERNAL: */ protected ClassDescriptor getDescriptor() { return descriptor; } /** * INTERNAL: * EJB 3.0 support. Returns the entity event listener. */ public DescriptorEventListener getEntityEventListener() { return entityEventListener; } /** * INTERNAL: * EJB 3.0 support. Returns the entity listener event listeners. */ public Vector getEntityListenerEventListeners() { if (entityListenerEventListeners == null) { entityListenerEventListeners = new Vector(); } return entityListenerEventListeners; } /** * PUBLIC: * Returns the Listener objects that have been added. * * @see #addListener(DescriptorEventListener) */ public Vector getEventListeners() { // Lazy initialize to avoid unessisary enumerations. if (eventListeners == null) { eventListeners = oracle.toplink.essentials.internal.helper.NonSynchronizedVector.newInstance(1); } return eventListeners; } protected Vector getEventMethods() { //Lazy Initialized to prevent Null Pointer exception after serialization if (this.eventMethods == null) { this.eventMethods = oracle.toplink.essentials.internal.helper.NonSynchronizedVector.newInstance(NumberOfEvents); for (int index = 0; index < NumberOfEvents; ++index) { this.eventMethods.addElement(null); } } return eventMethods; } protected Vector getEventSelectors() { if (this.eventSelectors == null) { this.eventSelectors = oracle.toplink.essentials.internal.helper.NonSynchronizedVector.newInstance(NumberOfEvents); for (int index = 0; index < NumberOfEvents; ++index) { this.eventSelectors.addElement(null); } } return eventSelectors; } /** * PUBLIC: * The name of the method called after an object is built */ public String getPostBuildSelector() { return (String)getEventSelectors().elementAt(PostBuildEvent); } /** * PUBLIC: * The name of the method called after an object is cloned */ public String getPostCloneSelector() { return (String)getEventSelectors().elementAt(PostCloneEvent); } /** * PUBLIC: * The name of the method called after an object is deleted */ public String getPostDeleteSelector() { return (String)getEventSelectors().elementAt(PostDeleteEvent); } /** * PUBLIC: * The name of the method called after an object is inserted */ public String getPostInsertSelector() { return (String)getEventSelectors().elementAt(PostInsertEvent); } /** * PUBLIC: * The name of the method called after an object is merged */ public String getPostMergeSelector() { return (String)getEventSelectors().elementAt(PostMergeEvent); } /** * PUBLIC: * The name of the method called after an object is refreshed */ public String getPostRefreshSelector() { return (String)getEventSelectors().elementAt(PostRefreshEvent); } /** * PUBLIC: * The name of the method called after an object is updated */ public String getPostUpdateSelector() { return (String)getEventSelectors().elementAt(PostUpdateEvent); } /** * PUBLIC: * The name of the method called after an object is written */ public String getPostWriteSelector() { return (String)getEventSelectors().elementAt(PostWriteEvent); } /** * PUBLIC: * The name of the method called before the create operation is applied to * an object */ public String getPrePersistSelector() { return (String)getEventSelectors().elementAt(PrePersistEvent); } /** * PUBLIC: * The name of the method called before an object is deleted */ public String getPreDeleteSelector() { return (String)getEventSelectors().elementAt(PreDeleteEvent); } /** * PUBLIC: * The name of the method called before an object is inserted */ public String getPreInsertSelector() { return (String)getEventSelectors().elementAt(PreInsertEvent); } /** * PUBLIC: * The name of the method called before the remove operation is applied to * an object */ public String getPreRemoveSelector() { return (String)getEventSelectors().elementAt(PreRemoveEvent); } /** * PUBLIC: * The name of the method called before an object is updated */ public String getPreUpdateSelector() { return (String)getEventSelectors().elementAt(PreUpdateEvent); } /** * PUBLIC: * The name of the method called before an object is written */ public String getPreWriteSelector() { return (String)getEventSelectors().elementAt(PreWriteEvent); } /** * INTERNAL: * Return if the event manager has any event listeners, or event methods. * If nothing is listening to event they can be avoided. */ public boolean hasAnyEventListeners() { // Check listeners in case of collection added to directly as occurs // for aggregates that have a clone of the event manager but not the // listeners. return hasAnyEventListeners || hasAnyListeners() || hasEntityEventListener() || hasEntityListenerEventListeners(); } protected boolean hasAnyListeners() { return (eventListeners != null) && (!eventListeners.isEmpty()); } /** * INTERNAL: * EJB 3.0 support. Return true if this event manager has any entity event * listeners. */ public boolean hasEntityEventListener() { return entityEventListener != null; } /** * INTERNAL: * EJB 3.0 support. Return true if this event manager has any entity * listener event listeners. */ public boolean hasEntityListenerEventListeners() { return entityListenerEventListeners != null && entityListenerEventListeners.size() > 0; } /** * INTERNAL: * Configure inherited selectors. */ public void initialize(AbstractSession session) { // Initialize the EJB 3.0 supported listeners. initializeEJB30EventManagers(); // Initialize if events are required at all. if (hasAnyListeners() || DescriptorEventListener.class.isAssignableFrom(getDescriptor().getJavaClass())) { setHasAnyEventListeners(true); } for (int index = 0; index < NumberOfEvents; index++) { if (getEventSelectors().elementAt(index) != null) { setHasAnyEventListeners(true); getEventMethods().setElementAt(findMethod(index), index); } } // Inherit all parent defined event method // Do NOT inherit the listener as the events are broadcast to the parent. if (getDescriptor().isChildDescriptor()) { DescriptorEventManager parentEventManager = getDescriptor().getInheritancePolicy().getParentDescriptor().getEventManager(); for (int index = 0; index < NumberOfEvents; index++) { if (getEventSelectors().elementAt(index) == null) { setHasAnyEventListeners(true); getEventSelectors().setElementAt(parentEventManager.getEventSelectors().elementAt(index), index); getEventMethods().setElementAt(parentEventManager.getEventMethods().elementAt(index), index); } } } } /** * INTERNAL: * EJB 3.0 support. Builds our chains of descriptor event managers that will * need to be notified. The chains are cache so we only need to build them * once. */ protected void initializeEJB30EventManagers() { entityEventManagers = new Vector(); entityListenerEventManagers = new Vector(); if (hasEntityEventListener()) { entityEventManagers.add(this); } if (hasEntityListenerEventListeners()) { entityListenerEventManagers.add(this); } ClassDescriptor currentDescriptor = getDescriptor(); boolean excludeEntityListeners = excludeSuperclassListeners(); while (currentDescriptor.isChildDescriptor()) { currentDescriptor = currentDescriptor.getInheritancePolicy().getParentDescriptor(); DescriptorEventManager eventManager = currentDescriptor.getEventManager(); if (eventManager.hasEntityEventListener()) { entityEventManagers.add(eventManager); } if (eventManager.hasEntityListenerEventListeners()) { if (!excludeEntityListeners) { entityListenerEventManagers.add(eventManager); } } excludeEntityListeners = eventManager.excludeSuperclassListeners(); } } /** * INTERNAL: * Notify the EJB 3.0 event listeners. */ protected void notifyEJB30Listeners(DescriptorEvent event) { // Step 1 - notify our default listeners. if (! excludeDefaultListeners()) { for (int i = 0; i < getDefaultEventListeners().size(); i++) { DescriptorEventListener listener = (DescriptorEventListener) getDefaultEventListeners().get(i); notifyListener(listener, event); } } // Step 2 - Notify the Entity Listener's first, top -> down. for (int index = entityListenerEventManagers.size() - 1; index >= 0; index--) { Vector entityListenerEventListeners = ((DescriptorEventManager) entityListenerEventManagers.get(index)).getEntityListenerEventListeners(); for (int i = 0; i < entityListenerEventListeners.size(); i++) { DescriptorEventListener listener = (DescriptorEventListener) entityListenerEventListeners.get(i); notifyListener(listener, event); } } // Step 3 - Notify the Entity event listeners. top -> down, unless // they are overriden in a subclass. for (int index = entityEventManagers.size() - 1; index >= 0; index--) { DescriptorEventListener entityEventListener = ((DescriptorEventManager) entityEventManagers.get(index)).getEntityEventListener(); if (! entityEventListener.isOverriddenEvent(event, entityEventManagers)) { notifyListener(entityEventListener, event); } } } /** * INTERNAL: * Big ugly case statement to notify listeners. */ protected void notifyListener(DescriptorEventListener listener, DescriptorEvent event) throws DescriptorException { switch (event.getEventCode()) { case PreWriteEvent: listener.preWrite(event); break; case PostWriteEvent: listener.postWrite(event); break; case PreDeleteEvent: listener.preDelete(event); break; case PostDeleteEvent: listener.postDelete(event); break; case PreInsertEvent: listener.preInsert(event); break; case PostInsertEvent: listener.postInsert(event); break; case PreUpdateEvent: listener.preUpdate(event); break; case PostUpdateEvent: listener.postUpdate(event); break; case PostMergeEvent: listener.postMerge(event); break; case PostCloneEvent: listener.postClone(event); break; case PostBuildEvent: listener.postBuild(event); break; case PostRefreshEvent: listener.postRefresh(event); break; case AboutToInsertEvent: listener.aboutToInsert(event); break; case AboutToUpdateEvent: listener.aboutToUpdate(event); break; case AboutToDeleteEvent: listener.aboutToDelete(event); break; case PrePersistEvent: listener.prePersist(event); break; case PreRemoveEvent: listener.preRemove(event); break; case PreUpdateWithChangesEvent: listener.preUpdateWithChanges(event); break; default: throw DescriptorException.invalidDescriptorEventCode(event, getDescriptor()); } } /** * INTERNAL: * Notify the event listeners. */ public void notifyListeners(DescriptorEvent event) { if (hasAnyListeners()) { for (int index = 0; index < getEventListeners().size(); index++) { DescriptorEventListener listener = (DescriptorEventListener)getEventListeners().get(index); notifyListener(listener, event); } } // Also must notify any inherited listeners. if (getDescriptor().isChildDescriptor()) { getDescriptor().getInheritancePolicy().getParentDescriptor().getEventManager().notifyListeners(event); } } /** * INTERNAL: * Used to initialize a remote DescriptorEventManager. */ public void remoteInitialization(AbstractSession session) { this.eventMethods = new Vector(NumberOfEvents); for (int index = 0; index < NumberOfEvents; index++) { this.eventMethods.addElement(null); } initialize(session); } /** * PUBLIC: * Remove a event listener. */ public void removeListener(DescriptorEventListener listener) { getEventListeners().removeElement(listener); } /** * PUBLIC: * A method can be registered to be called when an object's row it about to * be inserted. This uses the optional event argument of the DatabaseRow. * This is different from pre/postInsert because it occurs after the row has * already been built. This event can be used to modify the row before * insert, such as adding a user inserted by. */ public void setAboutToInsertSelector(String aboutToInsertSelector) { getEventSelectors().setElementAt(aboutToInsertSelector, AboutToInsertEvent); } /** * PUBLIC: * A method can be registered to be called when an object's row it about to * be updated. This uses the optional event argument of the DatabaseRow. * This is different from pre/postUpdate because it occurs after the row has * already been built, and it ONLY called if the update is required (changed * within a unit of work), as the other occur ALWAYS. This event can be used * to modify the row before insert, such as adding a user inserted by. */ public void setAboutToUpdateSelector(String aboutToUpdateSelector) { getEventSelectors().setElementAt(aboutToUpdateSelector, AboutToUpdateEvent); } /** * INTERNAL: * Set the descriptor. */ public void setDescriptor(ClassDescriptor descriptor) { this.descriptor = descriptor; } /** * PUBLIC: * EJB 3.0 support for lifecycle callback events defined on an entity class. */ public void setEntityEventListener(DescriptorEventListener listener) { this.entityEventListener = listener; } protected void setEventListeners(Vector eventListeners) { this.eventListeners = eventListeners; } protected void setEventMethods(Vector eventMethods) { this.eventMethods = eventMethods; } protected void setEventSelectors(Vector eventSelectors) { this.eventSelectors = eventSelectors; } /** * INTERNAL: * EJB 3.0 support. Default listeners apply to all entities in a persistence * unit. Set this flag to true to exclude the invocation of the default * listeners for this descriptor. */ public void setExcludeDefaultListeners(boolean excludeDefaultListeners) { this.excludeDefaultListeners = excludeDefaultListeners; } /** * INTERNAL: * EJB 3.0 support. If multiple entity classes in an inheritance hierarchy * define entity listeners, the listeners defined for a superclass are * invoked before the listeners defined for its subclasses. Set this flag * to true to exclude the invocation of the listeners defined by the entity * listener classes for the superclasses of this descriptor. */ public void setExcludeSuperclassListeners(boolean excludeSuperclassListeners) { this.excludeSuperclassListeners = excludeSuperclassListeners; } /** * INTERNAL: * Set if the event manager has any event listeners, or event methods. * If nothing is listening to event they can be avoided. */ protected void setHasAnyEventListeners(boolean hasAnyEventListeners) { this.hasAnyEventListeners = hasAnyEventListeners; } /** * PUBLIC: * A method can be registered to be called on a object that has just been * built from the database. This uses the optional event argument of the * DatabaseRow. This event can be used to correctly initialize an object's * non-persistent attributes or to perform complex optimizations or * mappings. This event is called whenever an object is built. */ public void setPostBuildSelector(String postBuildSelector) { getEventSelectors().setElementAt(postBuildSelector, PostBuildEvent); } /** * PUBLIC: * A method can be registered to be called on a object that has just been * cloned into a unit of work. This uses the optional event argument of the * orignial object (the source object it the clone). This event can be used * to correctly initialize an object's non-persistent attributes. */ public void setPostCloneSelector(String postCloneSelector) { getEventSelectors().setElementAt(postCloneSelector, PostCloneEvent); } /** * PUBLIC: * A method can be registered to be called on a object that has just been * deleted from the database. This event can notify/remove any dependents * on the object. */ public void setPostDeleteSelector(String postDeleteSelector) { getEventSelectors().setElementAt(postDeleteSelector, PostDeleteEvent); } /** * PUBLIC: * A method can be registered to be called on a object that has just been * inserted into the database. This event can be used to notify any * dependent on the object, or to update information not accessible until * the object has been inserted. */ public void setPostInsertSelector(String postInsertSelector) { getEventSelectors().setElementAt(postInsertSelector, PostInsertEvent); } /** * PUBLIC: * A method can be registered to be called on a object that has just been * merge from a unit of work. This uses the optional event argument of the * orignial object which is the object being merged from, the source object * is the object being merged into. This event can be used to correctly * initialize an object's non-persistent attributes. */ public void setPostMergeSelector(String postMergeSelector) { getEventSelectors().setElementAt(postMergeSelector, PostMergeEvent); } /** * PUBLIC: * A method can be registered to be called on a object that has just been * refreshed from the database. This uses the optional event argument of * the DatabaseRow. This event can be used to correctly initialize an * object's non-persistent attributes or to perform complex optimizations or * mappings. This event is only called on refreshes of existing objects. */ public void setPostRefreshSelector(String postRefreshSelector) { getEventSelectors().setElementAt(postRefreshSelector, PostRefreshEvent); } /** * PUBLIC: * A method can be registered to be called on a object that has just been * updated into the database. */ public void setPostUpdateSelector(String postUpdateSelector) { getEventSelectors().setElementAt(postUpdateSelector, PostUpdateEvent); } /** * PUBLIC: * A method can be registered to be called on a object that has just been * written to the database. This event is raised on any registered object * in a unit of work, even if it has not changed, refer to the * "aboutToUpdate" selector if it is required for the event to be raised * only when the object has been changed. This will be called on all inserts * and updates, after the "postInsert/Update" event has been raised. This * event can be used to notify any dependent on the object. */ public void setPostWriteSelector(String postWriteSelector) { getEventSelectors().setElementAt(postWriteSelector, PostWriteEvent); } /** * PUBLIC: * A method can be registered to be called on a object that is going to be * deleted from the database. This event can notify/remove any dependents * on the object. */ public void setPreDeleteSelector(String preDeleteSelector) { getEventSelectors().setElementAt(preDeleteSelector, PreDeleteEvent); } /** * PUBLIC: * A method can be registered to be called on a object that is going to be * inserted into the database. This event can be used to notify any * dependent on the object or acquire the object's id through a custom * mechanism. */ public void setPreInsertSelector(String preInsertSelector) { getEventSelectors().setElementAt(preInsertSelector, PreInsertEvent); } /** * PUBLIC: * A method can be registered to be called on a object when that object has * the create operation applied to it. */ public void setPrePersistSelector(String prePersistSelector) { getEventSelectors().setElementAt(prePersistSelector, PrePersistEvent); } /** * PUBLIC: * A method can be registered to be called on a object when that object has * the remove operation applied to it. */ public void setPreRemoveSelector(String preRemoveSelector) { getEventSelectors().setElementAt(preRemoveSelector, PreRemoveEvent); } /** * PUBLIC: * A method can be registered to be called on a object that is going to be * updated into the database. This event is raised on any registered object * in a unit of work, even if it has not changed, refer to the * "aboutToUpdate" selector if it is required for the event to be raised * only when the object has been changed. This event can be used to notify * any dependent on the object. */ public void setPreUpdateSelector(String preUpdateSelector) { getEventSelectors().setElementAt(preUpdateSelector, PreUpdateEvent); } /** * PUBLIC: * A method can be registered to be called on a object that is going to be * written to the database. This event is raised on any registered object * in a unit of work, even if it has not changed, refer to the * "aboutToUpdate" selector if it is required for the event to be raised * only when the object has been changed. This will be called on all inserts * and updates, before the "preInsert/Update" event has been raised. This * event can be used to notify any dependent on the object. */ public void setPreWriteSelector(String preWriteSelector) { getEventSelectors().setElementAt(preWriteSelector, PreWriteEvent); } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy