Interface WebExpressionHelper

 All Known Subinterfaces:
WebLimitExpressionHelper
 All Known Implementing Classes:
RWViewLimitHelper
,WebMDXExpressionHelper
,WebMDXReportLimitHelper
,WebSubsetViewLimitHelper
public interface WebExpressionHelper
The WebExpressionHelper interface is a helper interface which is used to manipulate the expression tree with multistep, complex manipulations. All of these manipulations can be done by using theWebExpression
/WebNode
interfaces, but this class simplifies the performance of many of those operations. This object can be obtained from aWebExpression
instance, and is linked to that instance. Since:
 MicroStrategy Web 7.3.1 or earlier


Method Summary
All Methods Instance Methods Abstract Methods Modifier and Type Method Description boolean
canEditExpression()
boolean
canGroup(int firstKey, int secondKey)
Check whether it is possible to call group() on the two nodes with the given keys.boolean
canGroup(WebNode firstNode, WebNode secondNode)
Check whether it is possible to call group() on the two given nodes.boolean
canSwapWithNext(int nodeKey)
Checks whether it is possible to call swapWithNext() on the node with the given key.boolean
canSwapWithNext(WebNode node)
Checks whether it is possible to call swapWithNext() on the given node.boolean
canSwapWithPrevious(int nodeKey)
Checks whether it is possible to call swapWithPrevious() on the node with the given key.boolean
canSwapWithPrevious(WebNode node)
Checks whether it is possible to call swapWithPrevious() on the given node.boolean
canUngroup(int firstKey, int secondKey)
Check whether it is possible to call ungroup() on the two nodes with the given keys.boolean
canUngroup(WebNode firstNode, WebNode secondNode)
Check whether it is possible to call ungroup() on the two given nodes.boolean
compareTo(WebExpression anotherExp)
Compares two WebExpression.void
consolidateTree()
Consolidates the whole expression tree.void
delete(int nodeKey)
Delete the node with the given key from the expression.void
delete(WebNode node)
Delete the specified node from the expression.boolean
getAutoConsolidation()
Return the current setting for the autoconsolidation option.WebOperatorNode
getNewRootNode()
Creates a new root node for the underlyingWebExpression
.WebNode
group(int firstKey, int secondKey)
Group two nodes in the expression together.WebNode
group(WebNode firstNode, WebNode secondNode)
Group two nodes in the expression together.boolean
hasFilterOn(WebObjectInfo oi)
Returns whether the expression contains an qualification on specified objectboolean
isEqual(WebNode n1, WebNode n2)
Checks whether two WebNode are equal.WebExpression
removeEmptyFilters()
This method will take the current expression tree and attempt to remove any empty filters in the expression.void
setAutoConsolidation(boolean auto)
Sets the autoconsolidation option on this instance.void
swap(int firstKey, int secondKey)
Swap two nodes in the expression.void
swap(WebNode firstNode, WebNode secondNode)
Swap two nodes in the expression.void
swapWithNext(int nodeKey)
Swaps the node with the given key with its next sibling.void
swapWithNext(WebNode node)
Swaps the given node with its next sibling.void
swapWithPrevious(int nodeKey)
Swaps the node with the given key with the previous sibling.void
swapWithPrevious(WebNode node)
Swaps the given node with the previous sibling.void
toggleFunction(int firstKey, int secondKey, int toggleFunction)
Change the function between the two nodes with the given keys to the specified function.void
toggleFunction(WebNode firstNode, WebNode secondNode, int toggleFunction)
Change the function between the two given nodes to the specified function.void
ungroup(int firstKey, int secondKey)
Ungroup two nodes in the expression.void
ungroup(WebNode firstNode, WebNode secondNode)
Ungroup two nodes in the expression.boolean
validateOperands(WebNode node, RWDataSet ds)
Returns whether the given node and its children are valid.



Method Detail

getAutoConsolidation
boolean getAutoConsolidation()
Return the current setting for the autoconsolidation option. When the autoconsolidation setting is on, a consolidation of the expression tree will be done after every other manipulation on this interface. See the consolidateTree method for the effects of a consolidation operation. By default, this option is true. Returns:
 The current setting for autoconsolidation.
 See Also:
setAutoConsolidation(boolean)
,consolidateTree()

