DataAccessAdapter (Oracle Fusion Middleware Java API Reference for Oracle Data Visualization Components)

java.lang.Object
- oracle.dss.util.DataAccessAdapter

All Implemented Interfaces:

CDFDataAccess, DataAccess, DataDirector

Direct Known Subclasses:

LocalDataSource, LocalPivotTableDataSource, LocalXMLDataSource, SampleDataSource
```
public class DataAccessAdapter
extends java.lang.Object
implements DataAccess, DataDirector
```
Null implementation of DataAccess and DataDirector interface. Data providers can extend this class and override methods to provide a real implementation of the two interfaces.

Field Summary
- Fields inherited from interface oracle.dss.util.DataAccess
  DATATYPE_BOOLEAN, DATATYPE_DATE, DATATYPE_DOUBLE, DATATYPE_FLOAT, DATATYPE_INTEGER, DATATYPE_LONG, DATATYPE_SHORT, DATATYPE_STRING, FIND_CASE_INSENSITIVE, FIND_CONTAINS, FIND_ENDS_WITH, FIND_EXACT, FIND_PRIOR, FIND_STARTS_WITH, QDR_WITH_PAGE, QDR_WITHOUT_PAGE
- Fields inherited from interface oracle.dss.util.DataDirector
  COLUMN_EDGE, DATA_ELEMENT_EDGE, DRILL_BACK, DRILL_COLLAPSE, DRILL_MEMBERS_ABOVE, DRILL_MEMBERS_BELOW, DRILL_REPLACE, DRILL_TO_PARENT, DRILL_TO_PARENT_AND_SIBLINGS, DRILLSTATE_DRILLABLE, DRILLSTATE_IS_DRILLED, DRILLSTATE_NOT_DRILLABLE, FORCE_FETCH_DATA, FORCE_FETCH_RELATIVE_INDENT, FORCE_FETCH_SPANS, GRAND_TOTAL_LAYER, GROUPSORT_END, GROUPSORT_MIDDLE, GROUPSORT_NONE, GROUPSORT_START, HIDDEN_EDGE, max_edge, NA_SUPPRESSION, NA_ZERO_SUPPRESSION, NO_SUPPRESSION, NO_TOTALS, PAGE_EDGE, PIVOT_CHECK_OK, PIVOT_CHECK_UNKNOWN, PIVOT_EDGES, PIVOT_MOVE_AFTER, PIVOT_MOVE_BEFORE, PIVOT_MOVE_TO, PIVOT_SWAP, PROP_ASYNCHRONOUS, PROP_AUTO_FIRE_EVENTS, PROP_CACHE_LIMIT, PROP_COLUMN_FETCH_SIZE, PROP_COLUMN_SORTS_SUPPORTED, PROP_DD2_DRILL_SUPPORTED, PROP_DD2_VARIABLE_DRILLPATHS, PROP_DEFAULT_DRILL_TYPE, PROP_EDGE_EXTENT_AVAILABLE, PROP_HIDDEN_EDGE_SUPPORTED, PROP_IS_COLUMN_OUTLINE_SUPPORTED, PROP_IS_OUTLINE_SUPPORTED, PROP_IS_REORDER_SUPPORTED, PROP_IS_ROW_OUTLINE_SUPPORTED, PROP_PAGE_SORTS_SUPPORTED, PROP_REL_INDENT_SCAN_LIMIT, PROP_ROW_FETCH_SIZE, PROP_SORTS_SUPPORTED, PROP_SUPPORTED_DRILL_TYPES, PROP_TABULAR, PROP_TOTALS_ALLOWED, PROP_TOTALS_VISIBLE, PROP_UNIQUE_MEMBERS_SCAN_LIMIT, ROW_EDGE, SECTION_EDGE, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SORT_TYPE_GROUPSORT, SORT_TYPE_GROUPSORT_PAGEBREAK, SORT_TYPE_NORMAL, TOTAL_ALL_LAYERS, TOTAL_AVERAGE, TOTAL_MAXIMUM, TOTAL_MINIMUM, TOTAL_SUM, ZERO_SUPPRESSION

Constructor Summary

Constructors
Constructor and Description

DataAccessAdapter()

Constructors
Constructor and Description
`DataAccessAdapter()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addDataDirectorListener(DataDirectorListener l)` Registers a listener to the data source for changes.
`boolean`	`allSlicesFetched(int edge)` Returns `true` if all slices the entire given edge have been fetched and are available.
`boolean`	`cancel()` Cancels the current long-running operation, if possible.
`boolean`	`changeEdgeCurrentHPos(int edge, int[] hPos, int maxLayerSpecified)` Changes the slice of data, on the specified edge, that is designated as the current slice by using hierarchical addressing.
`boolean`	`changeEdgeCurrentSlice(int edge, int slice)` Changes the slice, on the specified edge, that is designated as the current slice of data.
`boolean`	`deleteMemberCalc(int edge, int layer, int slice)` Deletes a calculation from the display based on a member that is located at the specified edge, layer, and slice.
`boolean`	`deleteValueCalc(int row, int column)` Deletes a calculation at the specified row and column of the body of a data for a view.
`boolean`	`drill(int edge, int layer, int[] slice, int flags)` Drills in data based on multiple selected members.
`boolean`	`drill(int edge, int layer, int[] slice, java.lang.String pathID, java.lang.String targetID, int flags)` Drills in the data for multiple members.
`boolean`	`drill(int edge, int layer, int slice, int flags)` Drills in the data for a single member.
`boolean`	`drill(int edge, int layer, int slice, java.lang.String pathID, java.lang.String targetID, int flags)` Drills in the data for a single member.
`boolean`	`drillOK(int edge, int layer, int[] slice, int flags)` Indicates whether the specified drill operation from multiple selected members would be a valid drill.
`boolean`	`drillOK(int edge, int layer, int[] slice, java.lang.String pathID, java.lang.String targetID, int flags)` Indicates whether the specified drill operation from multiple selected members would be a valid drill.
`boolean`	`drillOK(int edge, int layer, int slice, int flags)` Indicates whether a drill operation from a single selected member would be legal.
`boolean`	`drillOK(int edge, int layer, int slice, java.lang.String pathID, java.lang.String targetID, int flags)` Indicates whether a drill operation from a single selected member would be legal.
`boolean`	`dropChanges()` Clears the `QDR` overrides in the writeback collection.
`void`	`endGroupEdit()` Indicates the end of a group of `setValue` calls.
`int`	`findMember(int edge, int[] hPos, int memberLayer, java.lang.String s, java.lang.String type, int flags)` Searches a set of child members for the specified value starting at a specified offset.
`int[]`	`findMembers(int edge, int[] hPos, int memberLayer, java.lang.String s, java.lang.String type, int flags)` Searches a set of child members for the specified value starting at a specified offset, and returns all instances found as an array of slices.
`void`	`fireEvents()` Fire any pending events to all listeners.
`boolean`	`forceFetch(int[] startSlice, int[] endSlice, int flag)` Ensures that a block of data has been fetched or computed locally.
`ColumnSortInfo[]`	`getColumnSorts()` Retrieves sorting information for given layers on a table-style view.
`java.lang.Object[][]`	`getCompatibleDataItemMetadata(java.lang.String[] types, java.lang.String[] idList)` Return sets of metadata for a list of data items that can be referenced by the underlying query for use in building conditional formatting expressions, etc.
`java.util.List`	`getCorrespondingMemberMetadata(int edge, int layer, java.lang.String[] values, java.lang.String[] types, boolean inDataAccess)` Returns a `List` of `Object` arrays of member metadata corresponding to the given `MetadataMap.METADATA_VALUE` strings specified in the `values` parameter.
`java.util.List`	`getCorrespondingMemberMetadata(java.lang.String layerName, java.lang.String[] values, java.lang.String[] types, boolean inDataAccess)` Returns a `List` of `Object` arrays of member metadata corresponding to the given `MetadataMap.METADATA_VALUE` strings specified in the `values` parameter.
`DataAccess`	`getDataAccess()` Called by the view to get a current `BaseDataAccess` model of the data.
`DataMap`	`getDataMap()` Retrieves the list of types of data that can be retrieved or set for each location in the data cursor.
`DimensionSortInfo[]`	`getDimensionSorts()` Retrieves sorting information for given dimensions.
`int`	`getEdgeCount()` Retrieves the total number of edges in the cursor.
`int[]`	`getEdgeCurrentHPos(int edge)` Retrieves, for the specified edge, the hierarchical address of the location that is defined by the implementor as the "current" location.
`int`	`getEdgeCurrentSlice(int edge)` Retrieves the zero-based index of the slice that is defined by the implementor as the current slice.
`int`	`getEdgeExtent(int edge)` Retrieves the total number of slices that are available on the specified edge.
`boolean`	`getEdgeSymmetric(int edge)` Returns `true` if the edge is completely symmetric (every parent tuple has the same set of children at each layer), or `false` if not.
`java.lang.Object[]`	`getExpressions()` Return the entire set of expression tree structures set on this query.
`int[]`	`getFirstHPos(int edge)` Retrieves the hPos array that identifies the members at each physical layer of slice 0 on the specified edge.
`int[]`	`getLastHPos(int edge)` Retrieves the hPos array that identifies the members at each physical layer in the last slice on the specified edge.
`int`	`getLayerCount(int edge)` Retrieves the total number of layers on the specified edge.
`java.lang.Object`	`getLayerMetadata(int edge, int layer, java.lang.String type)` Retrieves the specified type of metadata for a member at the specified location.
`QDR`	`getLayerQDR(int edge, int layer, int flags)` Retrieves the `QDR` object that represents the specified logical layer.
`int`	`getMemberDepth(int edge, int layer, int slice)` Retrieves the size (expressed in layers that are perpendicular to the specified edge orientation) of a member at the specified layer, slice, and edge.
`int`	`getMemberExtent(int edge, int layer, int slice)` Retrieves the size of a member, that is, the number of slices that the member spans at a specified edge, layer, and slice location (parallel to the direction of the edge).
`int[]`	`getMemberHPos(int edge, int layer, int slice)` Retrieves the hierarchical address for an absolute address that is specified as edge, physical layer, and slice.
`int`	`getMemberLogicalLayer(int edge, int layer, int slice)` Retrieves the logical layer to which the member at the specified edge, physical layer, and slice location belongs.
`java.lang.Object`	`getMemberMetadata(int edge, int[] hPos, int memberLayer, int hIndex, java.lang.String type)` Retrieves the specified type of metadata for the member at a specified location.
`java.lang.Object`	`getMemberMetadata(int edge, int layer, int slice, java.lang.String type)` Retrieves the specified type of metadata for a member at the specified location.
`QDR`	`getMemberQDR(int edge, int[] hPos, int memberLayer, int flags)` Retrieves a `QDR` object that represents the specified member using hierarchical addressing.
`QDR`	`getMemberQDR(int edge, int layer, int slice, int flags)` Retrieves a `QDR` object that represents the data value for the member at the specified edge, layer, and slice.
`int`	`getMemberSiblingCount(int edge, int[] hPos, int memberLayer)` Retrieves the count of all the sibling members at a specified logical layer based on a series of relative indexes for each logical layer down to the specified logical layer.
`MemberSortInfo[]`	`getMemberSorts()` Retrieves the set of member sort information.
`int`	`getMemberStartLayer(int edge, int layer, int slice)` Retrieves the starting layer at which a member at the specified edge, layer, and slice location begins.
`int`	`getMemberStartSlice(int edge, int layer, int slice)` Retrieves the absolute number of the first slice that a member spans.
`MetadataMap`	`getMetadataMap(int edge, int layer)` Retrieves the list of all the types of metadata that callers have requested to be included in the cursors for the specified logical `layer`.
`int[]`	`getNextHPos(int edge, int[] hPos)` Retrieves the hPos that identifies the next member on the specified edge relative to a specified `hPos`.
`int[]`	`getPrevHPos(int edge, int[] hPos)` Retrieves the hPos array that identifies the members at each physical layer of the slice that is immediately previous to the specified `hPos` on the specified edge.
`java.lang.Object`	`getProperty(java.lang.String name)` Gets a property from a DataDirector2 object.
`java.util.Vector`	`getQDRoverrideCollection()` Retrieves a read-only copy of the `QDR` overrides in the writeback collection.
`java.lang.Object`	`getSliceLabel(int edge, int slice, java.lang.String type)` Retrieves the label (or concatenated metadata) for the specified slice.
`int`	`getSliceMemberCount(int edge, int slice)` Retrieves the number of unique logical layers (that is, the number of members that run perpendicular to the orientation of the edge) at the specified slice and edge.
`int`	`getSliceOutlineLayer(int edge, int slice)` Retrieves the starting logical layer of a specified slice in a specified edge when the Crosstab (along with the `DataAccess` implementor) is set to return data in outline mode.
`QDR`	`getSliceQDR(int edge, int slice, int flags)` Retrieves a `QDR` object that represents the data value at the specified slice on the edge (that is, across all relevant logical layers of the slice).
`int[]`	`getSlicesFromQDR(QDRInterface qdr, int[] startSlice, int[] endSlice)` Returns an array of absolute slice positions in an edge-orderered array (column edge 0, row edge 1, etc.), given a QDR specifying a position in the current cursor.
`SortInfo[]`	`getSorts()` Retrieves sorting information for given layers on a crosstab-style view.
`StatusInfo`	`getStatus()` Returns an object that contains progress information (if supported) and contains an enumerated status constant, and a return value if the call has completed successfully and the call returns a value.
`DataMap`	`getSupportedDataMap()` Return a `DataMap` that contains all of the types that this `DataAccessAdapter` can support.
`LayerMetadataMap`	`getSupportedLayerMetadataMap()` Return a `LayerMetadataMap` that contains all of the types that this `DataAccessAdapter` can support.
`MetadataMap`	`getSupportedMetadataMap()` Retrieves a `MetadataMap` that contains all of the types that this `DataAccessAdapter` can support.
`java.util.List`	`getUniqueMemberMetadata(int edge, int layer, java.lang.String[] types, int start, int count)` Returns an unordered `List` of `Object` arrays representing metadata for unique member values across a layer on an edge.
`java.util.List`	`getUniqueMemberMetadata(java.lang.String layerName, java.lang.String[] types, int start, int count)` Returns an unordered `List` of `Object` arrays representing metadata for unique member values across a layer on an edge.
`java.lang.Object`	`getValue(int row, int col, java.lang.String type)` Retrieves a data value for the specified row and column intersection.
`QDR`	`getValueQDR(int row, int column, int flags)` Retrieves a `QDR` object that represents the value at the specified row and column in the data area of the cursor.
`boolean`	`insertMemberCalc(int edge, int layer, int slice, int flags, java.lang.Object calc)` Inserts a calculation into a display based on the member at the specified edge, layer, and slice.
`boolean`	`insertValueCalc(int row, int column, int flags, java.lang.Object calc)` Inserts a calculation at a specified row and column in the body of a view's data.
`boolean`	`isAutoSubmit()` Indicates whether automatic submission is set for cell editing.
`boolean`	`isCancelable()` Indicates whether this `DataDirector` implementor allows views to cancel an operation that takes a long time.
`boolean`	`isFetched(int[] startSlice, int[] endSlice, int flag)` Indicates whether a block of data has been fully computed or processed locally.
`boolean`	`isMemberExtentComplete(int edge, int layer, int slice)` Determines if the size of a member, that is, the number of slices that the member spans at a specified edge, layer, and slice location (parallel to the direction of the edge), has been completely calculated.
`boolean`	`isOutline()` Indicates whether data is provided in outline form or inline form.
`boolean`	`pivot(int fromEdge, int toEdge, int fromLayer, int toLayer, int flags)` Pivots or swaps data.
`int`	`pivotCheck(int fromEdge, int toEdge, int fromLayer, int toLayer, int flags)` Indicates whether the specified pivot operation would be valid for the current data layout.
`boolean`	`pivotOK(int fromEdge, int toEdge, int fromLayer, int toLayer, int flags)` Indicates whether the specified pivot operation would be valid for the current data layout.
`boolean`	`redoEdit()` Performs a redo of the latest `undo` action.
`boolean`	`refresh()` Refreshes data and fires a DataChangedEvent to all registered listeners.
`void`	`release()` Informs the implementor that the caller no longer needs this `DataAccess` reference.
`void`	`removeDataDirectorListener(DataDirectorListener l)` Removes a listener from the data source.
`boolean`	`reorder(int edge, int fromLayer, int toLayer, int flags)` Reorders the layers (that is, columns) of a `Table` object.
`boolean`	`revalidate()` Rebuilds (that is, reruns) a query, refreshes the data cache, and fires a DataChangedEvent.
`void`	`setAutoSubmit(boolean bValue)` Specifies that the `QDR` override in the writeback collection for a cell will be submitted automatically as soon as it is entered.
`boolean`	`setColumnSorts(ColumnSortInfo[] sortInfo)` Allows sorting by dimension items on a table-style view.
`void`	`setDataMap(DataMap map, int sizeRow, int sizeColumn)` Specifies the types of data to provide in a data cursor.
`boolean`	`setDimensionSorts(DimensionSortInfo[] dimensionSortInfo)` Allows sorting by N dimensions, with each dimension optionally sorted by a series of criteria including measure, name, attribute, hierarchy, etc.
`java.lang.String[]`	`setExpressions(java.lang.Object[] expressions)` Set the entire set of Boolean expressions this query should assign DataMap constants for and be able to evaluate for the session.
`void`	`setLayerMetadata(int edge, int layer, java.lang.String type, java.lang.Object value)` Sets a piece of metadata for a logical layer that is found at a specified edge, logical layer and LayerMetadataMap type.
`void`	`setManualUpdate()` Batches DataDirector operations.
`boolean`	`setMemberSorts(MemberSortInfo[] memberSortInfo)` Specifies a set of member sorts for N dimensions.
`void`	`setMetadataMap(int edge, int layer, MetadataMap map, int size)` Specifies the types of metadata to provide in the cursors for the specified logical layer.
`void`	`setOutline(boolean outline)` Specifies whether data is provided to a view in outline form.
`void`	`setProperty(java.lang.String name, java.lang.Object value)` Sets a property on a DataDirector2 object.
`boolean`	`setSorts(SortInfo[] sortInfo)` Allows sorting by N dimension items on a crosstab-style view, with each item optionally sorted by its own measure fact/dimension item combinations or by the item text.
`boolean`	`setValue(java.lang.Object data, int row, int col, java.lang.String type)` Specifies a data value for the specified row and column intersection.
`StatusInfo`	`startExecution()` Must be called to begin execution on an asynchronous query.
`void`	`startGroupEdit()` Indicates the start of a group of `setValue` calls.
`boolean`	`submitChanges()` Writes the current group of `QDR` overrides in the writeback collection to the database and flushes the entries in the writeback collection.
`boolean`	`undoEdit()` Performs an undo of the latest `setValue` operation.
`void`	`update()` Processes batched DataDirector operations.

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

