EventMapping (Oracle Fusion Middleware Java API Reference for Oracle ADF Model)

java.lang.Object
- oracle.jbo.server.EventMapping

All Implemented Interfaces:: DiffMergeable, DefPersistable, PersistentDefinition

public class EventMapping
extends java.lang.Object
implements DefPersistable, DiffMergeable

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class EventMapping.EventPointType

Nested Classes
Modifier and Type	Class and Description
`static class`	`EventMapping.EventPointType`

Field Summary
- Fields inherited from interface oracle.jbo.mom.xml.DefPersistable
  XML_STATEMENT

Constructor Summary

Constructors
Constructor and Description

EventMapping()

EventMapping(java.lang.String eventName, EventMapping.EventPointType type)

Constructors
Constructor and Description
`EventMapping()`
`EventMapping(java.lang.String eventName, EventMapping.EventPointType type)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RaiseCondition`	`addRaiseCondition()`
`void`	`applyDiffChildren(DifferDetails dif, DiffResolver resolver)` Applies changes to children defs.
`void`	`applyDiffContents(DifferDetails dif, DiffResolver resolver)` When diff/merge operation is requested, we have the following three def objects:
`DifferDetails`	`beginDiffObjects(DiffMergeable docDef, DiffMergeable orgDef, DifferDetails difDetails)` This method is the entry point call when the diffing process begins on the document-level def.
`java.lang.Object`	`clone()`
`DifferDetails`	`diffChildren(DiffMergeable docDef, DiffMergeable orgDef, DifferDetails difDetails)` Performs diff of children defs.
`DifferDetails`	`diffContents(DiffMergeable docDef, DiffMergeable orgDef, DifferDetails difDetails)` Performs diff of scalar values.
`DifferDetails`	`diffObjects(DiffMergeable docDef, DiffMergeable orgDef, DifferDetails difDetails)` The work-horse method performing diff between two defs of this def type.
`DifferDetails`	`ensureDifferDetails(DifferDetails difDetails)` Ensures that we have a valid `DifferDetails`.
`java.lang.String`	`getDefTypeName()` Returns the XML def type name of this defintion object, e.g., "PDefEntityObject".
`java.lang.String`	`getDefXMLElementTag()`
`java.lang.String`	`getDefXMLNameSpace()`
`java.lang.String`	`getEventName()` Gets the name of the event specified in the mapping.
`java.lang.String`	`getFullName()` This method returns the Persistence reference of the object.
`java.lang.String`	`getMergeableFullName()` Returns the fully qualified name of the diff-mergeable definition object.
`java.lang.String`	`getMergeableName()` Returns the diff-mergeable definition's name (short form).
`java.lang.String`	`getName()`
`DefPersistable`	`getOrigObject()`
`java.util.Iterator<RaiseCondition>`	`getRaiseConditions()` Gets the list of raise conditions for the event mapping.
`EventMapping.EventPointType`	`getType()`
`static EventMapping.EventPointType`	`getTypeValue(java.lang.String str)`
`java.lang.String`	`getXMLElementTag()` Returns a piece of static info for the type of object this is invoked upon.
`boolean`	`isDirty()` This method returns if an Object is modified from last save/load
`boolean`	`isDisabled()`
`boolean`	`isForPersonalization()`
`boolean`	`isNew()` This method returns if this object is previously persisted.
`void`	`setDirty(boolean b)` This method marks the Object dirty
`void`	`setDisabled(boolean disabled)`
`void`	`setEventName(java.lang.String eventName)`
`void`	`setForPersonalization(boolean b)`
`void`	`setNew(boolean b)` This method marks the as previously persisted.
`void`	`setOrigObject(DefPersistable oldObj)`
`void`	`setType(EventMapping.EventPointType type)`
`void`	`writeChildren(DefWriter jos)` Writes the Object's children to the Persistent storage
`void`	`writeContents(DefWriter jos)` Objects should write their persistence output in this method
`void`	`writeObject(DefWriter jos)` Objects should write their persistence output in this method

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - EventMapping
```
public EventMapping()
```
  - EventMapping
