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

java.lang.Object
- oracle.jbo.common.DBSortCriteriaCollection

All Implemented Interfaces:: DiffMergeable, DefPersistable, PersistentDefinition

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

Field Summary
- Fields inherited from interface oracle.jbo.mom.xml.DefPersistable
  FLAG_DIRTY, FLAG_EDITABLE, FLAG_FROM_TIP, FLAG_LOAD_BASE, FLAG_LOAD_HL_DEFS, FLAG_MAJOR_VERSION_CHANGED, FLAG_MINOR_VERSION_CHANGED, FLAG_NEW, FLAG_NEW_RECURSE, FLAG_SKIP_WRITE, XML_STATEMENT

Constructor Summary

Constructors
Constructor and Description

DBSortCriteriaCollection()

Constructors
Constructor and Description
`DBSortCriteriaCollection()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addSortCriteria(DBSortCriteriaImpl sortCrit)`
`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.
`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`	`getFullName()` This method returns the Persistence reference of the object.
`java.lang.String`	`getIdentificationAttributeName()` return the attribute name for identification on an xml element.
`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()`
`SortCriteria[]`	`getSortCriteriaList()`
`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`	`isNew()` This method returns if this object is previously persisted.
`boolean`	`isNewRecurse()`
`boolean`	`isSkipWrite()`
`boolean`	`isWriteObject(DefPersistable parentObj, DefWriter defWriter)`
`void`	`loadXMLContents(DefElement xmlElement)`
`DBSortCriteriaImpl`	`lookupSortCriteria(java.lang.String name)`
`boolean`	`removeSortCriteria(java.lang.String name)`
`void`	`setDirty(boolean b)` This method marks the Object dirty
`void`	`setNew(boolean b)` This method marks the as previously persisted.
`void`	`setNewRecurse(boolean b)`
`void`	`setOrigObject(DefPersistable oldObj)`
`void`	`setSkipWrite(boolean b)`
`void`	`setSortCriteriaList(SortCriteria[] sortCrit)`
`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
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DBSortCriteriaCollection
```
public DBSortCriteriaCollection()
```
- Method Detail
  - getSortCriteriaList
```
public SortCriteria[] getSortCriteriaList()
```
  - setSortCriteriaList
```
public void setSortCriteriaList(SortCriteria[] sortCrit)
```
  - addSortCriteria
```
public void addSortCriteria(DBSortCriteriaImpl sortCrit)
```
  - lookupSortCriteria
```
public DBSortCriteriaImpl lookupSortCriteria(java.lang.String name)
```
  - removeSortCriteria
```
public boolean removeSortCriteria(java.lang.String 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.
  - 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
  - getDefXMLNameSpace
```
public java.lang.String getDefXMLNameSpace()
```
    Specified by:
    
    getDefXMLNameSpace in interface PersistentDefinition
  - getIdentificationAttributeName
```
public java.lang.String getIdentificationAttributeName()
```
    Description copied from interface: PersistentDefinition
    
    return the attribute name for identification on an xml element. Note, for most def objects, the string "Name" should be returned; for someone that has no "Name" attribute, you need to designate one. e.g. For adfmcatalog.xml, "fullName" is returned For most other metadatas, "Name" is returned
    
    Specified by:
    
    getIdentificationAttributeName in interface PersistentDefinition
  - 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.
  - isNewRecurse
```
public boolean isNewRecurse()
```
    Specified by:
    
    isNewRecurse in interface DefPersistable
  - setNewRecurse
```
public void setNewRecurse(boolean b)
```
    Specified by:
    
    setNewRecurse in interface DefPersistable
  - isSkipWrite
```
public boolean isSkipWrite()
```
    Specified by:
    
    isSkipWrite in interface DefPersistable
  - setSkipWrite
```
public void setSkipWrite(boolean b)
```
    Specified by:
    
    setSkipWrite in interface DefPersistable
  - isWriteObject
```
public boolean isWriteObject(DefPersistable parentObj,
                             DefWriter defWriter)
```
    Specified by:
    
    isWriteObject in interface DefPersistable
  - getOrigObject
```
public DefPersistable getOrigObject()
```
    Specified by:
    
    getOrigObject in interface DefPersistable
  - setOrigObject
```
public void setOrigObject(DefPersistable oldObj)
```
    Specified by:
    
    setOrigObject in interface DefPersistable
  - getName
```
public java.lang.String getName()
```
  - 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
  - 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
  - loadXMLContents
```
public void loadXMLContents(DefElement xmlElement)
```
  - 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
  - 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.
  - writeChildren
```
public final void writeChildren(DefWriter jos)
                         throws DefPersistenceException
```
    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
    
    Throws:
    
    DefPersistenceException
  - 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
  - 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)
    {
       <Your-def-class> orgDefImpl = (<Your-def-class>) 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
  - 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(<XML-tag-for-Child1>);

          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
  - 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

Class DBSortCriteriaCollection

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DBSortCriteriaCollection

Method Detail

getSortCriteriaList

setSortCriteriaList

addSortCriteria

lookupSortCriteria

removeSortCriteria

getXMLElementTag

getDefXMLElementTag

getDefTypeName

getDefXMLNameSpace

getIdentificationAttributeName

isNew

setNew

isNewRecurse

setNewRecurse

isSkipWrite

setSkipWrite

isWriteObject

getOrigObject

setOrigObject

getName

getFullName

getMergeableName

getMergeableFullName

loadXMLContents

writeObject

isDirty

setDirty

writeChildren

writeContents

ensureDifferDetails

diffContents

diffChildren

beginDiffObjects

diffObjects

applyDiffChildren

applyDiffContents