- Constructor Detail
  - DataAccessAdapter
```
public DataAccessAdapter()
```
- Method Detail
  - getEdgeExtent
```
public int getEdgeExtent(int edge)
                  throws EdgeOutOfRangeException
```
    Retrieves the total number of slices that are available on the specified edge. The implementation returns 0.
    
    Specified by:
    
    getEdgeExtent in interface CDFDataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    Returns:
    
    The total number of slices that are available on the specified edge. This number determines the range of valid slice values for the specified edge in other API calls: the valid range is from zero to this return value minus one. This implementation returns zero.
    
    Throws:
    
    EdgeOutOfRangeException - If the edge parameter is not valid.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, *
  - getEdgeSymmetric
```
public boolean getEdgeSymmetric(int edge)
                         throws EdgeOutOfRangeException
```
    Description copied from interface: CDFDataAccess
    
    Returns true if the edge is completely symmetric (every parent tuple has the same set of children at each layer), or false if not.
    
    Specified by:
    
    getEdgeSymmetric in interface CDFDataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    Returns:
    
    true if the edge is symmetric, false if not
    
    Throws:
    
    EdgeOutOfRangeException - If the edge parameter is not valid.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getEdgeCount
```
public int getEdgeCount()
```
    Retrieves the total number of edges in the cursor. Views assume the following:
    - Edge 0 is the column edge.
    - Edge 1 is the row edge.
    - All other edges are page edges; if the cursor has more than three edges, the view account for the extra edges.
    Specified by:
    
    getEdgeCount in interface CDFDataAccess
    
    Returns:
    
    The total number of edges in the cursor.
  - getValue
```
public java.lang.Object getValue(int row,
                                 int col,
                                 java.lang.String type)
                          throws RowOutOfRangeException,
                                 ColumnOutOfRangeException
```
    Retrieves a data value for the specified row and column intersection.
    This implementation returns null.
    
    Specified by:
    
    getValue in interface DataAccess
    
    Parameters:
    
    row - The row to get.
    
    col - The column to get.
    
    type - Type of data to return, such as formatted or unformatted. Valid type values are defined in the DataMap.
    
    Returns:
    
    The specified type of information for the specified row and column location. This implementation returns null.
    
    Throws:
    
    RowOutOfRangeException - If row is negative or too large.
    
    ColumnOutOfRangeException - If column is negative or too large.
    
    See Also:
    
    DataMap
  - setValue
```
public boolean setValue(java.lang.Object data,
                        int row,
                        int col,
                        java.lang.String type)
                 throws RowOutOfRangeException,
                        ColumnOutOfRangeException
```
    Specifies a data value for the specified row and column intersection.
    This implementation returns false.
    
    Specified by:
    
    setValue in interface DataAccess
    
    Parameters:
    
    data - The data to set into the cursor.
    
    row - The row at which to set the data.
    
    col - The column at which set the data.
    
    map - Type of data to set, such as formatted or unformatted. Valid type values are defined in the DataMap.
    
    Returns:
    
    truefalse if not.
    
    Throws:
    
    RowOutOfRangeException - If row is negative or too large.
    
    ColumnOutOfRangeException - If column is negative or too large.
    
    See Also:
    
    DataMap
  - getSliceLabel
```
public java.lang.Object getSliceLabel(int edge,
                                      int slice,
                                      java.lang.String type)
                               throws EdgeOutOfRangeException,
                                      SliceOutOfRangeException
```
    Retrieves the label (or concatenated metadata) for the specified slice. The method of concatenation is usually each member label separated by a space or other character, but can be implementation dependent.
    
    Specified by:
    
    getSliceLabel in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    slice - An absolute index (zero-based) along the specified edge that indicates the slice for which concatenated metadata is desired.
    
    type - A constant that specifies the kind of metadata that the caller wants to have returned. Valid type values are defined in the class MetadataMap class.
    
    Returns:
    
    The label (or metadata) for the location on the specified edge. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is out of range.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getEdgeCurrentSlice
```
public int getEdgeCurrentSlice(int edge)
                        throws EdgeOutOfRangeException
```
    Retrieves the zero-based index of the slice that is defined by the implementor as the current slice. For the row and column edges, the view do not require support for the concept of a current slice. This concept is usually associated with a view paging control on the page edge.
    
    Specified by:
    
    getEdgeCurrentSlice in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    Returns:
    
    The slice (zero-based) that is defined as the current slice. Often the slice that represents the page that is currently displayed in a Crosstab when this method is called for the page edge. (On the page edge, the value of slice is one less than the actual page number, which is 1-based.) This implementation returns zero.
    
    Throws:
    
    EdgeOutOfRangeException - If the edge parameter is not in the valid range.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getEdgeCurrentHPos
```
public int[] getEdgeCurrentHPos(int edge)
                         throws EdgeOutOfRangeException
```
    Retrieves, for the specified edge, the hierarchical address of the location that is defined by the implementor as the "current" location. The row and column edges of view do not require support for the concept of a current location. This concept is usually associated with a paging control on the page edge of a view.
    
    Specified by:
    
    getEdgeCurrentHPos in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    Returns:
    
    The hPos array that represents the current location on the specified edge. When this method is called for the page edge, the hPos that represents the page that is currently displayed in a Crosstab. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If the parameter edge is not valid.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getLayerCount
```
public int getLayerCount(int edge)
                  throws EdgeOutOfRangeException
```
    Retrieves the total number of layers on the specified edge.
    
    Specified by:
    
    getLayerCount in interface CDFDataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    Returns:
    
    The number of layers on the specified edge. This number determines the range of valid values on the specified edge for the layer parameter in other API calls: the valid range is from zero to this return value minus one. This implementation returns zero.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is out of range.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getSliceMemberCount
```
public int getSliceMemberCount(int edge,
                               int slice)
                        throws EdgeOutOfRangeException,
                               SliceOutOfRangeException
```
    Retrieves the number of unique logical layers (that is, the number of members that run perpendicular to the orientation of the edge) at the specified slice and edge. This method is useful in cases of asymmetry where the members on an edge do not all span the same layers.
    This implementation returns 0.
    
    Specified by:
    
    getSliceMemberCount in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    slice - An absolute index (zero-based) that indicates the location of a slice along the specified edge. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    Returns:
    
    The total number of unique logical layers for the specified slice and edge. This implementation returns zero.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is out of range.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getSliceOutlineLayer
```
public int getSliceOutlineLayer(int edge,
                                int slice)
                         throws EdgeOutOfRangeException,
                                SliceOutOfRangeException
```
    Retrieves the starting logical layer of a specified slice in a specified edge when the Crosstab (along with the DataAccess implementor) is set to return data in outline mode. Because, in outline mode, the getSliceMemberCount method always return the value 1, the Crosstab uses getSliceOutlineLayer to determine the logical layer.
    This implementation returns 0.
    
    Specified by:
    
    getSliceOutlineLayer in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector. The slice is zero-based. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    slice - An absolute index (zero-based) that indicates the location of a slice along the specified edge. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    Returns:
    
    The logical layer of the specified slice in the specified edge for outline mode only. This implementation returns zero.
    
    Throws:
    
    EdgeOutOfRangeException - If the edge parameter is not valid.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getMemberDepth
```
public int getMemberDepth(int edge,
                          int layer,
                          int slice)
                   throws EdgeOutOfRangeException,
                          LayerOutOfRangeException,
                          SliceOutOfRangeException
```
    Retrieves the size (expressed in layers that are perpendicular to the specified edge orientation) of a member at the specified layer, slice, and edge. In other words, this method returns the following information depending upon the specified edge:
    - Returns the "height" of a member in the Crosstab's column edge header, that is, the number of heading rows for the member.
    - Returns the "width" of a member in the Crosstab's row edge header, that is the number of heading columns for the member.
    The sum of all the members' values for this method, within a specified slice, should not exceed the value that getLayerCount returns for the specified edge.
    This method is useful only in cases of asymmetry where the members on an edge do not all cover one layer and have a depth of 1. On a symmetric edge, all members have a member depth of 1.
    This implementation returns 0.
    Specified by:
    
    getMemberDepth in interface CDFDataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to look for the layer and slice. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based index of the starting physical layer in which to look for the slice, as returned by getMemberStartLayer.
    
    slice - An absolute index (zero-based) that indicates the location of a slice along the specified edge. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    Returns:
    
    The depth (that is, the number of layers) that the specified member covers. This implementation returns zero.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    See Also:
    
    getLayerCount(int), getMemberStartLayer(int, int, int), DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getMemberStartLayer
```
public int getMemberStartLayer(int edge,
                               int layer,
                               int slice)
                        throws EdgeOutOfRangeException,
                               LayerOutOfRangeException,
                               SliceOutOfRangeException
```
    Retrieves the starting layer at which a member at the specified edge, layer, and slice location begins. Presentation beans use this method in conjunction with getMemberDepth to retrieve the following information depending on the edge:
    - For a member on a column edge, the vertical height and starting position.
    - For a member on a row edge, the horizontal width and starting position.
    The sum of the values that are returned for a member by this method, getMemberStartLayer, and getMemberDepth should not exceed the value that is returned by getLayerCount for an edge.
    This method is useful only in cases of asymmetry where the members on an edge do not all cover one layer. In a symmetric edge, all members have a member start layer equal to their layer.
    Specified by:
    
    getMemberStartLayer in interface CDFDataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to look for layer and slice. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based index of the physical layer in which to look for the slice.
    
    slice - An absolute index (zero-based) that indicates the location of a slice along the specified edge. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    Returns:
    
    The starting layer of the member within the specified edge.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getMemberLogicalLayer