```
public EventMapping(java.lang.String eventName,
                    EventMapping.EventPointType type)
```
- Method Detail
  - getTypeValue
```
public static EventMapping.EventPointType getTypeValue(java.lang.String str)
```
  - getEventName
```
public java.lang.String getEventName()
```
    Gets the name of the event specified in the mapping. It references the name of an event definition that will be fired on the event point that the mapping is defined for.
    
    Returns:
    
    the name of the event specified in the mapping.
  - setEventName
```
public void setEventName(java.lang.String eventName)
```
  - getType
```
public EventMapping.EventPointType getType()
```
  - setType
```
public void setType(EventMapping.EventPointType type)
```
  - getRaiseConditions
```
public java.util.Iterator<RaiseCondition> getRaiseConditions()
```
    Gets the list of raise conditions for the event mapping. Raise conditions indicate that the referenced event should only be raised on the event point when one or more of the raise conditions are met. This is used to say, for instance, that an event should only be rased on on update when a particular attribute is changed to a particular value.
    
    Returns:
    
    the list of raise conditions for the event mapping.
  - isForPersonalization
```
public boolean isForPersonalization()
```
  - setForPersonalization
```
public void setForPersonalization(boolean b)
```
  - setDisabled
```
public void setDisabled(boolean disabled)
```
  - isDisabled
```
public boolean isDisabled()
```
  - clone
```
public java.lang.Object clone()
```
    Overrides:
    
    clone in class java.lang.Object
  - addRaiseCondition
```
public RaiseCondition addRaiseCondition()
```
  - isDirty
```
public boolean isDirty()
```
    Description copied from interface: DefPersistable
    
    This method returns if an Object is modified from last save/load
    
    Specified by:
    
    isDirty in interface DefPersistable
    
    Returns:
    
    Returns true if the Object is dirty. Returns false otherwise.
  - setDirty
```
public void setDirty(boolean b)
```
    Description copied from interface: DefPersistable
    
    This method marks the Object dirty
    
    Specified by:
    
    setDirty in interface DefPersistable
    
    Parameters:
    
    b - If true the Object is marked Dirty.
  - setOrigObject
```
public void setOrigObject(DefPersistable oldObj)
```
    Specified by:
    
    setOrigObject in interface DefPersistable
  - getOrigObject
```
public DefPersistable getOrigObject()
```
    Specified by:
    
    getOrigObject in interface DefPersistable
  - getFullName
```
public java.lang.String getFullName()
```
    Description copied from interface: DefPersistable
    
    This method returns the Persistence reference of the object. The Persistence Reference is uniquely identifiable fully qualified name of the object.
    
    Specified by:
    
    getFullName in interface DefPersistable
    
    Returns:
    
    the Persistence Reference of the object
  - getName
```
public java.lang.String getName()
```
  - getMergeableName
```
public java.lang.String getMergeableName()
```
    Description copied from interface: DiffMergeable
    
    Returns the diff-mergeable definition's name (short form).
    
    Specified by:
    
    getMergeableName in interface DiffMergeable
    
    Returns:
    
    name of the def object
  - getMergeableFullName
```
public java.lang.String getMergeableFullName()
```
    Description copied from interface: DiffMergeable
    
    Returns the fully qualified name of the diff-mergeable definition object. It must uniquely identify the def object.
    
    Specified by:
    
    getMergeableFullName in interface DiffMergeable
    
    Returns:
    
    full name of the def object
  - isNew
```
public boolean isNew()
```
    Description copied from interface: DefPersistable
    
    This method returns if this object is previously persisted.
    
    Specified by:
    
    isNew in interface DefPersistable
    
    Returns:
    
    true if the Object is previously persisted. Returns false otherwise.
  - setNew
```
public void setNew(boolean b)
```
    Description copied from interface: DefPersistable
    
    This method marks the as previously persisted. By default all objects are new objects. When the object is persisted first time, that object is marked as 'not new' object
    
    Specified by:
    
    setNew in interface DefPersistable
    
    Parameters:
    
    b - If true the Object is marked as new object.
  - getDefXMLNameSpace
```
public java.lang.String getDefXMLNameSpace()
```
    Specified by:
    
    getDefXMLNameSpace in interface PersistentDefinition
  - getDefXMLElementTag