setAutoConsolidation
void setAutoConsolidation(boolean auto)
Sets the autoconsolidation option on this instance. When the autoconsolidation setting is on, a consolidation of the expression tree will be done after every other manipulation on this interface. See the consolidateTree method for the effects of a consolidation operation. Parameters:
auto
 The desired setting for autoconsolidation. See Also:
getAutoConsolidation()
,consolidateTree()

consolidateTree
void consolidateTree()
Consolidates the whole expression tree.Consolidation rules:
 Any branch qualification (AND, OR, or NOT) which has no child nodes will be removed.
 Branch qualifications (AND, OR), which have 1 child node will be removed and the tree adjusted such that the expression's meaning will not be changed.
 If a NOT node has a NOT node as it's child node, both not nodes will be removed.
 Any AND or OR node, can not have its first child as NOT node,
 If the first child is a NOT node,
 if there is at least one nonNOT child, try to swap with the first nonNOT child
 else, create a NOT node, move current AND or OR node under the NOT node, then change the AND to OR, OR to AND, then replace all NOT children with their children. Eg. (NOT A AND NOT B) > NOT (A OR B)
 If the first child is a NOT node,

removeEmptyFilters
WebExpression removeEmptyFilters()
This method will take the current expression tree and attempt to remove any empty filters in the expression. After doing that, it will consolidate the new expression. This method, if it is necessary to change the expresssion, will return a copy of the current expression; the expression that belongs to this WebExpressionHelper object will never be modified. Returns:
 Either the current expression, if no change was needed, or a copy of the current expression that has empty filters removed and is consolidated.
 Since:
 MicroStrategy Web 7.5.4

group
WebNode group(WebNode firstNode, WebNode secondNode) throws java.lang.IllegalArgumentException, WebObjectsException
Group two nodes in the expression together. The two nodes given must either share a parent node or for the first node and the parent node of the second child (which must be a NOT node) share a common parent node. In the second case, the operator will be considered to be the parent and the not node combined(i.e. AND NOT or OR NOT). This method will create a new node, which will have the same function (AND or OR) as the original parent of these two nodes. The new node is inserted at the position of the first given node, and the two given nodes will be set as child nodes of the newly created node. Parameters:
firstNode
 The first input parameter, which must share a parent with secondNodesecondNode
 The second input parameter, which must either share a parent with firstNode or the parent node must be a NOT node, and that node must share a parent with the firstNode. Returns:
 The new parent node of the two given nodes.
 Throws:
WebObjectsException
 Thrown when the parent of one child is not a branch qualification operator, when these children do not share the same parent, or when one of the input nodes is the root node of the expression.java.lang.IllegalArgumentException
 Thrown if either input parameter is null.

group
WebNode group(int firstKey, int secondKey) throws java.lang.IllegalArgumentException, WebObjectsException
Group two nodes in the expression together. This method is used to identify the nodes by the key of the expression. The two nodes given must either share a parent node or for the first node and the parent node of the second child (which must be a NOT node) share a common parent node. In the second case, the operator will be considered to be the parent and the not node combined(i.e. AND NOT or OR NOT). This method will create a new node, which will have the same function (AND or OR) as the original parent of these two nodes. The new node is inserted at the position of the first given node, and the two given nodes will be set as child nodes of the newly created node. Parameters:
firstKey
 The key of the first node.secondKey
 The key of the second node. the parent node must be a NOT node, and that node must share a parent with the firstNode. Returns:
 The new parent node of the two given nodes.
 Throws:
WebObjectsException
 Thrown when the parent of one child is not a branch qualification operator, when these children do not share the same parent, or when one of the input nodes is the root node of the expression.java.lang.IllegalArgumentException
 Thrown if either input parameter is null.

ungroup
void ungroup(WebNode firstNode, WebNode secondNode) throws java.lang.IllegalArgumentException, WebObjectsException
Ungroup two nodes in the expression. The parent of both given nodes, which is an operator node, will be removed and the two child nodes will be moved to the removed node's position in the expression. The two nodes given must either share a parent node or for the first node and the parent node of the second child (which must be a NOT node) share a common parent node. In the second case, the operator will be considered to be the parent and the not node combined(i.e. AND NOT or OR NOT). Parameters:
firstNode
 The first node to be ungrouped.secondNode
 The second node to be ungrouped. Throws:
WebObjectsException
 Thrown when parent node of one of the given nodes is not a branch qualificaiton operator, when the given nodes do not share the same parent, or when one of the input nodes or the parent of the input nodes is the root node of the expression.java.lang.IllegalArgumentException
 Thrown when one of the input parameters is null.

ungroup
void ungroup(int firstKey, int secondKey) throws java.lang.IllegalArgumentException, WebObjectsException
Ungroup two nodes in the expression. This method allows the user to specify the nodes to be ungrouped by their keys. The parent of both given nodes, which is an operator node, will be removed and the two child nodes will be moved to the removed node's position in the expression. The two nodes given must either share a parent node or for the first node and the parent node of the second child (which must be a NOT node) share a common parent node. In the second case, the operator will be considered to be the parent and the not node combined(i.e. AND NOT or OR NOT). Parameters:
firstKey
 The key of first node to be ungrouped.secondKey
 The key of second node to be ungrouped. Throws:
WebObjectsException
 Thrown when parent node of one of the given nodes is not a branch qualificaiton operator, when the given nodes do not share the same parent, or when one of the input nodes or the parent of the input nodes is the root node of the expression.java.lang.IllegalArgumentException
 Thrown when one of the input parameters is null.

swap
void swap(WebNode firstNode, WebNode secondNode) throws java.lang.IllegalArgumentException
Swap two nodes in the expression. These two nodes can be anywhere in the expression tree. After calling this method, the two nodes' locations will be swapped. Parameters:
firstNode
 The first node to be swapped.secondNode
 The second node to be swapped. Throws:
java.lang.IllegalArgumentException
 Thrown when the input parameter is null.

swap
void swap(int firstKey, int secondKey) throws java.lang.IllegalArgumentException
Swap two nodes in the expression. These two nodes can be anywhere in the expression tree. After calling this method, the two nodes' locations will be swapped. Parameters:
firstKey
 The key of the first node to be swapped.secondKey
 The key of the second node to be swapped. Throws:
java.lang.IllegalArgumentException
 Thrown when one of the keys do not exist in the expression tree.

swapWithPrevious
void swapWithPrevious(WebNode node) throws java.lang.IllegalArgumentException, WebObjectsException
Swaps the given node with the previous sibling. This only works if the given node is not the first child of it's parent node.There are two special cases:
 If the parent node is a NOT node, swap the given node with the NOT node's previous sibling.
 If the previous sibling is a NOT node, swap the given node with its child.
 Parameters:
node
 The node to be swapped. Throws:
WebObjectsException
 Thrown if the parent of the given node is not a branch qualification operator or when there is no previous sibling to swap with.java.lang.IllegalArgumentException
 Thrown when the input parameter is null.

swapWithPrevious
void swapWithPrevious(int nodeKey) throws java.lang.IllegalArgumentException, WebObjectsException
Swaps the node with the given key with the previous sibling. This only works if the given node is not the first child of it's parent node.There are two special cases:
 If the parent node is a NOT node, swap the given node with the NOT node's previous sibling.
 If the previous sibling is a NOT node, swap the given node with its child.
 Parameters:
nodeKey
 The key of the node to be swapped. Throws:
WebObjectsException
 Thrown if the parent of the given node is not a branch qualification operator or when there is no previous sibling to swap with.java.lang.IllegalArgumentException
 Thrown if no node with the given key exists.

swapWithNext
void swapWithNext(WebNode node) throws java.lang.IllegalArgumentException, WebObjectsException
Swaps the given node with its next sibling. This only works if the given node is not the last child of it's parent node.There are two special cases:
 If the parent node is a NOT node, swap the given node with the NOT node's next sibling.
 If the next sibling is a NOT node, swap the given node with its child.
 Parameters:
node
 The node to be swapped. Throws:
WebObjectsException
 Thrown if the parent of the given node is not a branch qualification operator or when there is no previous sibling to swap with.java.lang.IllegalArgumentException
 Thrown when the input parameter is null.

swapWithNext
void swapWithNext(int nodeKey) throws java.lang.IllegalArgumentException, WebObjectsException
Swaps the node with the given key with its next sibling. This only works if the given node is not the last child of it's parent node.There are two special cases:
 If the parent node is a NOT node, swap the given node with the NOT node's next sibling.
 If the next sibling is a NOT node, swap the given node with its child.
 Parameters:
nodeKey
 The key of the node to be swapped. Throws:
WebObjectsException
 Thrown if the parent of the given node is not a branch qualification operator or when there is no previous sibling to swap with.java.lang.IllegalArgumentException
 Thrown if no node with the given key exists.

toggleFunction
void toggleFunction(WebNode firstNode, WebNode secondNode, int toggleFunction) throws java.lang.IllegalArgumentException, WebObjectsException
Change the function between the two given nodes to the specified function. The functions which are available come fromEnumWebToggleFunction
. Note that if AND NOT or OR NOT are the original operator, the node directly under the NOT node should be specified as the second argument to this method. These two nodes either should be the direct children of the same parent, or the second node must have a NOT node as its parent which shares a parent with the first argument.For example, if there were an AND node, with children firstNode and a NOT node which has the secondNode as a child node, then the original function is considered to be AND NOT.
Each time, this function will add a new node for the new toggleFunction first. Then if the auto consolidation is set, it may remove the original function node (the shared parent of the two input nodes).
 Parameters:
firstNode
 The first node whose parent operator will be toggled.secondNode
 The second node whose parent operator will be toggled.toggleFunction
 The function to toggle to, which is a value fromEnumWebToggleFunction
. Throws:
WebObjectsException
 Thrown if the parent of the given nodes is not aa branch qualification operator, the two given nodes do not share the same parent, or if either the first node, second node, or the shared parent node are the root node of the expression.java.lang.IllegalArgumentException
 Thrown when input parameter is null. See Also:
consolidateTree()

toggleFunction
void toggleFunction(int firstKey, int secondKey, int toggleFunction) throws java.lang.IllegalArgumentException, WebObjectsException
Change the function between the two nodes with the given keys to the specified function. The functions which are available come fromEnumWebToggleFunction
. Note that if AND NOT or OR NOT are the original operator, the node directly under the NOT node should be specified as the second argument to this method. These two nodes either should be the direct children of the same parent, or the second node must have a NOT node as its parent which shares a parent with the first argument.For example, if there were an AND node, with children firstNode and a NOT node which has the secondNode as a child node, then the original function is considered to be AND NOT.
Each time, this function will add a new node for the new toggleFunction first. Then if the auto consolidation is set, it may remove the original function node (the shared parent of the two input nodes).
 Parameters:
firstKey
 The key of the first node whose parent operator will be toggled.secondKey
 The key of the second node whose parent operator will be toggled.toggleFunction
 The function to toggle to, which is a value fromEnumWebToggleFunction
. Throws:
WebObjectsException
 Thrown if the parent of the given nodes is not aa branch qualification operator, the two given nodes do not share the same parent, or if either the first node, second node, or the shared parent node are the root node of the expression.java.lang.IllegalArgumentException
 Thrown if one of the keys given is not found in the expression. See Also:
consolidateTree()

delete
void delete(WebNode node) throws java.lang.IllegalArgumentException
Delete the specified node from the expression. If it is the root node of the expression, this method will do nothing. Parameters:
node
 The node to be deleted. Throws:
java.lang.IllegalArgumentException
 Thrown if the input parameter is null.

delete
void delete(int nodeKey) throws java.lang.IllegalArgumentException
Delete the node with the given key from the expression. If it is the root node of the expression, this method will do nothing. Parameters:
nodeKey
 The key of the node to be deleted. Throws:
java.lang.IllegalArgumentException
 Thrown if the key is not found in the expression.

canGroup
boolean canGroup(WebNode firstNode, WebNode secondNode) throws java.lang.IllegalArgumentException
Check whether it is possible to call group() on the two given nodes. Parameters:
firstNode
 The first node.secondNode
 The second node. Returns:
 True if calling group() on the two given nodes will not cause an error, or false if it is not possible to group the two given nodes.
 Throws:
java.lang.IllegalArgumentException
 Thrown if either input parameter is null.

canGroup
boolean canGroup(int firstKey, int secondKey) throws java.lang.IllegalArgumentException
Check whether it is possible to call group() on the two nodes with the given keys. Parameters:
firstKey
 The key of the first node.secondKey
 The key of the second node. Returns:
 True if calling group() on the two given nodes will not cause an error, or false if it is not possible to group the two given nodes.
 Throws:
java.lang.IllegalArgumentException
 Thrown if either key does not exist in the expression.