```
public int getMemberLogicalLayer(int edge,
                                 int layer,
                                 int slice)
                          throws EdgeOutOfRangeException,
                                 LayerOutOfRangeException,
                                 SliceOutOfRangeException
```
    Retrieves the logical layer to which the member at the specified edge, physical layer, and slice location belongs. If a particular member spans more than one physical layer at the specified slice, then passing in any of the spanned physical layer positions for the layer parameter should yield the same logical layer.
    The value returned by this method can be used as input to getLayerMetadata and should not exceed the value that is returned by getMemberCount.
    
    Specified by:
    
    getMemberLogicalLayer in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to look for the layer and slice. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based index of the physical layer of the member.
    
    slice - An absolute index (zero-based) that indicates the location of a slice along the specified edge. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    Returns:
    
    The logical layer of the member within the specified edge.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getLayerMetadata
```
public java.lang.Object getLayerMetadata(int edge,
                                         int layer,
                                         java.lang.String type)
                                  throws EdgeOutOfRangeException,
                                         LayerOutOfRangeException
```
    Retrieves the specified type of metadata for a member at the specified location.
    This implementation returns null.
    
    Specified by:
    
    getLayerMetadata in interface CDFDataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to look for the member metadata. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based index of the layer for which metadata is requested. Uses a depth computation to identify the location of the layer or layer member; 0 is the outer-most layer on the edge. The value for this parameter can be obtained by calling getMemberLogicalLayer.
    
    type - A constant that specifies the kind of metadata that you want. Valid type values are defined in the LayerMetadataMap.
    
    Returns:
    
    The requested metadata. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    See Also:
    
    LayerMetadataMap, DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getMemberExtent
```
public int getMemberExtent(int edge,
                           int layer,
                           int slice)
                    throws EdgeOutOfRangeException,
                           LayerOutOfRangeException,
                           SliceOutOfRangeException
```
    Retrieves the size of a member, that is, the number of slices that the member spans at a specified edge, layer, and slice location (parallel to the direction of the edge). Views use this method to determine the width of a member in a column header or the height of a member in a row header when not in outline form.
    The sum of all the unique getMemberExtent values for an edge should not exceed the getEdgeExtent value for the same edge.
    This implementation returns 0.
    
    Specified by:
    
    getMemberExtent in interface CDFDataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to look for the layer and slice. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based index of the physical layer of the member whose size will be returned. Valid values are zero to total layers at the specified slice.
    
    slice - An absolute index (zero-based) that indicates the location along the edge of the member whose extent will be returned. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    Returns:
    
    The number of slices that the member spans at the specified location. This implementation returns zero.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large
    
    SliceOutOfRangeException - If slice is negative or too large
    
    See Also:
    
    getMemberStartSlice(int, int, int), DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getMemberStartSlice
```
public int getMemberStartSlice(int edge,
                               int layer,
                               int slice)
                        throws EdgeOutOfRangeException,
                               LayerOutOfRangeException,
                               SliceOutOfRangeException
```
    Retrieves the absolute number of the first slice that a member spans. Views use this method to determine where to start painting a member label in a row or column header. Views pass the same parameter values to this method and to getMemberExtent.
    This implementation returns 0.
    
    Specified by:
    
    getMemberStartSlice in interface CDFDataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to look for the layer and slice. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based index of the physical layer of the member whose first slice will be returned. Valid values are zero to total layers at the specified slice.
    
    slice - An absolute index (zero-based) that indicates the location along the specified edge of the member whose starting slice will be returned. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    Returns:
    
    The absolute index of the first slice that the member spans. This implementation returns zero.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    See Also:
    
    getMemberExtent(int, int, int), DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getMemberMetadata
```
public java.lang.Object getMemberMetadata(int edge,
                                          int layer,
                                          int slice,
                                          java.lang.String type)
                                   throws EdgeOutOfRangeException,
                                          LayerOutOfRangeException,
                                          SliceOutOfRangeException
```
    Retrieves the specified type of metadata for a member at the specified location.
    
    Specified by:
    
    getMemberMetadata in interface CDFDataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to look for the member metadata. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based index of the physical layer in which to find the slice. Valid values are zero to total layers at the specified slice.
    
    slice - An absolute index (zero-based) that indicates the location along the edge of a slice that belongs to the member for which metadata is requested. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    type - A constant that specifies the kind of metadata requested. Valid type values are defined in MetadataMap. The caller should have intialized the appropriate MetadataMap object with any types of metadata that the caller intends to use.
    
    Returns:
    
    The requested metadata. This implementation returns null.
    
    Throws:
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SlieOutOfRangeException - If slice is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    EdgeOutOfRangeException
    
    See Also:
    
    MetadataMap, DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getMemberSiblingCount
```
public int getMemberSiblingCount(int edge,
                                 int[] hPos,
                                 int memberLayer)
                          throws EdgeOutOfRangeException,
                                 LayerOutOfRangeException,
                                 SliceOutOfRangeException
```
    Retrieves the count of all the sibling members at a specified logical layer based on a series of relative indexes for each logical layer down to the specified logical layer. This method is useful in populating a page control for a view. For an example, consider the following column header.
    
    June July
    
    Tents Canoes Tents Canoes
    
    NY Boston LA Toronto Winnepeg NY LA NY Boston LA Toronto Winnepeg
    
    A caller can use this method to find the number of Geography values (that is, sibling members) under the members July and Tents. This count is 3 (for NY, Boston, and LA). The hPos and memberLayer parameters for this example are as follows:
    - hPos, an array of relative indexes, holds an entry for July, Tents, and any one of the siblings that are to be counted. A valid hPos in this example must contain indexes for at least layers 0, 1, and 2. Valid arrays for this example could be any of the following: {1,0,0} or {1,0,1} or {1,0,2).
    - memberLayer, which identifies the layer at which to count the siblings, must be 2.
    Note: The value that is returned by this method provides the upper limit to the hIndex that a caller passes in getMemberMetadata.
    This implementation returns 0.
    Specified by:
    
    getMemberSiblingCount in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    hPos - An array that contains an index for the member values at each layer up to and including the layer of the sibling members that are to be counted. These indexes are relative to the number of members at each layer. When a member spans more than one layer, any layers beyond the starting layer should have their place held by a -1 index.
    
    memberLayer - The index into the hPos array for which the call should return the sibling member count.
    
    Returns:
    
    The number of sibling members that are found on the specified edge at the location that is specified by hPos and memberLayer. In the example, this method returns 3 (for the siblings NY, Boston, and LA). This implementation returns 0.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If memberLayer is too large.
    
    SliceOutOfRangeException - If any slice in hPos is too large.
    
    See Also:
    
    getMemberMetadata(int, int, int, java.lang.String), DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getMemberMetadata
```
public java.lang.Object getMemberMetadata(int edge,
                                          int[] hPos,
                                          int memberLayer,
                                          int hIndex,
                                          java.lang.String type)
                                   throws EdgeOutOfRangeException,
                                          LayerOutOfRangeException,
                                          SliceOutOfRangeException
```
    Retrieves the specified type of metadata for the member at a specified location. For example, this method is useful for retrieving labels for display in views.
    The user of this method makes the following calls:
    - Calls getMemberSiblingCount to retrieve the number of sibling members for a specified tree of members.
    - Calls this method once for each sibling member to retrieve the specified metadata for that member.
    The call for this method uses the same hPos and memberLayer parameters as found in getMemberSiblingCount to specify the parent tree of members. Each call of this method also uses the hIndex parameter that indicates the specific sibling member for which to return metadata. Valid values for hIndex range from 0 to (getMemberSiblingCount() - 1).
    Specified by:
    
    getMemberMetadata in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    hPos - An array of relative indexes, organized by logical layer, for the parent tree of members above the sibling member that is specified by hIndex. The array includes entries for layer 0 through at least the layer that is specified by memberLayer.
    
    memberLayer - The zero-based index into the hPos array for which the call should address the set of sibling members.
    
    hIndex - The zero-based index of a sibling member relative to its siblings. This index specifies the sibling member for which to return the specified metadata.
    
    type - A constant that specifies the kind of metadata to return. Valid type values are defined in MetadataMap.
    
    Returns:
    
    The requested metadata for the member at the specified location. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If memberLayer is too large.
    
    SliceOutOfRangeException - If any slice in hPos is too large, or if the hIndex is too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getMemberHPos
```
public int[] getMemberHPos(int edge,
                           int layer,
                           int slice)
                    throws EdgeOutOfRangeException,
                           LayerOutOfRangeException,
                           SliceOutOfRangeException
```
    Retrieves the hierarchical address for an absolute address that is specified as edge, physical layer, and slice. This method constructs an array that can be used in creating the hPos parameter in calls such as getMemberSiblingCount and getMemberMetadata.
    As an example, this method can retrieve an array of indexes from a page edge. The array includes an index for each layer in the page edge. Consider pivoting the following column header to a page edge.
    
    June July
    
    Tents Canoes Tents Canoes
    
    NY Boston LA Toronto Winnepeg NY LA NY Boston LA Toronto Winnepeg
    
    If the current page displayed June, Canoes, and Winnepeg, this method would return the array {0,1,1}. June is at index 0 in layer 0. Canoes is at index 1 in layer 1 under June. Winnepeg is at index 1 in layer 2 under Canoes. To find the number of members under Canoes under June, call getMemberSiblingCount with the array {0,1,1} and the memberLayer parameter 2.
    
    Specified by:
    
    getMemberHPos in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to look for the slice. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based index of the physical layer of the member whose hierarchical address will be returned.
    
    slice - An absolute index (zero-based) along an edge that indicates the location of the slice whose hierarchical location will be returned. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    Returns:
    
    An array of relative indexes. There is one index for each layer in the edge up to and including the layer argument, with -1 representing non-starting layers when a member happens to span more than one layer. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If memberLayer is too large.
    
    SliceOutOfRangeException - If any slice in hPos is too large
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getFirstHPos
```
public int[] getFirstHPos(int edge)
                   throws EdgeOutOfRangeException
```
    Retrieves the hPos array that identifies the members at each physical layer of slice 0 on the specified edge. If there is no new member at a particular layer (because the member spans more than one physical layer) then the index value in the hPos array will be -1 for that layer.
    
    Specified by:
    
    getFirstHPos in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    Returns:
    
    An hPos array that fully identifies the first slice on the specified edge. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getLastHPos
```
public int[] getLastHPos(int edge)
                  throws EdgeOutOfRangeException
```
    Retrieves the hPos array that identifies the members at each physical layer in the last slice on the specified edge. If there is no new member at a particular layer (because the member spans more than one physical layer) then the index value in the hPos array will be -1 for that layer.
    
    Specified by:
    
    getLastHPos in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    Returns:
    
    An hPos array that fully identifies the last slice on the specified edge. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getPrevHPos
```
public int[] getPrevHPos(int edge,
                         int[] hPos)
                  throws EdgeOutOfRangeException,
                         LayerOutOfRangeException,
                         SliceOutOfRangeException
```
    Retrieves the hPos array that identifies the members at each physical layer of the slice that is immediately previous to the specified hPos on the specified edge. If there is no new member at a particular layer (because the member spans more than one physical layer) then the index value in the hPos array will be -1 for that layer.
    
    Specified by:
    
    getPrevHPos in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    hPos - Identifies the member for which this call should return the previous member on the edge.
    
    Returns:
    
    An hPos array that fully identifies the previous slice on the edge. Returns null if the hPos parameter represents the first slice on the edge. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If hPos is too long.
    
    SliceOutOfRangeException - If any slice in hPos is too large
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getNextHPos
```
public int[] getNextHPos(int edge,
                         int[] hPos)
                  throws EdgeOutOfRangeException,
                         LayerOutOfRangeException,
                         SliceOutOfRangeException
```
    Retrieves the hPos that identifies the next member on the specified edge relative to a specified hPos. If there is no new member at a particular layer (because the member spans more than one physical layer) then the index value in the hPos array will be -1 for that layer.
    
    Specified by:
    
    getNextHPos in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    hPos - Identifies the member for which this call should return the next member on the edge.
    
    Returns:
    
    An hPos array that fully identifies the next slice on the specified edge. Returns null if the specified hPos is the last one on the edge. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If hPos is too long.
    
    SliceOutOfRangeException - If any slice in hPos is too large
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getValueQDR
```
public QDR getValueQDR(int row,
                       int column,
                       int flags)
                throws RowOutOfRangeException,
                       ColumnOutOfRangeException
```
    Retrieves a QDR object that represents the value at the specified row and column in the data area of the cursor.
    
    Specified by:
    
    getValueQDR in interface DataAccess
    
    Parameters:
    
    row - The row in the data cursor for which to return the QDR.
    
    column - The column in the data cursor for which to return the QDR.
    
    flags - A constant that identifies whether to include page edge information if the QDR is not for the page edge. Valid constants are listed in the See Also section.
    
    Returns:
    
    QDR object that refers to the data at the specified location. This implementation returns null.
    
    Throws:
    
    RowOutOfRangeException - If the row parameter is not valid.
    
    ColumnOutOfRangeException - If the column parameter is not valid.
    
    See Also:
    
    DataAccess.QDR_WITH_PAGE, DataAccess.QDR_WITHOUT_PAGE
  - getSliceQDR
```
public QDR getSliceQDR(int edge,
                       int slice,
                       int flags)
                throws EdgeOutOfRangeException,
                       SliceOutOfRangeException
```
    Retrieves a QDR object that represents the data value at the specified slice on the edge (that is, across all relevant logical layers of the slice).
    
    Specified by:
    
    getSliceQDR in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of in which to find the slice. The constants end with _EDGE in DataDirector.
    
    slice - An absolute index (zero-based) that indicates the location of the slice along the specified edge.
    
    flags - A constant that identifies whether to include page edge information if the QDR is not for the page edge. Valid constants are listed in the See Also section.
    
    Returns:
    
    QDR object that refers to the data at the specified location. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If the edge parameter is not valid.
    
    SliceOutOfRangeException - If the slice parameter is not valid.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataAccess.QDR_WITH_PAGE, DataAccess.QDR_WITHOUT_PAGE
  - getMemberQDR