```
public java.lang.String getDefXMLElementTag()
```
    Specified by:
    
    getDefXMLElementTag in interface PersistentDefinition
  - getDefTypeName
```
public java.lang.String getDefTypeName()
```
    Description copied from interface: DiffMergeable
    
    Returns the XML def type name of this defintion object, e.g., "PDefEntityObject".
    
    Specified by:
    
    getDefTypeName in interface DiffMergeable
    
    Returns:
    
    XML def type name
  - getXMLElementTag
```
public java.lang.String getXMLElementTag()
```
    Description copied from interface: PersistentDefinition
    
    Returns a piece of static info for the type of object this is invoked upon. Examples are PreparedStatements for insert, update, delete, and String containing a base the select statement for retrieving instances of this type through the SQLInputStream
    
    Specified by:
    
    getXMLElementTag in interface PersistentDefinition
    
    Returns:
    
    returns the Statement required to store in Persitent Storage. Incase of XML, it just returns the String. In the case of SQL a JDBC PreparedStatement is returned.
  - writeChildren
```
public void writeChildren(DefWriter jos)
```
    Description copied from interface: PersistentDefinition
    
    Writes the Object's children to the Persistent storage
    
    Specified by:
    
    writeChildren in interface PersistentDefinition
    
    Parameters:
    
    jos - the Output storage for persistence
  - writeContents
```
public void writeContents(DefWriter jos)
```
    Description copied from interface: PersistentDefinition
    
    Objects should write their persistence output in this method
    
    Specified by:
    
    writeContents in interface PersistentDefinition
    
    Parameters:
    
    jos - the Output storage for persistence
  - writeObject
```
public void writeObject(DefWriter jos)
```
    Description copied from interface: PersistentDefinition
    
    Objects should write their persistence output in this method
    
    Specified by:
    
    writeObject in interface PersistentDefinition
    
    Parameters:
    
    jos - the Output storage for persistence
  - ensureDifferDetails
```
public DifferDetails ensureDifferDetails(DifferDetails difDetails)
```
    Description copied from interface: DiffMergeable
    Ensures that we have a valid DifferDetails.
    This method is to create a DifferDetails object to be used for diffing if necessary. The difDetails may come in as null. By calling this method, we can ensure that a non-null difDetails is there. So, instead of writing:
```
    if (difDetails == null)
    {
       difDetails = new DifferDetails(..);
    }
    difDetails.addDiffDetail(..);
 
```
    we can write
```
    (difDetails = diffMergeable.ensureDifferDetails(difDetails)).addDiffDetail(..);
 
```
    Specified by:
    
    ensureDifferDetails in interface DiffMergeable
    
    Parameters:
    
    difDetails - the incoming DifferDetails. It may be null.
    
    Returns:
    
    the same difDetails if it wasn't null coming in, or a new DifferDetails if the incoming difDetails was null
  - diffContents
```
public DifferDetails diffContents(DiffMergeable docDef,
                                  DiffMergeable orgDef,
                                  DifferDetails difDetails)
```
    Description copied from interface: DiffMergeable
    Performs diff of scalar values. Typically, scalar attr values are grouped into String, int, and boolean arrays -- one set coming from 'this' definition and the other set coming from orgDef. Then, help methods on DifferBase can be used to diff the attr values and accumulate the details of diff in difDetails.
    Here is example code snippet:
```
    private static final String DIFF_STRING_ELEMS[] =
    {
       "MyStringVal1",
       "MyStringVal2"
    };

    private static final String DIFF_INT_ELEMS[] =
    {
       "MyIntVal",
    }

    public DifferDetails diffContents(DiffMergeable docDef, DiffMergeable orgDef, DifferDetails difDetails)
    {
        orgDefImpl = () orgDef;

       final String editStringValues[] =
       {
          this.getMyStringVal1(),
          this.getMyStringVal2()
       };

       String orgStringValues[] = null;

       if (orgDef != null)
       {
          String orgV[] =
          {
             orgDefImpl.getMyStringVal1(),
             orgDefImpl.getMyStringVal2()
          };

          orgStringValues = orgV;
       }

       final int editIntValues[] =
       {
          this.getMyIntVal(),
       };

       int orgIntValues[] = null;

       if (orgDef != null)
       {
          int orgV[] =
          {
             orgDefImpl.getMyIntVal()
          };

          orgIntValues = orgV;
       }

       difDetails = DifferBase.diffStringArray(this, DIFF_STRING_ELEMS, editStringValues, orgStringValues, difDetails);
       difDetails = DifferBase.diffIntArray(this, DIFF_INT_ELEMS, editIntValues, orgIntValues, difDetails);

       return difDetails;
   }
 
```
    Specified by:
    
    diffContents in interface DiffMergeable
    
    Parameters:
    
    docDef - the document-level definition
    
    orgDef - the original definition. It could be null if the definition did not exist originally
    
    difDetails - the DifferDetails that accumulate the details of diff from the document-level (top-level) def
    
    Returns:
    
    the DifferDetails that has all the details of diff
  - diffChildren
```
public DifferDetails diffChildren(DiffMergeable docDef,
                                  DiffMergeable orgDef,
                                  DifferDetails difDetails)
```
    Description copied from interface: DiffMergeable
    Performs diff of children defs. This def should enumerate through all its children and diff them and accumulate details of diff into difDetails and return it at the end.
    For example, if this def has Child1 and Child2, its implementation should look something like:
```
    public DifferDetails diffChildren(DiffMergeable docDef, DiffMergeable orgDef, DifferDetails difDetails)
    {
       difDetails = diffChildrenChild1(docDef, orgDef, difDetails);
       difDetails = diffChildrenChild1(docDef, orgDef, difDetails);

       return difDetails;
    }
 
```
    where diffChildrenChild1() uses DifferChildren's helper method diffChildrenList to diff the child defs.
    Specified by:
    
    diffChildren in interface DiffMergeable
    
    Parameters:
    
    docDef - the document-level definition
    
    orgDef - the original definition. It could be null if the definition did not exist originally
    
    difDetails - the DifferDetails that accumulate the details of diff from the document-level (top-level) def
    
    Returns:
    
    the DifferDetails that has all the details of diff
  - beginDiffObjects
```
public DifferDetails beginDiffObjects(DiffMergeable docDef,
                                      DiffMergeable orgDef,
                                      DifferDetails difDetails)
```
    Description copied from interface: DiffMergeable
    
    This method is the entry point call when the diffing process begins on the document-level def. This document-level def may perform its setup or preparation operations and then traverse into nested (children) DiffMergeable's. 'this' object is the changed definition.
    
    Specified by:
    
    beginDiffObjects in interface DiffMergeable
    
    Parameters:
    
    docDef - the document-level definition
    
    orgDef - the original definition. It could be null if the definition did not exist originally
    
    difDetails - the DifferDetails that accumulate the details of diff from the document-level (top-level) def
    
    Returns:
    
    the DifferDetails that has all the details of diff
  - diffObjects
```
public DifferDetails diffObjects(DiffMergeable docDef,
                                 DiffMergeable orgDef,
                                 DifferDetails difDetails)
```
    Description copied from interface: DiffMergeable
    
    The work-horse method performing diff between two defs of this def type. Most typically, it will call diffContents to diff scalar values and diffChildren to diff children objects. The children objects themselves are expected to be DiffMergeable. 'this' object is the changed definition.
    
    Specified by:
    
    diffObjects in interface DiffMergeable
    
    Parameters:
    
    docDef - the document-level definition
    
    orgDef - the original definition. It could be null if the definition did not exist originally
    
    difDetails - the DifferDetails that accumulate the details of diff from the document-level (top-level) def
    
    Returns:
    
    the DifferDetails that has all the details of diff
  - applyDiffContents
