Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
  * JBoss, Home of Professional Open Source
  * Copyright 2009, Red Hat, Inc. and/or its affiliates, and individual contributors
  * by the @authors tag. See the copyright.txt in the distribution for a
  * full listing of individual contributors.
  *
  * 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.hibernate.validator.internal.engine;
 
 import java.util.List;
 
 
 import static org.hibernate.validator.internal.util.logging.Messages.MESSAGES;

Author(s):
Hardy Ferentschik
Gunnar Morling
Kevin Pollet <kevin.pollet@serli.com> (C) 2011 SERLI
 
 public final class PathImpl implements PathSerializable {
 	private static final long serialVersionUID = 7564511574909882392L;
 	private static final Log log = LoggerFactory.make();
 
 	public static final String PROPERTY_PATH_SEPARATOR = ".";

Regular expression used to split a string path into its elements.

See also:
Regular expression tester
 
 	private static final String LEADING_PROPERTY_GROUP = "[^\\[\\.]+";  // everything up to a [ or .
 	private static final String OPTIONAL_INDEX_GROUP = "\\[(\\w*)\\]";
 	private static final String REMAINING_PROPERTY_STRING = "\\.(.*)";  // processed recursively
 
 	private static final Pattern PATH_PATTERN = Pattern.compile"(" +  + ")(" +  + ")?(" +  + ")*" );
 	private static final int PROPERTY_NAME_GROUP = 1;
 	private static final int INDEXED_GROUP = 2;
 	private static final int INDEX_GROUP = 3;
 	private static final int REMAINING_STRING_GROUP = 5;
 
 	private final List<NodenodeList;
 	private int hashCode;

Returns a Path instance representing the path described by the given string. To create a root node the empty string should be passed.

Parameters:
propertyPath the path as string representation.
Returns:
a Path instance representing the path described by the given string.
Throws:
java.lang.IllegalArgumentException in case property == null or property cannot be parsed.
 
 	public static PathImpl createPathFromString(String propertyPath) {
 		Contracts.assertNotNullpropertyPath.propertyPathCannotBeNull() );
 
 		if ( propertyPath.length() == 0 ) {
 			return createNewPathnull );
 		}
 
 		return parsePropertypropertyPath );
 	}

Creates a path representing the specified method parameter.

