Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2013 the original author or authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.springframework.data.mongodb.core.spel;
 
 
 import  org.springframework.expression.spel.ExpressionState;
 import  org.springframework.expression.spel.SpelNode;
 import  org.springframework.expression.spel.ast.Literal;
 import  org.springframework.expression.spel.ast.MethodReference;
 import  org.springframework.expression.spel.ast.Operator;
 import  org.springframework.util.Assert;

A value object for nodes in an expression. Allows iterating ove potentially available child ExpressionNodes.

Author(s):
Oliver Gierke
 
 public class ExpressionNode implements Iterable<ExpressionNode> {
 
 	private static final Iterator<ExpressionNodeEMPTY_ITERATOR = Collections.<ExpressionNodeemptySet().iterator();
 
 	private final SpelNode node;
 	private final ExpressionState state;

Creates a new ExpressionNode from the given SpelNode and ExpressionState.

Parameters:
node must not be null.
state must not be null.
 
 	protected ExpressionNode(SpelNode node, ExpressionState state) {
 
 		Assert.notNull(node"SpelNode must not be null!");
 		Assert.notNull(state"ExpressionState must not be null!");
 
 		this. = node;
 		this. = state;
 	}

Factory method to create ExpressionNode's according to the given SpelNode and ExpressionState.

Parameters:
node
state must not be null.
Returns:
an ExpressionNode for the given SpelNode or null if null was given for the SpelNode.
 
 	public static ExpressionNode from(SpelNode node, ExpressionState state) {
 
 		if (node == null) {
 			return null;
 		}
 
 		if (node instanceof Operator) {
 			return new OperatorNode((Operator) nodestate);
 		}
 
 		if (node instanceof MethodReference) {
 			return new MethodReferenceNode((MethodReference) nodestate);
 		}
 
 		if (node instanceof Literal) {
 			return new LiteralNode((Literal) nodestate);
 		}
 
 		return new ExpressionNode(nodestate);
 	}

Returns the name of the ExpressionNode.

Returns:
 
 	public String getName() {
 		return .toStringAST();
 	}

Returns whether the current ExpressionNode is backed by the given type.

Parameters:
type must not be null.
Returns:
 
	public boolean isOfType(Class<?> type) {
		Assert.notNull(type"Type must not be empty!");
		return type.isAssignableFrom(.getClass());
	}

Returns whether the given ExpressionNode is representing the same backing node type as the current one.

Parameters:
node
Returns:
	boolean isOfSameTypeAs(ExpressionNode node) {
		return node == null ? false : this..getClass().equals(node.node.getClass());
	}

Returns whether the ExpressionNode is a mathematical operation.

Returns:
	public boolean isMathematicalOperation() {
		return false;
	}

Returns whether the ExpressionNode is a literal.

Returns:
	public boolean isLiteral() {
		return false;
	}

Returns the value of the current node.

Returns:
	public Object getValue() {
		return .getValue();
	}

Returns whether the current node has child nodes.

Returns:
	public boolean hasChildren() {
		return .getChildCount() != 0;
	}

Returns the child ExpressionNode with the given index.

Parameters:
index must not be negative.
Returns:
	public ExpressionNode getChild(int index) {
		Assert.isTrue(index >= 0);
		return from(.getChild(index), );
	}

Returns whether the ExpressionNode has a first child node that is not of the given type.

Parameters:
type must not be null.
Returns:
	public boolean hasfirstChildNotOfType(Class<?> type) {
		Assert.notNull(type"Type must not be null!");
		return hasChildren() && !.getChild(0).getClass().equals(type);
	}

Creates a new ExpressionNode from the given SpelNode.

Parameters:
node
Returns:
	protected ExpressionNode from(SpelNode node) {
		return from(node);
	}
	/* 
	 * (non-Javadoc)
	 * @see java.lang.Iterable#iterator()
	 */
		if (!hasChildren()) {
		}
		return new Iterator<ExpressionNode>() {
			int index = 0;
			public boolean hasNext() {
				return  < .getChildCount();
			}
			public ExpressionNode next() {
				return from(.getChild(++));
			}
			public void remove() {
			}
		};
	}
New to GrepCode? Check out our FAQ X