dap4.ce

Class CEConstraint

java.lang.Object

dap4.ce.CEConstraint

Direct Known Subclasses:

CEConstraint.Universal

public class CEConstraint
extends Object

A Constraint is a structure containing a parsed representation of a constraint expression.

The constraint, with respect to some underlying DMR, defines a subset view over that DMR in that it specifies a set of declarations (variables, enums, dimensions, groups) to be included. For each such variable, the constraint specifies any overriding of the dimensions of the variables. The DMR printer and the serializer access the constraint to determine what to put out.

At some point this class will be substantially more complex as it will contain predicates and function invocations.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	CEConstraint.Segment
protected static class	CEConstraint.Universal

Field Summary

Fields

Modifier and Type	Field and Description
protected Map<DapNode,List<DapAttribute>>	attributes
protected List<DapDimension>	dimrefs
protected DapDataset	dmr
protected List<DapEnum>	enums
static boolean	EXPAND
protected boolean	finished
protected List<DapGroup>	groups
protected Map<DapDimension,DapDimension>	redef
protected Map<DapDimension,Slice>	redefslice
protected List<DapDimension>	refdims
protected List<CEConstraint.Segment>	variables

Constructor Summary

Constructors

Constructor and Description
CEConstraint()
CEConstraint(DapDataset dmr)

Method Summary

Methods

Modifier and Type	Method and Description
void	addAttribute(DapNode node, DapAttribute attr)
void	addRedef(DapDimension dim, Slice slice)
void	addVariable(DapVariable var, List<Slice> slices)
protected void	computedimensions() Compute dimension related information using slicing and redef info.
protected void	computeenums() Walk all the included variables and accumulate the referenced enums
protected void	computegroups() Walk all the included declarations and accumulate the set of referenced groups
protected void	dumpvar(CEConstraint.Segment seg, StringBuilder buf, boolean forconstraint) Recursive helper for tostring/toConstraintString
protected void	expandCompoundTypes() Locate each unexpanded Structure|Sequence and: 1.
protected int	expansionCount(DapStructure struct) Count the number of fields of a structure that already in this view.
protected int	findVariable(DapVariable var)
CEConstraint	finish(boolean expand) Finish creating this Constraint.
DapDataset	getDMR()
DapDimension	getRedefDim(DapDimension orig)
static CEConstraint	getUniversal(DapDataset dmr)
protected CEConstraint.Segment	getVariable(DapVariable var)
List<Slice>	getVariableSlices(DapVariable var)
protected boolean	isWholeStructure(DapStructure struct) See if all the fields in this structure are part of the view; this must be done recursively.
boolean	references(DapNode node)
String	toConstraintString() Convert the view to a constraint string suitable for use in a URL, except not URL encoded.
String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

EXPAND

public static final boolean EXPAND

See Also:

Constant Field Values

dmr

protected DapDataset dmr

variables

protected List<CEConstraint.Segment> variables

redefslice

protected Map<DapDimension,Slice> redefslice

attributes

protected Map<DapNode,List<DapAttribute>> attributes

redef

protected Map<DapDimension,DapDimension> redef

dimrefs

protected List<DapDimension> dimrefs

enums

protected List<DapEnum> enums

groups

protected List<DapGroup> groups

refdims

protected List<DapDimension> refdims

finished

protected boolean finished

Constructor Detail

CEConstraint

public CEConstraint()

CEConstraint

public CEConstraint(DapDataset dmr)

Method Detail

getUniversal

public static CEConstraint getUniversal(DapDataset dmr)

getDMR

public DapDataset getDMR()

addRedef

public void addRedef(DapDimension dim,
            Slice slice)

addVariable

public void addVariable(DapVariable var,
               List<Slice> slices)

addAttribute

public void addAttribute(DapNode node,
                DapAttribute attr)

getRedefDim

public DapDimension getRedefDim(DapDimension orig)

getVariableSlices

public List<Slice> getVariableSlices(DapVariable var)

toString

public String toString()

Overrides:

toString in class Object

references

public boolean references(DapNode node)

finish

public CEConstraint finish(boolean expand)
                    throws DapException

Finish creating this Constraint.

Parameters:

expand - expand structures in the underlying view

Throws:

DapException

toConstraintString

public String toConstraintString()

Convert the view to a constraint string suitable for use in a URL, except not URL encoded.

Returns:

constraint string

dumpvar

protected void dumpvar(CEConstraint.Segment seg,
           StringBuilder buf,
           boolean forconstraint)

Recursive helper for tostring/toConstraintString

Parameters:

seg -

buf -

forconstraint -

findVariable

protected int findVariable(DapVariable var)

getVariable

protected CEConstraint.Segment getVariable(DapVariable var)

isWholeStructure

protected boolean isWholeStructure(DapStructure struct)

See if all the fields in this structure are part of the view; this must be done recursively.

expandCompoundTypes

protected void expandCompoundTypes()

Locate each unexpanded Structure|Sequence and: 1. check that none of its fields is referenced => do not expand 2. add all of its fields as leaves Note that #2 may end up adding additional leaf structs &/or seqs

Throws:

DapException

expansionCount

protected int expansionCount(DapStructure struct)

Count the number of fields of a structure that already in this view.

Parameters:

struct - the dapstructure to check

Returns:

# of fields in this view

Throws:

DapException

computedimensions

protected void computedimensions()
                          throws DapException

Compute dimension related information using slicing and redef info.

Assume that the constraint compiler has given us the following info:

1. A list of the variables to include.
2. A pair (DapDimension,Slice) for each redef
3. For each variable in #1, a list of slices taken from the constraint expression

Two products will be produced.

1. The variables map will be modified so that the slices properly reflect any original or redef dimensions.
2. A set, dimrefs, of all referenced original dimensions.

The processing is as follows

1. For each redef create a new redef dimension
2. For each variable:
   1. if the variable is scalar, do nothing.
   2. if the variable has no associated slices, then make its new dimensions be the original dimensions.
   3. otherwise, walk the slices and create new dimensions from them; use redefs where indicated

Throws:

DapException

computeenums

protected void computeenums()

Walk all the included variables and accumulate the referenced enums

computegroups

protected void computegroups()

Walk all the included declarations and accumulate the set of referenced groups