```
public QDR getMemberQDR(int edge,
                        int layer,
                        int slice,
                        int flags)
                 throws EdgeOutOfRangeException,
                        LayerOutOfRangeException,
                        SliceOutOfRangeException
```
    Retrieves a QDR object that represents the data value for the member at the specified edge, layer, and slice.
    
    Specified by:
    
    getMemberQDR in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    layer - A zero-based index that represents the physical layer of the member for which the QDR object is requested.
    
    slice - An absolute index (zero-based) that indicates the location, along the specified edge, of a slice that belongs to the member for which the QDR object is requested.
    
    flags - A constant that identifies whether to include page edge information if the QDR is not for the page edge. Valid constants are listed in the See Also section.
    
    Returns:
    
    QDR object that refers to the data at the specified position. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is not valid.
    
    LayerOutOfRangeException - If layer is not valid for the specified edge.
    
    SliceOutOfRangeException - If slice is not valid for the specified edge and layer.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataAccess.QDR_WITH_PAGE, DataAccess.QDR_WITHOUT_PAGE
  - getMemberQDR
```
public QDR getMemberQDR(int edge,
                        int[] hPos,
                        int memberLayer,
                        int flags)
                 throws EdgeOutOfRangeException,
                        LayerOutOfRangeException,
                        SliceOutOfRangeException
```
    Retrieves a QDR object that represents the specified member using hierarchical addressing.
    
    Specified by:
    
    getMemberQDR in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to find the member. The constants end with _EDGE in DataDirector.
    
    hPos - An array of relative indices that are organized by logical layer. The indices start at layer 0 and extend at least through the layer that is specified in memberLayer.
    
    memberLayer - The zero-based index into the hpos array that indicates the layer in which to find the member.
    
    flags - A constant that identifies whether to include page edge information if the QDR is not for the page edge. Valid constants are listed in the See Also section.
    
    Returns:
    
    QDR object that refers to the data at the specified hpos and memberlayer within the hpos. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is not valid.
    
    LayerOutOfRangeException - If memberLayer is not valid for the specified edge.
    
    SliceOutOfRangeException - If the values in the hpos array are not valid relative indices in the specified hierarchy.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataAccess.QDR_WITH_PAGE, DataAccess.QDR_WITHOUT_PAGE
  - getLayerQDR
```
public QDR getLayerQDR(int edge,
                       int layer,
                       int flags)
                throws EdgeOutOfRangeException,
                       LayerOutOfRangeException
```
    Retrieves the QDR object that represents the specified logical layer.
    
    Specified by:
    
    getLayerQDR in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to find the logical layer. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based index of the logical layer for which to return the QDR.
    
    flags - A constant that identifies whether to include page edge information if the QDR is not for the page edge. Valid constants are listed in the See Also section.
    
    Returns:
    
    QDR object that refers to the data in the specified layer. This implementation returns null.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is not valid.
    
    LayerOutOfRangeException - If the logical layer is not valid for the specified edge.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataAccess.QDR_WITH_PAGE, DataAccess.QDR_WITHOUT_PAGE
  - getSlicesFromQDR
```
public int[] getSlicesFromQDR(QDRInterface qdr,
                              int[] startSlice,
                              int[] endSlice)
```
    Description copied from interface: DataAccess
    
    Returns an array of absolute slice positions in an edge-orderered array (column edge 0, row edge 1, etc.), given a QDR specifying a position in the current cursor. If a cell position corresponding to the QDR cannot be found, -1 values for the edge slices are returned. If this method has not been implemented, null is returned.
    
    Specified by:
    
    getSlicesFromQDR in interface DataAccess
    
    Parameters:
    
    qdr - QDR representing a position (edge member, edge slice, or data cell)
    
    startSlice - optional set of slices, ordered by edge (column edge 0, row edge 1, etc.), specifying the beginning of a viewport within which getSlicesFromQDR should check for the QDR. endSlices optional set of slices, ordered by edge (see startSlices), specifying the end of a viewport within which getSlicesFromQDR should check for the QDR.
    
    Returns:
    
    the location of the given QDR as an array of absolute slice positions, ordered by edge. If there is no edge in a particular set of data, the slice value will be -1 in that array position. If the QDR cannot be located or cannot be located within the given viewport if specified, -1 values will be returned. If the method is not implemented, null is returned.
  - findMember
```
public int findMember(int edge,
                      int[] hPos,
                      int memberLayer,
                      java.lang.String s,
                      java.lang.String type,
                      int flags)
               throws EdgeOutOfRangeException,
                      LayerOutOfRangeException,
                      SliceOutOfRangeException
```
    Searches a set of child members for the specified value starting at a specified offset. The child members are addressed as in getMemberChildCount. Returns the relative index in the specified hierarchical location for the member where the search value is found.
    
    Specified by:
    
    findMember in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge along which to search. The constants end with _EDGE in DataDirector.
    
    hPos - The hierarchically specified set of values to search. An array of relative indexes that are organized by logical layer. The indexes start at layer 0 and extend at least through the layer indicated by memberlayer. The relative indexes that are specified for the outermost layers indicate a parent tree of members; the relative index for the innermost layer indicates a zero-based starting position within the set of sibling members at which to start the search.
    
    memberLayer - The zero-based index into the hPos array for indicating the starting position for the search operation.
    
    s - The String to find.
    
    type - A constant that indicates the type of metadata for which to search. Valid type values are defined in MetadataMap.
    
    flags - The type of search - not yet defined.
    
    Returns:
    
    The relative index of the member in which the search value was found. Returns -1 if the String is not found. This implementation returns -1.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is invalid.
    
    LayerOutOfRangeException - If memberlayer is invalid for the edge.
    
    SliceOutOfRangeException - If hPos that are not valid relative indexes 0.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - findMembers
```
public int[] findMembers(int edge,
                         int[] hPos,
                         int memberLayer,
                         java.lang.String s,
                         java.lang.String type,
                         int flags)
                  throws EdgeOutOfRangeException,
                         LayerOutOfRangeException,
                         SliceOutOfRangeException
```
    Description copied from interface: DataAccess
    
    Searches a set of child members for the specified value starting at a specified offset, and returns all instances found as an array of slices. The child members are addressed as in getMemberChildCount. Returns the relative index in the specified hierarchical location for the member where the search value is found.
    
    Specified by:
    
    findMembers in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge along which to search. The constants end with _EDGE in DataDirector.
    
    hPos - The hierarchically specified set of values to search. An array of relative indexes that are organized by logical layer. The indexes start at layer 0 and extend at least through the layer indicated by memberlayer. The relative indexes that are specified for the outermost layers indicate a parent tree of members; the relative index for the innermost layer indicates a zero-based starting position within the set of sibling members at which to start the search.
    
    memberLayer - The zero-based index into the hPos array for indicating the starting position for the search operation.
    
    s - The String to find.
    
    type - A constant that indicates the type of metadata for which to search. Valid type values are defined in MetadataMap.
    
    flags - The type of search using constants, some constants that affect case sensitivity may be ANDed with the actual type of the search. The valid constants begin with FIND_ in this class.
    
    Returns:
    
    The relative indices of the member in which the search value was found. Returns null if the String is not found.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is invalid.
    
    LayerOutOfRangeException - If memberlayer is invalid for the edge.
    
    SliceOutOfRangeException - If hPos that are not valid relative indexes 0.
    
    See Also:
    
    DataAccess.FIND_EXACT, DataAccess.FIND_CONTAINS, DataAccess.FIND_STARTS_WITH, DataAccess.FIND_ENDS_WITH, DataAccess.FIND_CASE_INSENSITIVE, DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - release
```
public void release()
```
    Informs the implementor that the caller no longer needs this DataAccess reference. Provides an opportunity for cleaning up the cursor when a caller is finished with it.
    Views should not call this method for normal DataAccess instances, because calling this method makes the DataAccess reference unavailable to other presentation beans that might be using it. This method is useful only in special cases where a caller has wrapped a DataAccess around a private single-layer cursor.
    The implementor may or may not implement this method, depending on the underlying cursor.
    
    Specified by:
    
    release in interface DataAccess
    
    Specified by:
    
    release in interface DataDirector
  - startGroupEdit
```
public void startGroupEdit()
```
    Indicates the start of a group of setValue calls. This group of setValue calls will be treated as a unit in terms of undo and redo actions. For this reason, it is important that endGroupEdit is called when the client finishes the group editing.
    
    Specified by:
    
    startGroupEdit in interface DataAccess
    
    See Also:
    
    setValue(java.lang.Object, int, int, java.lang.String), endGroupEdit()
  - endGroupEdit
```
public void endGroupEdit()
```
    Indicates the end of a group of setValue calls. This group of setValue calls will be treated as a unit in terms of undo and redo actions.
    
    Specified by:
    
    endGroupEdit in interface DataAccess
    
    See Also:
    
    setValue(java.lang.Object, int, int, java.lang.String), startGroupEdit()
  - submitChanges
```
public boolean submitChanges()
```
    Writes the current group of QDR overrides in the writeback collection to the database and flushes the entries in the writeback collection. This implementation returns false.
    
    Specified by:
    
    submitChanges in interface DataAccess
    
    Returns:
    
    true if changes are submitted successfully; false if changes are not submitted successfully.
  - undoEdit
```
public boolean undoEdit()
```
    Performs an undo of the latest setValue operation. This implementation returns false.
    
    Specified by:
    
    undoEdit in interface DataAccess
    
    Returns:
    
    true if the undo was successful; false if the undo was not successful.
  - redoEdit
```
public boolean redoEdit()
```
    Performs a redo of the latest undo action. This implementation returns false.
    
    Specified by:
    
    redoEdit in interface DataAccess
    
    Returns:
    
    true if the redo was successful; false if the redo was not successful.
  - dropChanges
```
public boolean dropChanges()
```
    Clears the QDR overrides in the writeback collection. This implementation returns false.
    
    Specified by:
    
    dropChanges in interface DataAccess
    
    Returns:
    
    true if the clear operation was successful; false if the clear operation was not successful.
  - setAutoSubmit
```
public void setAutoSubmit(boolean bValue)
```
    Specifies that the QDR override in the writeback collection for a cell will be submitted automatically as soon as it is entered.
    
    Specified by:
    
    setAutoSubmit in interface DataAccess
    
    Parameters:
    
    bValue - true specifies automatic submission; false specifies no automatic submission.
  - isAutoSubmit
```
public boolean isAutoSubmit()
```
    Indicates whether automatic submission is set for cell editing. This implementation returns false.
    
    Specified by:
    
    isAutoSubmit in interface DataAccess
    
    Returns:
    
    true specifies that automatic submission is set for cell editing; false specifies that automatic submission is not set for cell editing.
  - getQDRoverrideCollection
```
public java.util.Vector getQDRoverrideCollection()
```
    Retrieves a read-only copy of the QDR overrides in the writeback collection.
    This implementation returns null.
    
    Specified by:
    
    getQDRoverrideCollection in interface DataAccess
    
    Returns:
    
    The read-only copy of the QDR overrides in the writeback collection.
  - getUniqueMemberMetadata
```
public java.util.List getUniqueMemberMetadata(int edge,
                                              int layer,
                                              java.lang.String[] types,
                                              int start,
                                              int count)
                                       throws EdgeOutOfRangeException,
                                              LayerOutOfRangeException
```
    Description copied from interface: DataAccess
    
    Returns an unordered List of Object arrays representing metadata for unique member values across a layer on an edge. The Object arrays correspond one-to-one with the MetadataMap types specified in the types parameter. An example of a types array might be: new String[] {MetadataMap.METADATA_VALUE, MetadataMap.METADATA_LONGLABEL} In this case, the method would return the unique set of values and their longlabels found across the given layer on the given edge. This list will be complete if the layer does not depend on any other layers (symmetric). If it is asymmetric, the number of items scanned will be constrained by no more than count number of unique items or an implementation-dependent limitation on the number of outer layer parents scanned. The return value might be: listElement(0) = new Object[] {"TOTALPROD", "Total Products"} listElement(1) = new Object[] {"AUDIODIV", "Audio Division"} listElement(2) = new Object[] {"CAMCORDER", "Camcorder"}\ If start were 1 and count were -1, then only listElement items 1 and 2 would be returned as the 0th and 1th items in the List. Normally, start will be 0 and count will be -1.
    
    Specified by:
    
    getUniqueMemberMetadata in interface DataAccess
    
    Parameters:
    
    edge - The edge containing the layer for which to build the member list
    
    layer - The zero-based index of the physical layer for which to build the member list
    
    types - An array of MetadataMap types indicating the nature of the returned metadata in the Vector elements
    
    start - Starting point in the overall unique member list of the return list. Zero indicates start from the beginning.
    
    count - Maximum number of unique values to return, beginning at index start. -1 indicates all values should be returned. Ignored in symmetric cases. The caller is free to ignore values returned beyond their requested count if they are managing fixed size virtual buffers.
    
    Returns:
    
    a Vector of Object arrays, with each element of the Vector representing one unique member for the given edge and layer. Each element of the Object array corresponds to the metadata specified one-for-one in the types parameter.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.ROW_EDGE, DataDirector.PAGE_EDGE, MetadataMap
    
    For internal use only. Application developers should not use this
    
    Returns an unordered Vector of Object arrays representing unique (by value) metadata across a layer on an edge. The Object arrays correspond one-to-one with the MetadataMap types specified in the types parameter. An example of a types array might be: new String[] {MetadataMap.METADATA_VALUE, MetadataMap.METADATA_LONGLABEL} In this case, the method would return the unique set of values and their longlabels found across the given layer on the given edge. This list will be complete if the layer does not depend on any other layers (symmetric). If it is asymmetric, the number of items scanned will be constrained by no more than count number of unique items or an implementation-dependent limitation on the number of outer layer parents scanned. The return value might be: vecElement(0) = new Object[] {"TOTALPROD", "Total Products"} vecElement(1) = new Object[] {"AUDIODIV", "Audio Division"} vecElement(2) = new Object[] {"CAMCORDER", "Camcorder"} If start were 1 and count were -1, then only vecElement items 1 and 2 would be returned as the 0th and 1th items in the Vector. Normally, start will be 0 and count will be -1.
  - getUniqueMemberMetadata