canUngroup
boolean canUngroup(WebNode firstNode, WebNode secondNode) throws java.lang.IllegalArgumentException
Check whether it is possible to call ungroup() on the two given nodes. Parameters:
firstNode
 The first node.secondNode
 The second node. Returns:
 True if calling ungroup() on the two given nodes will not cause an error, or false if it is not possible to ungroup the two given nodes.
 Throws:
java.lang.IllegalArgumentException
 Thrown if either input parameter is null.

canUngroup
boolean canUngroup(int firstKey, int secondKey) throws java.lang.IllegalArgumentException
Check whether it is possible to call ungroup() on the two nodes with the given keys. Parameters:
firstKey
 The key of the first node.secondKey
 The key of the second node. Returns:
 True if calling ungroup() on the two given nodes will not cause an error, or false if it is not possible to ungroup the two given nodes.
 Throws:
java.lang.IllegalArgumentException
 Thrown if either key does not exist in the expression.

canSwapWithPrevious
boolean canSwapWithPrevious(WebNode node) throws java.lang.IllegalArgumentException
Checks whether it is possible to call swapWithPrevious() on the given node. Parameters:
node
 The node to be swapped. Returns:
 True if swapWithPrevious will not cause an error, false otherwise.
 Throws:
java.lang.IllegalArgumentException
 Thrown if the node parameter is null.

canSwapWithPrevious
boolean canSwapWithPrevious(int nodeKey) throws java.lang.IllegalArgumentException
Checks whether it is possible to call swapWithPrevious() on the node with the given key. Parameters:
nodeKey
 The key of the node to be swapped. Returns:
 True if swapWithPrevious will not cause an error, false otherwise.
 Throws:
java.lang.IllegalArgumentException
 Thrown if the node parameter is null.

canSwapWithNext
boolean canSwapWithNext(WebNode node) throws java.lang.IllegalArgumentException
Checks whether it is possible to call swapWithNext() on the given node. Parameters:
node
 The node to be swapped. Returns:
 True if swapWithNext will not cause an error, false otherwise.
 Throws:
java.lang.IllegalArgumentException
 Thrown if the node parameter is null.

canSwapWithNext
boolean canSwapWithNext(int nodeKey) throws java.lang.IllegalArgumentException
Checks whether it is possible to call swapWithNext() on the node with the given key. Parameters:
nodeKey
 The key of the node to be swapped. Returns:
 True if swapWithNext will not cause an error, false otherwise.
 Throws:
java.lang.IllegalArgumentException
 Thrown if the node parameter is null.

canEditExpression
boolean canEditExpression()
 Since:
 MicroStrategy Web 9.0.0

getNewRootNode
WebOperatorNode getNewRootNode()
Creates a new root node for the underlyingWebExpression
. The new root node has functionEnumDSSXMLFunction.DssXmlFunctionAnd
and expression typeEnumDSSXMLExpressionType.DssXmlFilterBranchQual
. If the specifiedWebExpression
has any sub expression originally, the sub expression becomes the first child of the new root node after the method call returns. Returns:
 a new root node for the specified expression object.
 Since:
 MicroStrategy Web 9.0.0

hasFilterOn
boolean hasFilterOn(WebObjectInfo oi)
Returns whether the expression contains an qualification on specified object

compareTo
boolean compareTo(WebExpression anotherExp)
Compares two WebExpression. The comparison is based on the structure of each root node in the expressions.Note that this method is currently used to compare the expressions which are used in derived elements editor.
 Parameters:
anotherExp
 the WebExpression to be compared.. Returns:
 true if this expression is the same as the anotherExp argument; false otherwise.
 See Also:
isEqual(WebNode, WebNode)

isEqual
boolean isEqual(WebNode n1, WebNode n2)
Checks whether two WebNode are equal.Note that this method is currently used to compare the expressions which are used in derived elements editor.
 Parameters:
n1
 the first WebNode to check equalityn2
 the second WebNode to check equality Returns:
 true if the two WebNode are the same; false otherwise.

validateOperands
boolean validateOperands(WebNode node, RWDataSet ds)
Returns whether the given node and its children are valid. The primary use of this is to ensure that the given node is valid within the given RW context. Parameters:
node
 TheWebNode
object which will be validated. If null is passed, then the validation will start at the root. Note that all children will be validated as well.ds
 The dataset which is used to validate if it contains the operand objects Returns:
 True if the expression is valid, false if it is not.
 Since:
 MicroStrategy Web 9.4.0