```
public void applyDiffContents(DifferDetails dif,
                              DiffResolver resolver)
```
    Description copied from interface: DiffMergeable
    When diff/merge operation is requested, we have the following three def objects:
    orgDef - original def object (from the branch point) editDef - def object into which changes are to be merge toMergeDef - def object to be merged (source of changes) For sandbox refresh operation, orgDef comes from the branch point, editDef from the sandbox, toMergeDef from the mainline of the repos. With these three defs, we first diff editDef against orgDef, producing editDifDetails.
    Similarly, toMergeDef is diffed against orgDef, producing toMergeDifDetails. The diff engine then walks through these two sets of diffs and identifies conflicts. After the conflicts are all resolved, we apply appropriate changes to editDef.
    applyDiffContents is called to apply changes to scalar values. dif contains the changed values to be applied to 'this' object. Use sample code like the following:
```
    public void applyDiffContents(DifferDetails dif, DiffResolver resolver)
    {
       DifferChangeMap detailMap = dif.getDetailMap();
       Object[] updValues;

       // DIFF_STRING_ELEMS from the above example code
       for (int j = 0; j < DIFF_STRING_ELEMS.length; j++)
       {
          if ((updValues = (Object[]) detailMap.getValue(DIFF_STRING_ELEMS[j])) != null)
          {
             switch(j)
             {
             case 0:
                setMyStringVal1((String) updValues[0]);
                break;
             case 1:
                 setMyStringVal2((String) updValues[0]);
                break;
             }
          }
       }

       for (int j = 0; j < DIFF_INT_ELEMS.length; j++)
       {
          if ((updValues = (Object[]) detailMap.getValue(DIFF_INT_ELEMS[j])) != null)
          {
             switch(j)
             {
             case 0:
                setMyIntVal((Integer) updValues[0]);
                break;
             }
          }
       }
    }
 
```
    Notice that the index specified in the case statement is the array index of the attr in the String, int, or boolean array.
    Specified by:
    
    applyDiffContents in interface DiffMergeable
    
    Parameters:
    
    dif - changes to be applied to 'this' def
    
    resolver - the diff resolver used in diff/merge operation
  - applyDiffChildren
```
public void applyDiffChildren(DifferDetails dif,
                              DiffResolver resolver)
```
    Description copied from interface: DiffMergeable
    Applies changes to children defs. dif contains the changes to be applied to the children. For each child def, this method should first retrieve the diff details for the child, which is of type DifferChildren. Then, it should call DifferChildren.applyDiffChanges(oracle.jbo.mom.DiffChildrenMerge, oracle.jbo.mom.DiffResolver) to perform the change operation.
    applyChanges() requires a DiffChildrenMerge object, which has the insert, update, and remove methods. 'this' def object must provide implmementation of these operations.
    Here is a sample:
```
    public void applyDiffChildren(DifferDetails dif, DiffResolver resolver)
    {
       DifferChangeMap detailMap = dif.getDetailMap();

       if (detailMap != null)
       {
          DifferChildren difChild1 = (DifferChildren) detailMap.getValue();

          if (difVCs != null)
          {
             DiffChildrenMerge dm = new DiffChildrenMerge()
             {
                public void insertChild(Object id, Object value)
                {
                   .. perform insert op for Child1 ..
                }

                public void updateChild(Object id, Object value, Object oldValue)
                {
                   .. perform update op for Child1 ..
                }

                public void removeChild(Object id)
                {
                   .. perform remove op for Child1 ..
                }
             };

             difChild1.applyDiffChanges(dm, resolver);
          }

          // Similarly for Child2
       }
    }
 
```
    Specified by:
    
    applyDiffChildren in interface DiffMergeable

Class EventMapping

Nested Class Summary

Field Summary

Fields inherited from interface oracle.jbo.mom.xml.DefPersistable

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

EventMapping

EventMapping

Method Detail

getTypeValue

getEventName

setEventName

getType

setType

getRaiseConditions

isForPersonalization

setForPersonalization

setDisabled

isDisabled

clone

addRaiseCondition

isDirty

setDirty

setOrigObject

getOrigObject

getFullName

getName

getMergeableName

getMergeableFullName

isNew

setNew

getDefXMLNameSpace

getDefXMLElementTag

getDefTypeName

getXMLElementTag

writeChildren

writeContents

writeObject

ensureDifferDetails

diffContents

diffChildren

beginDiffObjects

diffObjects

applyDiffContents

applyDiffChildren