```
public java.util.List getUniqueMemberMetadata(java.lang.String layerName,
                                              java.lang.String[] types,
                                              int start,
                                              int count)
                                       throws LayerOutOfRangeException,
                                              SliceOutOfRangeException
```
    Description copied from interface: DataAccess
    
    Returns an unordered List of Object arrays representing metadata for unique member values across a layer on an edge. The Object arrays correspond one-to-one with the MetadataMap types specified in the types parameter. An example of a types array might be: new String[] {MetadataMap.METADATA_VALUE, MetadataMap.METADATA_LONGLABEL} In this case, the method would return the unique set of values and their longlabels found across the given layerName layer. This list will be complete if the layer does not depend on any other layers (symmetric). If it is asymmetric, the number of items scanned will be constrained by no more than count number of unique items or an implementation-dependent limitation on the number of outer layer parents scanned. The return value might be: listElement(0) = new Object[] {"TOTALPROD", "Total Products"} listElement(1) = new Object[] {"AUDIODIV", "Audio Division"} listElement(2) = new Object[] {"CAMCORDER", "Camcorder"}\ If start were 1 and count were -1, then only listElement items 1 and 2 would be returned as the 0th and 1th items in the List. Normally, start will be 0 and count will be -1.
    
    Specified by:
    
    getUniqueMemberMetadata in interface DataAccess
    
    Parameters:
    
    layerName - The name of the layer at which to find the given values. This value should correspond to a name obtained via a dataAccess.getLayerMetadata(edge, layer, LayerMetadataMap.LAYER_METADATA_NAME) call.
    
    types - An array of MetadataMap types indicating the nature of the returned metadata in the Vector elements
    
    start - Starting point in the overall unique member list of the return list. Zero indicates start from the beginning.
    
    count - Maximum number of unique values to return, beginning at index start. -1 indicates all values should be returned. Ignored in symmetric cases. The caller is free to ignore values returned beyond their requested count if they are managing fixed size virtual buffers.
    
    Returns:
    
    a Vector of Object arrays, with each element of the Vector representing one unique member for the given layer. Each element of the Object array corresponds to the metadata specified one-for-one in the types parameter.
    
    Throws:
    
    LayerOutOfRangeException - If the layerName is not found at any edge or layer in the DataAccess.
    
    SliceOutOfRangeException - If a problem with counting the members occurs
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.ROW_EDGE, DataDirector.PAGE_EDGE, MetadataMap, LayerMetadataMap
    
    For internal use only. Application developers should not use this
    
    Returns an unordered Vector of Object arrays representing unique (by value) metadata across a named layer. The Object arrays correspond one-to-one with the MetadataMap types specified in the types parameter. An example of a types array might be: new String[] {MetadataMap.METADATA_VALUE, MetadataMap.METADATA_LONGLABEL} In this case, the method would return the unique set of values and their longlabels found across the given layer. This list will be complete if the layer does not depend on any other layers (symmetric). If it is asymmetric, the number of items scanned will be constrained by no more than count number of unique items or an implementation-dependent limitation on the number of outer layer parents scanned. The return value might be: vecElement(0) = new Object[] {"TOTALPROD", "Total Products"} vecElement(1) = new Object[] {"AUDIODIV", "Audio Division"} vecElement(2) = new Object[] {"CAMCORDER", "Camcorder"} If start were 1 and count were -1, then only vecElement items 1 and 2 would be returned as the 0th and 1th items in the Vector. Normally, start will be 0 and count will be -1.
  - getCorrespondingMemberMetadata
```
public java.util.List getCorrespondingMemberMetadata(int edge,
                                                     int layer,
                                                     java.lang.String[] values,
                                                     java.lang.String[] types,
                                                     boolean inDataAccess)
                                              throws EdgeOutOfRangeException,
                                                     LayerOutOfRangeException
```
    Description copied from interface: DataAccess
    
    Returns a List of Object arrays of member metadata corresponding to the given MetadataMap.METADATA_VALUE strings specified in the values parameter. The Object arrays correspond one-to-one with the MetadataMap types in the types parameter. For example, a call such as: List listElement = dataAccess.getCorrespondingMemberMetadata( DataDirector.COLUMN_EDGE, 1, new String[] {"UK", "AMERICAS"}, new String[] {MetadataMap.METADATA_LONGLABEL, MetadataMap.METADATA_INDENT}, true); would return, assuming UK and AMERICAS were contained in the current DataAccess results at the column edge, layer 1: listElement(0) = {"United Kingdom", 2.0} listElement(1) = {"Areas in the Americas", 1.0} The inDataAccess parameter is for future use for finding metadata that may be outside the current DataAccess results.
    
    Specified by:
    
    getCorrespondingMemberMetadata in interface DataAccess
    
    Parameters:
    
    edge - The edge in which to find the layer potentially containing the given values.
    
    layer - The layer in which to find the given values.
    
    types - An array of MetadataMap types indicating the nature of the returned metadata in the Vector elements
    
    inDataAccess - Assumed to be true at this time. Only return corresponding Metadata for values found in DataAccess. The returned Vector will contain a null element for values that are not found at all.
    
    Returns:
    
    A Vector of Object arrays containing corresponding metadata information for the given list of values. The size of the Vector will match the size of the values parameter, but may contain null elements if a particular value or values were not found.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.ROW_EDGE, DataDirector.PAGE_EDGE, MetadataMap
    
    For internal use only. Application developers should not use this
    
    Returns a Vector of Object arrays of metadata values corresponding to the given MetadataMap.METADATA_VALUE strings given in the values parameter. The Object arrays represent the corresponding MetadataMap types in the types parameter, and match one-to-one. For example, a call such as: Vector vecElement = dataAccess.getCorrespondingMemberMetadata(DataDirector.COLUMN_EDGE, 1, new String[] {"UK", "AMERICAS"}, new String[] {MetadataMap.METADATA_LONGLABEL, MetadataMap.METADATA_INDENT}, true); would return, assuming UK and AMERICAS were contained in the current DataAccess results at the column edge, layer 1: vecElement(0) = {"United Kingdom", 2.0} vecElement(1) = {"Areas in the Americas", 1.0} The inDataAccess parameter is for future use for finding metadata for values in a layer that may be outside the current DataAccess cursors.
  - getCorrespondingMemberMetadata
```
public java.util.List getCorrespondingMemberMetadata(java.lang.String layerName,
                                                     java.lang.String[] values,
                                                     java.lang.String[] types,
                                                     boolean inDataAccess)
                                              throws LayerOutOfRangeException
```
    Description copied from interface: DataAccess
    
    Returns a List of Object arrays of member metadata corresponding to the given MetadataMap.METADATA_VALUE strings specified in the values parameter. The Object arrays correspond one-to-one with the MetadataMap types in the types parameter. For example, a call such as: List listElement = dataAccess.getCorrespondingMemberMetadata( "MDM!D_XADEMO.GEOGRAPHY", new String[] {"UK", "AMERICAS"}, new String[] {MetadataMap.METADATA_LONGLABEL, MetadataMap.METADATA_INDENT}, true); would return, assuming UK and AMERICAS were contained in the current DataAccess results at the layer named "MDM!D_XADEMO.GEOGRAPHY": listElement(0) = {"United Kingdom", 2.0} listElement(1) = {"Areas in the Americas", 1.0} The inDataAccess parameter is for future use for finding metadata that may be outside the current DataAccess results.
    
    Specified by:
    
    getCorrespondingMemberMetadata in interface DataAccess
    
    Parameters:
    
    layerName - The name of the layer at which to find the given values. This value should correspond to a name obtained via a dataAccess.getLayerMetadata(edge, layer, LayerMetadataMap.LAYER_METADATA_NAME) call.
    
    types - An array of MetadataMap types indicating the nature of the returned metadata in the Vector elements
    
    inDataAccess - Assumed to be true at this time. Only return corresponding Metadata for values found in DataAccess. The returned Vector will contain a null element for values that are not found at all.
    
    Returns:
    
    A Vector of Object arrays containing corresponding metadata information for the given list of values. The size of the Vector will match the size of the values parameter, but may contain null elements if a particular value or values were not found.
    
    Throws:
    
    LayerOutOfRangeException - If the layerName is not found at any edge and layer in the DataAccess.
    
    See Also:
    
    MetadataMap, LayerMetadataMap
    
    For internal use only. Application developers should not use this
    
    Returns a Vector of Object arrays of metadata values corresponding to the given MetadataMap.METADATA_VALUE strings given in the values parameter. The Object arrays represent the corresponding MetadataMap types in the types parameter, and match one-to-one. For example, a call such as: Vector vecElement = dataAccess.getCorrespondingMemberMetadata("MDM!D_XADEMO.GEOGRAPHY", new String[] {"UK", "AMERICAS"}, new String[] {MetadataMap.METADATA_LONGLABEL, MetadataMap.METADATA_INDENT}, true); would return, assuming UK and AMERICAS were contained in the current DataAccess results at the layer named "MDM!D_XADEMO.GEOGRAPHY": vecElement(0) = {"United Kingdom", 2.0} vecElement(1) = {"Areas in the Americas", 1.0} The inDataAccess parameter is for future use for finding metadata for values in a layer that may be outside the current DataAccess cursors.
  - allSlicesFetched
```
public boolean allSlicesFetched(int edge)
                         throws EdgeOutOfRangeException
```
    Returns true if all slices the entire given edge have been fetched and are available. A true return value implies that the value returned by getEdgeExtent for the same edge parameter is the actual total number of slices available on the edge. A false value indicates that the getEdgeExtent return value represents the number of slices available without further data fetching, but that the implementation believes there are more slices available and that fetching of these slices will occur upon a forceFetch call or other implementation-specific view/DataSource interactions
    
    Specified by:
    
    allSlicesFetched in interface DataAccess
    
    Parameters:
    
    edge - The edge for which to determine if all slices have been fetched
    
    Returns:
    
    true if all slices have been fetched
    
    Throws:
    
    EdgeOutOfRangeException - If edge is invalid
  - pivot
```
public boolean pivot(int fromEdge,
                     int toEdge,
                     int fromLayer,
                     int toLayer,
                     int flags)
              throws EdgeOutOfRangeException,
                     LayerOutOfRangeException,
                     DataDirectorException
```
    Pivots or swaps data. Operations include:
    - Moving layers from one edge to another
    - Moving layers from one location on an edge to another location on the same edge
    - Swapping the locations of two layers
    - Swapping two edges
    This implementation returns false.
    Specified by:
    
    pivot in interface DataDirector
    
    Parameters:
    
    fromEdge - A constant that indicates the edge from which a layer should be pivoted. Valid constants end with _EDGE in this interface.
    
    toEdge - A constant that indicates the edge to which a layer should be pivoted. Valid constants end with _EDGE in this interface.
    
    fromLayer - The zero-based index of the physical layer on the fromEdge that should be pivoted or swapped. The outermost layer on the edge is 0. Note that a Table object will report columns as its layers.
    
    toLayer - The zero-based index of the physical layer on the toEdge that should be pivoted or swapped. The outermost layer on the edge is 0. Note that a Table object will report columns as its layers.
    
    flags - A constant that indicates the type of pivot to perform. The constants begin with PIVOT_ in this interface.
    
    Returns:
    
    true if the pivot is successful, false if not.
    
    Throws:
    
    EdgeOutOfRangeException - If either edge is too large.
    
    LayerOutOfRangeException - If either layer is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.DATA_ELEMENT_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataDirector.PIVOT_EDGES, DataDirector.PIVOT_MOVE_AFTER, DataDirector.PIVOT_MOVE_BEFORE, DataDirector.PIVOT_MOVE_TO, DataDirector.PIVOT_SWAP
  - pivotOK
```
public boolean pivotOK(int fromEdge,
                       int toEdge,
                       int fromLayer,
                       int toLayer,
                       int flags)
                throws EdgeOutOfRangeException,
                       LayerOutOfRangeException,
                       DataDirectorException
```
    Indicates whether the specified pivot operation would be valid for the current data layout. This method is called before the pivot method and does not perform the actual pivot. The data provider determines its own rules for valid pivot operations.
    This implementation returns false.
    
    Specified by:
    
    pivotOK in interface DataDirector
    
    Parameters:
    
    fromEdge - A constant that indicates the edge from which a layer should be pivoted. Valid constants end with _EDGE in this interface.
    
    toEdge - A constant that indicates the edge to which a layer should be pivoted. Valid constants end with _EDGE in this interface.
    
    fromLayer - The zero-based index of the physical layer on the fromEdge that should be pivoted or swapped. The outermost layer on the edge is 0. Note that a Table object will report columns as its layers.
    
    toLayer - The zero-based index of the physical layer on the toEdge that should be pivoted or swapped. The outermost layer on the edge is 0. Note that a Table object will report columns as its layers.
    
    flags - A constant that indicates the type of pivot to perform. The constants begin with PIVOT_ in this interface.
    
    Returns:
    
    true if the pivot is legal according to the data provider's rules, false if the pivot is not legal according to the data provider's rules.
    
    Throws:
    
    EdgeOutOfRangeException - If either edge is too large.
    
    LayerOutOfRangeException - If either depth is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.DATA_ELEMENT_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataDirector.PIVOT_EDGES, DataDirector.PIVOT_MOVE_AFTER, DataDirector.PIVOT_MOVE_BEFORE, DataDirector.PIVOT_MOVE_TO, DataDirector.PIVOT_SWAP
  - pivotCheck