Parameters:
method The method hosting the parameter to represent.
parameterName The parameter's name, e.g. "arg0" or "param1".
Returns:
A path representing the specified method parameter.
 
 	public static PathImpl createPathForMethodParameter(Method methodString parameterName) {
 		Contracts.assertNotNullmethod"A method is required to create a method parameter path." );
 		Contracts.assertNotNullparameterName"A parameter name is required to create a method parameter path." );
 
 		PathImpl path = createRootPath();
		path.addMethodParameterNodemethodparameterName );
		return path;
	}
	public static PathImpl createPathForMethodReturnValue(Method method) {
		Contracts.assertNotNullmethod"A method is required to create a method return value path." );
		path.addMethodReturnValueNodemethod );
		return path;
	}
	public static PathImpl createRootPath() {
		return createNewPathnull );
	}
	public static PathImpl createCopy(PathImpl path) {
		return new PathImplpath );
	}
	public final boolean isRootPath() {
		return .size() == 1 && .get( 0 ).getName() == null;
	}
	public final PathImpl getPathWithoutLeafNode() {
		return new PathImpl.subList( 0, .size() - 1 ) );
	}
	public final NodeImpl addNode(String nodeName) {
		NodeImpl parent = .isEmpty() ? null : (NodeImpl.get.size() - 1 );
		 = new NodeImplnodeNameparentfalsenullnull );
		 = -1;
	}
	private NodeImpl addMethodParameterNode(Method methodString parameterName) {
		NodeImpl parent = .isEmpty() ? null : (NodeImpl.get.size() - 1 );
		 = new MethodParameterNodeImplmethodparameterNameparent );
		 = -1;
	}
		NodeImpl parent = .isEmpty() ? null : (NodeImpl.get.size() - 1 );
		 = new MethodReturnValueNodeImplmethodparent );
		 = -1;
	}
	public final NodeImpl makeLeafNodeIterable() {
		 = new NodeImpl.getName(), .getParent(), truenullnull );
		 = -1;
	}
	public final NodeImpl setLeafNodeIndex(Integer index) {
		 = new NodeImpl.getName(), .getParent(), trueindexnull );
		 = -1;
	}
	public final NodeImpl setLeafNodeMapKey(Object key) {
		 = -1;
	}
	public final NodeImpl getLeafNode() {
	}
	public final Iterator<Path.Nodeiterator() {
		if ( .size() == 0 ) {
			return Collections.<Path.Node>emptyList().iterator();
		}
		if ( .size() == 1 ) {
			return .iterator();
		}
		return .subList( 1, .size() ).iterator();
	}
	public final String asString() {
		StringBuilder builder = new StringBuilder();
		boolean first = true;
		for ( int i = 1; i < .size(); i++ ) {
			NodeImpl nodeImpl = (NodeImpl.geti );
			if ( nodeImpl.getName() != null ) {
				if ( !first ) {
				}
				builder.appendnodeImpl.asString() );
			}
			first = false;
		}
		return builder.toString();
	}
	public String toString() {
		return asString();
	}
	public boolean equals(Object obj) {
		if ( this == obj ) {
			return true;
		}
		if ( obj == null ) {
			return false;
		}
		if ( getClass() != obj.getClass() ) {
			return false;
		}
		PathImpl other = (PathImplobj;
		if (  == null ) {
			if ( other.nodeList != null ) {
				return false;
			}
		}
		else if ( !.equalsother.nodeList ) ) {
			return false;
		}
		return true;
	}
	// deferred hash code building
	public int hashCode() {
		if (  == -1 ) {
		}
		return ;
	}
	private int buildHashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ( (  == null ) ? 0 : .hashCode() );
		return result;
	}
	private static PathImpl createNewPath(String name) {
		PathImpl path = new PathImpl();
		path.addNodename );
		return path;
	}

Copy constructor.

Parameters:
path the path to make a copy of.
	private PathImpl(PathImpl path) {
		thispath.nodeList );
	}
	private PathImpl() {
		 = new ArrayList<Node>();
	}
	private PathImpl(List<NodenodeList) {
		this. = new ArrayList<Node>( nodeList );
	}
	private static PathImpl parseProperty(String property) {
		PathImpl path = createNewPathnull );
		String tmp = property;
		do {
			Matcher matcher = .matchertmp );
			if ( matcher.matches() ) {
				String value = matcher.group );
				if ( !isValidJavaIdentifiervalue ) ) {
				}
				// create the node
				path.addNodevalue );
				// is the node indexable
				if ( matcher.group ) != null ) {
				}
				// take care of the index/key if one exists
				String indexOrKey = matcher.group );
				if ( indexOrKey != null && indexOrKey.length() > 0 ) {
					try {
						Integer i = Integer.parseIntindexOrKey );
						path.setLeafNodeIndexi );
					}
					catch ( NumberFormatException e ) {
						path.setLeafNodeMapKeyindexOrKey );
					}
				}
				// match the remaining string
				tmp = matcher.group );
			}
			else {
			}
while ( tmp != null );
		if ( path.getLeafNode().isIterable() ) {
			path.addNodenull );
		}
		return path;
	}

Validate that the given identifier is a valid Java identifier according to the Java Language Specification, chapter 3.8

Parameters:
identifier string identifier to validate
Returns:
true if the given identifier is a valid Java Identifier
Throws:
java.lang.IllegalArgumentException if the given identifier is null
	private static boolean isValidJavaIdentifier(String identifier) {
		Contracts.assertNotNullidentifier"identifier param cannot be null" );
		if ( identifier.length() == 0 || !Character.isJavaIdentifierStart( (intidentifier.charAt( 0 ) ) ) {
			return false;
		}
		for ( int i = 1; i < identifier.length(); i++ ) {
			if ( !Character.isJavaIdentifierPart( (intidentifier.charAti ) ) ) {
				return false;
			}
		}
		return true;
	}
New to GrepCode? Check out our FAQ X