```
public int pivotCheck(int fromEdge,
                      int toEdge,
                      int fromLayer,
                      int toLayer,
                      int flags)
               throws EdgeOutOfRangeException,
                      LayerOutOfRangeException,
                      DataDirectorException
```
    Description copied from interface: DataDirector
    
    Indicates whether the specified pivot operation would be valid for the current data layout. This method is called before the pivot method and does not perform the actual pivot. The data provider determines its own rules for valid pivot operations.
    
    Specified by:
    
    pivotCheck in interface DataDirector
    
    Parameters:
    
    fromEdge - A constant that indicates the edge from which a layer should be pivoted. Valid constants end with _EDGE in this interface.
    
    toEdge - A constant that indicates the edge to which a layer should be pivoted. Valid constants end with _EDGE in this interface.
    
    fromLayer - The zero-based index of the physical layer on the fromEdge that should be pivoted or swapped. The outermost layer on the edge is 0. Note that a Table object will report columns as its layers.
    
    toLayer - The zero-based index of the physical layer on the toEdge that should be pivoted or swapped. The outermost layer on the edge is 0. Note that a Table object will report columns as its layers.
    
    flags - A constant that indicates the type of pivot to perform. The constants begin with PIVOT_ in this interface.
    
    Returns:
    
    constant indicating if the pivot was legal, and if not, an indication as to why not.
    
    Throws:
    
    EdgeOutOfRangeException - If either edge is too large.
    
    LayerOutOfRangeException - If either layer is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.DATA_ELEMENT_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataDirector.PIVOT_EDGES, DataDirector.PIVOT_MOVE_AFTER, DataDirector.PIVOT_MOVE_BEFORE, DataDirector.PIVOT_MOVE_TO, *
  - drill
```
public boolean drill(int edge,
                     int layer,
                     int slice,
                     int flags)
              throws EdgeOutOfRangeException,
                     LayerOutOfRangeException,
                     SliceOutOfRangeException,
                     DataDirectorException
```
    Drills in the data for a single member.
    This implementation returns false.
    
    Specified by:
    
    drill in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge to drill. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer of the member to be drilled. The outermost layer on the edge is 0.
    
    slice - The zero-based index (along the specified edge) of the slice that represents the member that is to be drilled. Each member in the innermost layer has a unique slice. In outer layers, any slice that the member spans can be used.
    
    flags - Not yet defined.
    
    Returns:
    
    true if the drill operation is successful; false if the drill operation is not successful.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - drillOK
```
public boolean drillOK(int edge,
                       int layer,
                       int slice,
                       int flags)
                throws EdgeOutOfRangeException,
                       LayerOutOfRangeException,
                       SliceOutOfRangeException,
                       DataDirectorException
```
    Indicates whether a drill operation from a single selected member would be legal. This method is called before the drill method and does not perform the actual drill.
    This implementation returns false.
    
    Specified by:
    
    drillOK in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge to drill. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer of the member that is to be drilled. The outermost layer on the edge is 0.
    
    slice - The zero-based index (along the specified edge) of the slice that represents the members that are to be drilled. Each member in the innermost layer has a unique slice. In outer layers, any slice that the member spans can be used.
    
    flags - Not yet defined.
    
    Returns:
    
    true if the specified drilling operation is legal, false if the specified operation is not legal.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - drill
```
public boolean drill(int edge,
                     int layer,
                     int[] slice,
                     int flags)
              throws EdgeOutOfRangeException,
                     LayerOutOfRangeException,
                     SliceOutOfRangeException,
                     DataDirectorException
```
    Drills in data based on multiple selected members.
    This implementation returns false.
    
    Specified by:
    
    drill in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge to drill. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer of the members to be drilled. The outermost layer on the edge is 0.
    
    slice - A list of the zero-based indexes (along the specified edge) of the slices that represent the members that are to be drilled. Each member in the innermost layer has a unique slice. In outer layers, any slice that the member spans can be used.
    
    flags - Not yet defined.
    
    Returns:
    
    true if the drill operation is successful, false if the drill operation is not successful.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - drillOK
```
public boolean drillOK(int edge,
                       int layer,
                       int[] slice,
                       int flags)
                throws EdgeOutOfRangeException,
                       LayerOutOfRangeException,
                       SliceOutOfRangeException,
                       DataDirectorException
```
    Indicates whether the specified drill operation from multiple selected members would be a valid drill. This method is called before the drill method and does not perform the actual drill.
    This implementation returns false.
    
    Specified by:
    
    drillOK in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge to drill. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer of the member to be drilled. The outermost layer on the edge is 0.
    
    slice - A list of the zero-based indexes (along the specified edge) of the slices that represent the members that are to be drilled. Each member in the innermost layer has a unique slice. In outer layers, any slice that the member spans can be used.
    
    flags - Not yet defined.
    
    Returns:
    
    true if this drilling operation is legal, false if not.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - changeEdgeCurrentSlice
```
public boolean changeEdgeCurrentSlice(int edge,
                                      int slice)
                               throws EdgeOutOfRangeException,
                                      SliceOutOfRangeException,
                                      DataDirectorException
```
    Changes the slice, on the specified edge, that is designated as the current slice of data. This method uses the slice parameter to indicate the new current slice.
    This implementation returns false.
    
    Specified by:
    
    changeEdgeCurrentSlice in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge on which to change the current slice. Valid constants end with _EDGE in this interface.
    
    slice - The zero-based index (along the specified edge) of the slice that is to become the current slice.
    
    Returns:
    
    true if the change is successful, false if the change is not successful.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    SliceOutOfRangeException - If slice is too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - changeEdgeCurrentHPos
```
public boolean changeEdgeCurrentHPos(int edge,
                                     int[] hPos,
                                     int maxLayerSpecified)
                              throws EdgeOutOfRangeException,
                                     LayerOutOfRangeException,
                                     SliceOutOfRangeException,
                                     DataDirectorException
```
    Changes the slice of data, on the specified edge, that is designated as the current slice by using hierarchical addressing. This method is generally used when paging controls change the current page of a view.
    This implementation returns false.
    
    Specified by:
    
    changeEdgeCurrentHPos in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge on which to make the change. Valid constants end with _EDGE in this interface.
    
    hPos - An array of relative indexes starting with the outermost layer and working in at least to maxLayerSpecified. This array indicates the set of new values to give to the various layers that specify the new current slice.
    
    maxLayerSpecified - The maximum index into hPos (layer) that this method should use in making the change to the current slice.
    
    Returns:
    
    true if the current slice change is successful, false if the current slice change is not successful.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If number of layers in hPos is too large.
    
    SliceOutOfRangeException - If the slices in hPos are too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - reorder
```
public boolean reorder(int edge,
                       int fromLayer,
                       int toLayer,
                       int flags)
                throws EdgeOutOfRangeException,
                       LayerOutOfRangeException,
                       DataDirectorException
```
    Reorders the layers (that is, columns) of a Table object. The flags parameter uses the pivot constants from this interface to specify the operation that is to be performed. These constants are as follows:
    - PIVOT_SWAP -- Swaps fromLayer with toLayer.
    - PIVOT_MOVE_BEFORE -- Moves fromLayer before toLayer.
    - PIVOT_MOVE_AFTER -- Moves fromLayer after toLayer.
    Specified by:
    
    reorder in interface DataDirector
    
    Parameters:
    
    edge - A constant that identifies the edge on which the reorder takes place. Valid constants end with _EDGE in this interface.
    
    fromLayer - The zero-based index of the physical layer (column) that the Table object wants to move. The outermost layer on the edge is 0.
    
    toLayer - The zero-based index of the physical layer (column) with which or to which the Table object is moving the fromLayer. The outermost layer on the edge is 0.
    
    flags - A constant that indicates the operation to be performed. The constants begin with PIVOT_ in this interface.
    
    Returns:
    
    true if reordering is successful, false if reordering is not successful.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.PIVOT_MOVE_AFTER, DataDirector.PIVOT_MOVE_BEFORE, DataDirector.PIVOT_SWAP, DataDirector.ROW_EDGE
  - insertValueCalc
```
public boolean insertValueCalc(int row,
                               int column,
                               int flags,
                               java.lang.Object calc)
                        throws RowOutOfRangeException,
                               ColumnOutOfRangeException,
                               DataDirectorException
```
    Inserts a calculation at a specified row and column in the body of a view's data.
    This implementation returns false.
    
    Specified by:
    
    insertValueCalc in interface DataDirector
    
    Parameters:
    
    row - The row at which to insert the calculation.
    
    column - The column at which to insert the calculation.
    
    flags - Not yet defined.
    
    calc - Not yet defined.
    
    Returns:
    
    true if the calculation is inserted, false if the calculation is not inserted.
    
    Throws:
    
    RowOutOfRangeException - If row is negative or too large.
    
    ColumnOutOfRangeException - If column is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
  - insertMemberCalc
```
public boolean insertMemberCalc(int edge,
                                int layer,
                                int slice,
                                int flags,
                                java.lang.Object calc)
                         throws EdgeOutOfRangeException,
                                LayerOutOfRangeException,
                                SliceOutOfRangeException,
                                DataDirectorException
```
    Inserts a calculation into a display based on the member at the specified edge, layer, and slice.
    This implementation returns false.
    
    Specified by:
    
    insertMemberCalc in interface DataDirector
    
    Parameters:
    
    edge - A constant that specifies the edge that contains the member at which to insert the calculation. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer that contains the member at which to insert the calculation. The outermost layer on the edge is 0.
    
    slice - The zero-based index (along the specified edge) of the slice at which to insert the calculation.
    
    flags - Not yet defined.
    
    calc - Not yet defined.
    
    Returns:
    
    true if the calculation is inserted, false if the calculation is not inserted.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - deleteValueCalc
```
public boolean deleteValueCalc(int row,
                               int column)
                        throws RowOutOfRangeException,
                               ColumnOutOfRangeException,
                               DataDirectorException
```
    Deletes a calculation at the specified row and column of the body of a data for a view. Deletes the calculation only if it is present at the specified location.
    This implementation returns false.
    
    Specified by:
    
    deleteValueCalc in interface DataDirector
    
    Parameters:
    
    row - The row at which to delete the calculation.
    
    column - The column at which to delete the calculation.
    
    Returns:
    
    true if the calculation is deleted, false if the calculation is not deleted.
    
    Throws:
    
    RowOutOfRangeException - If row is negative or too large.
    
    ColumnOutOfRangeException - If column is negative or too large.
    
    DataDirectorException - If a data provider error occurs
  - deleteMemberCalc
```
public boolean deleteMemberCalc(int edge,
                                int layer,
                                int slice)
                         throws EdgeOutOfRangeException,
                                LayerOutOfRangeException,
                                SliceOutOfRangeException,
                                DataDirectorException
```
    Deletes a calculation from the display based on a member that is located at the specified edge, layer, and slice. Deletes the calculation only if it is present at the specified location.
    This implementation returns false.
    
    Specified by:
    
    deleteMemberCalc in interface DataDirector
    
    Parameters:
    
    edge - A constant that specifies the edge that contains the member for which to delete the calculation. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer that contains the member for which to delete the calculation. The outermost layer on the edge is 0.
    
    slice - The zero-based index (along the specified edge) of the slice at which to delete the calculation.
    
    Returns:
    
    true if the calculation is deleted, false if the calculation is not deleted.
    
    Throws:
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice
    DataDirectorException - If a data provider error occurs.
    
    EdgeOutOfRangeException
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getDataAccess
```
public DataAccess getDataAccess()
                         throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Called by the view to get a current BaseDataAccess model of the data.
    
    Specified by:
    
    getDataAccess in interface DataDirector
    
    Returns:
    
    current model of data implemented via BaseDataAccess
    
    Throws:
    
    DataDirectorException
  - addDataDirectorListener
```
public void addDataDirectorListener(DataDirectorListener l)
```
    Registers a listener to the data source for changes. The DataDirector implementor is expected to fire a DataAvailableEvent in this routine when data is available and to provide an implementation of the DataAccess interface when data is ready.
    This implementation does nothing.
    
    Specified by:
    
    addDataDirectorListener in interface DataDirector
    
    Parameters:
    
    l - The listener to add.
  - removeDataDirectorListener
```
public void removeDataDirectorListener(DataDirectorListener l)
```
    Removes a listener from the data source.
    This implementation does nothing.
    
    Specified by:
    
    removeDataDirectorListener in interface DataDirector
    
    Parameters:
    
    l - The listener to remove.
  - refresh
```
public boolean refresh()
                throws DataDirectorException
```
    Refreshes data and fires a DataChangedEvent to all registered listeners. This method signals the implementor to refresh the data cache without rerunning the query.
    This implementation returns false.
    
    Specified by:
    
    refresh in interface DataDirector
    
    Returns:
    
    true if data will be refreshed, false if data will not be refreshed.
    
    Throws:
    
    DataDirectorException - If a data provider error occurs
  - revalidate
```
public boolean revalidate()
                   throws DataDirectorException
```
    Rebuilds (that is, reruns) a query, refreshes the data cache, and fires a DataChangedEvent.
    This implementation returns false.
    
    Specified by:
    
    revalidate in interface DataDirector
    
    Returns:
    
    true if data will be refreshed, false if data will not be refreshed
    
    Throws:
    
    DataDirectorException - If a data provider error occurs
  - setOutline
```
public void setOutline(boolean outline)
                throws DataDirectorException
```
    Specifies whether data is provided to a view in outline form. Updates the data and fires a DataChanged event. This is an optional method because implementors that do not require an outline display do not have to support outline form. Outline form lists outer layers in the same depth as inner layers, whereas inline form shows outer layers at different depths.
    For example, if the row edge uses outline form, all layers appear in the same label column. If the row edge does not use outline form, then there is a separate column for each layer.
    This implementation does nothing.
    
    Specified by:
    
    setOutline in interface DataDirector
    
    Parameters:
    
    outline - true to specify outline form for data, false to use inline form for data.
    
    Throws:
    
    DataDirectorException - If a data provider error occurs
  - isOutline
```
public boolean isOutline()
```
    Indicates whether data is provided in outline form or inline form. Outline form lists outer layers in the same depth as inner layers, whereas inline form shows outer layers at different depths. This method should always return false if the implementor does not support outline form.
    In a Crosstab, for example, if a row edge uses outline form, then all layers appear in the same label column. If a row edge does not use outline form, then there is a separate column for each layer.
    This implementation returns false.
    
    Specified by:
    
    isOutline in interface DataDirector
    
    Returns:
    
    true if the data is provided in outline form, false if the data is provided in inline form.
  - setMetadataMap
```
public void setMetadataMap(int edge,
                           int layer,
                           MetadataMap map,
                           int size)
                    throws EdgeOutOfRangeException,
                           LayerOutOfRangeException,
                           DataDirectorException
```
    Specifies the types of metadata to provide in the cursors for the specified logical layer.
    This implementation does nothing.
    
    Specified by:
    
    setMetadataMap in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge that contains the logical layer of interest. Valid constants end with _EDGE in this interface. To set a default map for all edges, pass -1.
    
    layer - The index for the logical layer whose MetadataMap is to be set. To refer to all of the layers on an edge, use -1.
    
    map - A list of the metadata types that the implementor should fetch for the specified layer, if possible.
    
    size - A suggested number of metatdata values that the data provider should fetch at a time. This is a guide for the data provider about the size of metadata chunks. This parameter is ignored if the implementor does not support partial fetches.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is out of range.
    
    LayerOutOfRangeException - If layer is out of range.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - setDataMap
```
public void setDataMap(DataMap map,
                       int sizeRow,
                       int sizeColumn)
                throws DataDirectorException
```
    Specifies the types of data to provide in a data cursor.
    This implementation does nothing.
    
    Specified by:
    
    setDataMap in interface DataDirector
    
    Parameters:
    
    map - A list of the data types that the caller expects in data cursors that the DataAccess implementation fetches.
    
    sizeRow - The suggested number of rows that the data provider should fetch at a time.
    
    sizeColumn - The suggested number of columns that the data provider should fetch at a time.
    
    Throws:
    
    DataDirectorException - If a data provider error occurs
  - getMetadataMap
```
public MetadataMap getMetadataMap(int edge,
                                  int layer)
                           throws EdgeOutOfRangeException,
                                  LayerOutOfRangeException
```
    Retrieves the list of all the types of metadata that callers have requested to be included in the cursors for the specified logical layer. This list includes the types of metadata that have been specified in setMetadataMap requests by any views that use this data provider.
    This implementation returns null.
    
    Specified by:
    
    getMetadataMap in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge that contains the logical layer. Valid constants end with _EDGE in this interface. A value of -1 is a request for the default MetadataMap.
    
    layer - A zero-based index for the logical layer for which to retrieve the metadata map. The outermost layer on the specified edge is zero. A layer value of -1 indicates all of the layers on the specified edge.
    
    Returns:
    
    The map that contains all of the types of metadata that are to be retrieved into the cursors for the layer.
    
    Throws:
    
    EdgeOutOfRangeException - if edge is out of range.
    
    LayerOutOfRangeException - If no layer exists at this location.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - getDataMap
```
public DataMap getDataMap()
```
    Retrieves the list of types of data that can be retrieved or set for each location in the data cursor. This list includes the types of data that have been specified in data maps by any views that use this data provider.
    This implmentation returns null.
    
    Specified by:
    
    getDataMap in interface DataDirector
    
    Returns:
    
    The map of available types of data.
  - isCancelable
```
public boolean isCancelable()
```
    Indicates whether this DataDirector implementor allows views to cancel an operation that takes a long time.
    This implementation returns false.
    
    Specified by:
    
    isCancelable in interface DataDirector
    
    Returns:
    
    true if the data provider supports cancelation of long operations, false if not.
  - cancel
```
public boolean cancel()
               throws DataDirectorException
```
    Cancels the current long-running operation, if possible.
    This implementation returns false.
    
    Specified by:
    
    cancel in interface DataDirector
    
    Returns:
    
    code>true if the implementor canceled the operation, false if the implementor did not or could not cancel the operation.
    
    Throws:
    
    DataDirectorException - If a data provider error occurs
  - setManualUpdate
```
public void setManualUpdate()
```
    Batches DataDirector operations. If the implementor supports command batching, operations between this call and a call to update are batched.
    This implementation does nothing.
    
    Specified by:
    
    setManualUpdate in interface DataDirector
    
    See Also:
    
    update()
  - update
```
public void update()
            throws DataDirectorException
```
    Processes batched DataDirector operations. Operations between a call to setManualUpdate and this method are batched. This method should also turn off manual update mode.
    This implementation does nothing.
    
    Specified by:
    
    update in interface DataDirector
    
    Throws:
    
    DataDirectorException - If a data provider error occurs
    
    See Also:
    
    setManualUpdate()
  - getSupportedMetadataMap
```
public MetadataMap getSupportedMetadataMap()
```
    Retrieves a MetadataMap that contains all of the types that this DataAccessAdapter can support. Some types of metadata might not be available in some types of queries.
    
    Specified by:
    
    getSupportedMetadataMap in interface DataDirector
    
    Returns:
    
    null.
    
    See Also:
    
    MetadataMap
  - getSupportedLayerMetadataMap
```
public LayerMetadataMap getSupportedLayerMetadataMap()
```
    Return a LayerMetadataMap that contains all of the types that this DataAccessAdapter can support. Some types of layer metadata might not be available in some types of queries.
    
    Specified by:
    
    getSupportedLayerMetadataMap in interface DataDirector
    
    Returns:
    
    null.
    
    See Also:
    
    LayerMetadataMap
  - getSupportedDataMap
```
public DataMap getSupportedDataMap()
```
    Return a DataMap that contains all of the types that this DataAccessAdapter can support. Some types of data might not be available in some types of queries.
    
    Specified by:
    
    getSupportedDataMap in interface DataDirector
    
    Returns:
    
    null.
    
    See Also:
    
    DataMap
  - drill
```
public boolean drill(int edge,
                     int layer,
                     int slice,
                     java.lang.String pathID,
                     java.lang.String targetID,
                     int flags)
              throws EdgeOutOfRangeException,
                     LayerOutOfRangeException,
                     SliceOutOfRangeException,
                     InvalidDrillPathException,
                     InvalidDrillTargetException,
                     DataDirectorException
```
    Drills in the data for a single member. NOTE: The list of valid Drill Path/Drill Target combinations is available from the current DataAccess instance.
    
    Specified by:
    
    drill in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge to drill. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer of the member to be drilled. The outermost layer on the edge is 0.
    
    slice - The zero-based index (along the specified edge) of the slice that represents the member that is to be drilled. Each member in the innermost layer has a unique slice. In outer layers, any slice that the member spans can be used. NOTE: A slice value of -1 indicates that the drill operation is to be applied uniformly across the layer.
    
    pathID - Drill Path ID for this drill operation.
    
    targetID - Drill Target ID for this drill operation.
    
    flags - Indicates the type of drill operation to perform.
    
    Returns:
    
    true if the drill operation is successful; false if the drill operation is not successful.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is too large or less than -1.
    
    InvalidDrillPathException - If path is invalid.
    
    InvalidDrillTargetException - If target is invalid.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, LayerMetadataMap.LAYER_METADATA_DRILLPATHS, MetadataMap.METADATA_DRILLPATHS, DataDirector.DRILL_COLLAPSE
  - drillOK
```
public boolean drillOK(int edge,
                       int layer,
                       int slice,
                       java.lang.String pathID,
                       java.lang.String targetID,
                       int flags)
                throws EdgeOutOfRangeException,
                       LayerOutOfRangeException,
                       SliceOutOfRangeException,
                       InvalidDrillPathException,
                       InvalidDrillTargetException,
                       DataDirectorException
```
    Indicates whether a drill operation from a single selected member would be legal. This method is called before the drill method and does not perform the actual drill. NOTE: The list of valid Drill Path/Drill Target combinations is available from the current DataAccess instance.
    
    Specified by:
    
    drillOK in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge to drill. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer of the member that is to be drilled. The outermost layer on the edge is 0.
    
    slice - The zero-based index (along the specified edge) of the slice that represents the member that is to be drilled. Each member in the innermost layer has a unique slice. In outer layers, any slice that the member spans can be used. NOTE: A slice value of -1 indicates that the drill operation is to be applied uniformly across the layer.
    
    pathID - Drill Path ID for this drill operation.
    
    targetID - Drill Target ID for this drill operation.
    
    flags - Indicates the type of drill operation to be performed.
    
    Returns:
    
    true if the specified drilling operation is legal, false if the specified operation is not legal.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is too large or less than -1.
    
    InvalidDrillPathException - If path is invalid.
    
    InvalidDrillTargetException - If target is invalid.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, LayerMetadataMap.LAYER_METADATA_DRILLPATHS, MetadataMap.METADATA_DRILLPATHS, DataDirector.DRILL_COLLAPSE
  - drill
```
public boolean drill(int edge,
                     int layer,
                     int[] slice,
                     java.lang.String pathID,
                     java.lang.String targetID,
                     int flags)
              throws EdgeOutOfRangeException,
                     LayerOutOfRangeException,
                     SliceOutOfRangeException,
                     InvalidDrillPathException,
                     InvalidDrillTargetException,
                     DataDirectorException
```
    Drills in the data for multiple members. NOTE: The list of valid Drill Path/Drill Target combinations is available from the current DataAccess instance.
    
    Specified by:
    
    drill in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge to drill. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer of the member to be drilled. The outermost layer on the edge is 0.
    
    slice - A list of the zero-based indexes (along the specified edge) of the slices that represent the members to be drilled. Each member in the innermost layer has a unique slice. In outer layers, any slice that the member spans can be used.
    
    pathID - Drill Path ID for this drill operation.
    
    targetID - Drill Target ID for this drill operation.
    
    flags - Indicates the type of drill operation to perform.
    
    Returns:
    
    true if the drill operation is successful, false if the drill operation is not successful.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    InvalidDrillPathException - If path is invalid.
    
    InvalidDrillTargetException - If target is invalid.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, LayerMetadataMap.LAYER_METADATA_DRILLPATHS, MetadataMap.METADATA_DRILLPATHS, DataDirector.DRILL_COLLAPSE
  - drillOK
```
public boolean drillOK(int edge,
                       int layer,
                       int[] slice,
                       java.lang.String pathID,
                       java.lang.String targetID,
                       int flags)
                throws EdgeOutOfRangeException,
                       LayerOutOfRangeException,
                       SliceOutOfRangeException,
                       InvalidDrillPathException,
                       InvalidDrillTargetException,
                       DataDirectorException
```
    Indicates whether the specified drill operation from multiple selected members would be a valid drill. This method is called before the drill method and does not perform the actual drill. NOTE: The list of valid Drill Path/Drill Target combinations is available from the current DataAccess instance.
    
    Specified by:
    
    drillOK in interface DataDirector
    
    Parameters:
    
    edge - A constant that indicates the edge to drill. Valid constants end with _EDGE in this interface.
    
    layer - The zero-based index of the physical layer of the member to be drilled. The outermost layer on the edge is 0.
    
    slice - A list of the zero-based indexes (along the specified edge of the slices that represent the members that are to be drilled. Each member in the innermost layer has a unique slice. In outer layers, any slice that the member spans can be used.
    
    pathID - Drill Path ID for this drill operation.
    
    targetID - Drill Target ID for this drill operation.
    
    flags - Indicates the type of drill operation to be performed.
    
    Returns:
    
    true if this drilling operation is legal, false if not.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    InvalidDrillPathException - If path is invalid.
    
    InvalidDrillTargetException - If target is invalid.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, LayerMetadataMap.LAYER_METADATA_DRILLPATHS, MetadataMap.METADATA_DRILLPATHS, DataDirector.DRILL_COLLAPSE
  - setSorts
```
public boolean setSorts(SortInfo[] sortInfo)
                 throws LayerOutOfRangeException,
                        DataDirectorException
```
    Allows sorting by N dimension items on a crosstab-style view, with each item optionally sorted by its own measure fact/dimension item combinations or by the item text. Any settings made through this API are considered the entire set of sort criteria for the DataDirector: the given sort criteria replace previously set sort criteria.
    
    Specified by:
    
    setSorts in interface DataDirector
    
    Parameters:
    
    sortInfo - An array of SortInfo objects. Each SortInfo object may specify one or more sort criterion by which to sort its corresponding dimension item. QDRSortInfo objects may be passed for items to sort by measure fact/dimension item combinations, or SortInfo objects may be passed to sort items by their text.
    
    Returns:
    
    true if the sort operation is successful, false if the sort operation is not successful.
    
    Throws:
    
    LayerOutOfRangeException - If layerName is invalid.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataDirector.SORT_DIRECTION_ASCENDING, DataDirector.SORT_DIRECTION_DESCENDING
  - getSorts
```
public SortInfo[] getSorts()
                    throws LayerOutOfRangeException,
                           DataDirectorException
```
    Retrieves sorting information for given layers on a crosstab-style view.
    
    Specified by:
    
    getSorts in interface DataDirector
    
    Returns:
    
    An array of SortInfo objects. These may be QDRSortInfo objects for items sorted by facts or SortInfo objects for items sorted by their text.
    
    Throws:
    
    LayerOutOfRangeException - If layerName is invalid.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataDirector.SORT_DIRECTION_ASCENDING, DataDirector.SORT_DIRECTION_DESCENDING
  - setColumnSorts
```
public boolean setColumnSorts(ColumnSortInfo[] sortInfo)
                       throws LayerOutOfRangeException,
                              DataDirectorException
```
    Allows sorting by dimension items on a table-style view. Any settings made through this API are considered the entire set of sort criteria for the DataDirector: the given sort criteria replace previously set sort criteria.
    
    Specified by:
    
    setColumnSorts in interface DataDirector
    
    Parameters:
    
    sortInfo - An array of ColumnSortInfo objects. Each ColumnSortInfo object may specify a sort criterion by which to sort its corresponding dimension item.
    
    Returns:
    
    true if the sort operation is successful, false if the sort operation is not successful.
    
    Throws:
    
    LayerOutOfRangeException - If layerName is invalid.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataDirector.SORT_DIRECTION_ASCENDING, DataDirector.SORT_DIRECTION_DESCENDING, DataDirector.SORT_TYPE_GROUPSORT, DataDirector.SORT_TYPE_GROUPSORT_PAGEBREAK
  - getColumnSorts
```
public ColumnSortInfo[] getColumnSorts()
                                throws LayerOutOfRangeException,
                                       DataDirectorException
```
    Retrieves sorting information for given layers on a table-style view.
    
    Specified by:
    
    getColumnSorts in interface DataDirector
    
    Returns:
    
    An array of ColumnSortInfo objects.
    
    Throws:
    
    LayerOutOfRangeException - If layerName is invalid.
    
    DataDirectorException - If a data provider error occurs.
    
    See Also:
    
    DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE, DataDirector.SORT_DIRECTION_ASCENDING, DataDirector.SORT_DIRECTION_DESCENDING, DataDirector.SORT_TYPE_GROUPSORT, DataDirector.SORT_TYPE_GROUPSORT_PAGEBREAK
  - setProperty
```
public void setProperty(java.lang.String name,
                        java.lang.Object value)
                 throws DataDirectorException
```
    Sets a property on a DataDirector2 object. The choices of properties are defined in DataDirector2, and the property's values depend on the definition of the property.
    
    Specified by:
    
    setProperty in interface DataDirector
    
    Parameters:
    
    name - The name of the property whose value is changing. Valid property names have constants defined in DataDirector2 or its extensions. Implementations may or may not make use of any particular property, and their persistence is NOT guaranteed.
    
    value - A value to apply to the specified property. Valid values are determined by the particular property.
    
    Throws:
    
    DataDirectorException - thrown if an error occurs setting the specified property
  - getProperty
```
public java.lang.Object getProperty(java.lang.String name)
                             throws DataDirectorException
```
    Gets a property from a DataDirector2 object. The choices of properties are defined in DataDirector2, and the property's values depend on the definition of the property.
    
    Specified by:
    
    getProperty in interface DataDirector
    
    Parameters:
    
    name - The name of the property whose value is requested. Valid property names have constants defined in DataDirector2 or its extensions. Implementations may or may not make use of any particular property, and their persistence is NOT guaranteed.
    
    Returns:
    
    The value of the specified property. Valid values are determined by the particular property.
    
    Throws:
    
    DataDirectorException - thrown if an error occurs getting the specified property
  - getCompatibleDataItemMetadata
```
public java.lang.Object[][] getCompatibleDataItemMetadata(java.lang.String[] types,
                                                          java.lang.String[] idList)
                                                   throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Return sets of metadata for a list of data items that can be referenced by the underlying query for use in building conditional formatting expressions, etc. (such as Sales > Costs).
    
    Specified by:
    
    getCompatibleDataItemMetadata in interface DataDirector
    
    Parameters:
    
    types - List of MetadataMap types requested for each data item returned
    
    idList - Optional list of MetadataMap.METADATA_VALUE IDs for which to return the metadata specified in types. If null, return all the compatible data items.
    
    Returns:
    
    The first dimension is a list of data item metadata compatible with this query. The second dimension specifies the requested metadata information for each data item returned, as specified by the types parameter.
    
    Throws:
    
    DataDirectorException
  - setExpressions
```
public java.lang.String[] setExpressions(java.lang.Object[] expressions)
                                  throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Set the entire set of Boolean expressions this query should assign DataMap constants for and be able to evaluate for the session. Calling setExpressions will generally result in a query update.
    
    Specified by:
    
    setExpressions in interface DataDirector
    
    Parameters:
    
    expressions - an array of expression tree structures that represent Boolean expressions involving constants, and data item metadata IDs as returned by getCompatibleDataItemMetadata.
    
    Returns:
    
    ordered list of DataMap types associated with the given expressions. The caller may use these in subsequent DataAccess getValue() calls.
    
    Throws:
    
    DataDirectorException
  - getExpressions
```
public java.lang.Object[] getExpressions()
```
    Description copied from interface: DataDirector
    
    Return the entire set of expression tree structures set on this query.
    
    Specified by:
    
    getExpressions in interface DataDirector
    
    Returns:
    
    list of expression tree structures previously set on this query.
  - setDimensionSorts
```
public boolean setDimensionSorts(DimensionSortInfo[] dimensionSortInfo)
                          throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Allows sorting by N dimensions, with each dimension optionally sorted by a series of criteria including measure, name, attribute, hierarchy, etc. Any settings made through this API are considered the entire set of dimension sort criteria for the DataDirector: the given sort criteria replace previously set sort criteria.
    
    Specified by:
    
    setDimensionSorts in interface DataDirector
    
    Parameters:
    
    dimensionSortInfo - An array of DimensionSortInfo objects. Each DimensionSortInfo object may specify one or more sort criterion by which to sort its corresponding dimension.
    
    Returns:
    
    true if the sort operation is successful, false if the sort operation is not successful.
    
    Throws:
    
    DataDirectorException - If a data provider error occurs.
  - getDimensionSorts
```
public DimensionSortInfo[] getDimensionSorts()
                                      throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Retrieves sorting information for given dimensions.
    
    Specified by:
    
    getDimensionSorts in interface DataDirector
    
    Returns:
    
    An array of DimensionSortInfo objects.
    
    Throws:
    
    DataDirectorException - If a data provider error occurs.
  - setMemberSorts
```
public boolean setMemberSorts(MemberSortInfo[] memberSortInfo)
                       throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Specifies a set of member sorts for N dimensions. Any settings made through this API are considered the entire set of member sort criteria for the DataDirector: the given sort criteria replace previously set sort criteria.
    
    Specified by:
    
    setMemberSorts in interface DataDirector
    
    Parameters:
    
    memberSortInfo - An array of MemberSortInfo objects. Each MemberSortInfo object may specify one or more member sorts for its corresponding dimension.
    
    Returns:
    
    true if the sort operation is successful, false if the sort operation is not successful.
    
    Throws:
    
    DataDirectorException - If a data provider error occurs.
  - getMemberSorts
```
public MemberSortInfo[] getMemberSorts()
                                throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Retrieves the set of member sort information.
    
    Specified by:
    
    getMemberSorts in interface DataDirector
    
    Returns:
    
    An array of MemberSortInfo objects. Each MemberSortInfo object may specify one or more member sorts for its corresponding dimension.
    
    Throws:
    
    DataDirectorException - If a data provider error occurs.
  - fireEvents
```
public void fireEvents()
                throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Fire any pending events to all listeners.
    
    Specified by:
    
    fireEvents in interface DataDirector
    
    Throws:
    
    DataDirectorException - if an error occurs.
  - startExecution
```
public StatusInfo startExecution()
                          throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Must be called to begin execution on an asynchronous query. Returns an object that contains progress information (if supported) and contains an enumerated status constant, and a return value if the call has completed successfully and the call returns a value.
    
    Specified by:
    
    startExecution in interface DataDirector
    
    Returns:
    
    StatusInfo containing status, progress information (if supported), and a return value for the API call (if relevant).
    
    Throws:
    
    DataDirectorException - if an error occurs.
  - getStatus
```
public StatusInfo getStatus()
                     throws DataDirectorException
```
    Description copied from interface: DataDirector
    
    Returns an object that contains progress information (if supported) and contains an enumerated status constant, and a return value if the call has completed successfully and the call returns a value.
    
    Specified by:
    
    getStatus in interface DataDirector
    
    Returns:
    
    StatusInfo containing status, progress information (if supported), and a return value for the API call (if relevant).
    
    Throws:
    
    DataDirectorException - if an error occurs.
  - isFetched
```
public boolean isFetched(int[] startSlice,
                         int[] endSlice,
                         int flag)
                  throws SliceOutOfRangeException
```
    Description copied from interface: DataAccess
    
    Indicates whether a block of data has been fully computed or processed locally. The block of data is specified as matched pairs of start and end slice locations organized in array parameters by edge.
    For example, this method can be used for a printing routine that wants to keep the UI running and to be sure that the block of data that it is about to print has already been fetched.
    Implementors are not required to support this method.
    
    Specified by:
    
    isFetched in interface DataAccess
    
    Parameters:
    
    startSlice - A list of starting slices that define one "side" of the data block, organized by edge. For example, this parameter might refer to the starting column and row. This method ignores array elements above the maximum supported edge.
    
    endSlice - A matching list (as defined by startSlice) of ending slices that define the other "side" of the data block. For example, this parameter might refer to the ending column and row. This method ignores array elements above the maximum supported edge.
    
    flag - A DataDirector3 flag indicating the type of block the caller is interested in (spans, relative indent, etc.)
    
    Returns:
    
    true if the block of data has been computed locally or if the call is unsupported; false if the block of data has not been computed locally.
    
    Throws:
    
    SliceOutOfRangeException - If any of the slices are invalid.
    
    See Also:
    
    DataDirector3
  - forceFetch
```
public boolean forceFetch(int[] startSlice,
                          int[] endSlice,
                          int flag)
                   throws SliceOutOfRangeException
```
    Description copied from interface: DataAccess
    
    Ensures that a block of data has been fetched or computed locally. If this call is successful, then the caller can expect that isFetched will return true.
    Implementors are not required to support this method.
    
    Specified by:
    
    forceFetch in interface DataAccess
    
    Parameters:
    
    startSlice - A list of starting slices that define one "side" of the data block, organized by edge. For example, this parameter might refer to the starting column and row. This method ignores array elements above the maximum supported edge.
    
    endSlice - A matching list (as defined by startSlice) of ending slices that define the other "side" of the data block. For example, this parameter might refer to the ending column and row. This method ignores array elements above the maximum supported edge.
    
    flag - A bitwise DataDirector3 flag indicating the type of blocks the caller is interested in (spans, relative indent, etc.)
    
    Returns:
    
    true If the block of data was successfully computed or if the method is not supported. false if the block of data was not computed..
    
    Throws:
    
    SliceOutOfRangeException - If the startSlice parameter is invalid
    
    See Also:
    
    DataDirector3
  - isMemberExtentComplete
```
public boolean isMemberExtentComplete(int edge,
                                      int layer,
                                      int slice)
                               throws EdgeOutOfRangeException,
                                      LayerOutOfRangeException,
                                      SliceOutOfRangeException
```
    Description copied from interface: DataAccess
    
    Determines if the size of a member, that is, the number of slices that the member spans at a specified edge, layer, and slice location (parallel to the direction of the edge), has been completely calculated. Views use this method to determine whether the width of a member in a column header or the height of a member in a row header when not in outline form will increase further, in order for views to support dynamic span information from implementations.
    
    Specified by:
    
    isMemberExtentComplete in interface DataAccess
    
    Parameters:
    
    edge - A constant that represents the edge in which to look for the layer and slice. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based number of the physical layer. Valid values are zero to total layers at the specified slice.
    
    slice - An absolute index (zero-based) along the edge. Each member in the innermost layer has a unique slice. In outer layers, any slice that the outer member spans can be used.
    
    Returns:
    
    true if the extent of the specified member has been fully computed, false if not.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    SliceOutOfRangeException - If slice is negative or too large.
    
    See Also:
    
    CDFDataAccess.getMemberStartSlice(int, int, int), CDFDataAccess.getMemberExtent(int, int, int), DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE
  - setLayerMetadata
```
public void setLayerMetadata(int edge,
                             int layer,
                             java.lang.String type,
                             java.lang.Object value)
                      throws EdgeOutOfRangeException,
                             LayerOutOfRangeException
```
    Description copied from interface: DataDirector
    
    Sets a piece of metadata for a logical layer that is found at a specified edge, logical layer and LayerMetadataMap type. Calling this method may result in a DataChangedEvent, and may result in the new metadata being shared by others users of the DataAccess/DataDirector implementation. The changes may or may not be persisted if the DataDirector implementation is persistable. As a rule, only Strings, Booleans, Integers, Longs, Floats and Doubles will be persisted if at all.
    
    Specified by:
    
    setLayerMetadata in interface DataDirector
    
    Parameters:
    
    edge - A constant that represents the edge of interest. The constants end with _EDGE in DataDirector.
    
    layer - The zero-based number of the layer for which metadata is to be set. Uses a depth computation to identify the location of the layer or layer member; 0 is the outer-most layer on the edge. The value for this parameter can be obtained by calling getMemberLogicalLayer.
    
    type - A constant that specifies the kind of metadata that you want to set. Valid type values are defined in the LayerMetadataMap.
    
    value - The new value for the metadata at the given edge, layer, and type. null clears the setting for the edge, layer, and type.
    
    Throws:
    
    EdgeOutOfRangeException - If edge is too large.
    
    LayerOutOfRangeException - If layer is negative or too large.
    
    See Also:
    
    LayerMetadataMap, DataDirector.COLUMN_EDGE, DataDirector.PAGE_EDGE, DataDirector.ROW_EDGE

June							July
Tents			Canoes				Tents			Canoes
NY	Boston	LA	Toronto	Winnepeg	NY	LA	NY	Boston	LA	Toronto	Winnepeg

Class DataAccessAdapter

Field Summary

Fields inherited from interface oracle.dss.util.DataAccess

Fields inherited from interface oracle.dss.util.DataDirector

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DataAccessAdapter

Method Detail

getEdgeExtent

getEdgeSymmetric

getEdgeCount

getValue

setValue

getSliceLabel

getEdgeCurrentSlice

getEdgeCurrentHPos

getLayerCount

getSliceMemberCount

getSliceOutlineLayer

getMemberDepth

getMemberStartLayer

getMemberLogicalLayer

getLayerMetadata

getMemberExtent

getMemberStartSlice

getMemberMetadata

getMemberSiblingCount

getMemberMetadata

getMemberHPos

getFirstHPos

getLastHPos

getPrevHPos

getNextHPos

getValueQDR

getSliceQDR

getMemberQDR

getMemberQDR

getLayerQDR

getSlicesFromQDR

findMember

findMembers

release

startGroupEdit

endGroupEdit

submitChanges

undoEdit

redoEdit

dropChanges

setAutoSubmit

isAutoSubmit

getQDRoverrideCollection

getUniqueMemberMetadata

getUniqueMemberMetadata

getCorrespondingMemberMetadata

getCorrespondingMemberMetadata

allSlicesFetched

pivot

pivotOK

pivotCheck

drill

drillOK

drill

drillOK

changeEdgeCurrentSlice

changeEdgeCurrentHPos

reorder

insertValueCalc

insertMemberCalc

deleteValueCalc

deleteMemberCalc

getDataAccess

addDataDirectorListener

removeDataDirectorListener

refresh

revalidate

setOutline

isOutline

setMetadataMap