Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012 Daniel Bechler
   *
   * 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 de.danielbechler.diff.path;
 
 
 import java.util.*;

Author(s):
Daniel Bechler
 
 public final class PropertyPath
 {
 	private final List<Elementelements;
 
 	private PropertyPath(final List<Elementelements)
 	{
 		this. = Collections.unmodifiableList(elements);
 	}
 
 	public List<ElementgetElements()
 	{
 		return ;
 	}
 
 	public boolean matches(final PropertyPath propertyPath)
 	{
 		return propertyPath.equals(this);
 	}
 
 	public boolean isParentOf(final PropertyPath propertyPath)
 	{
 		final Iterator<Elementiterator1 = .iterator();
 		final Iterator<Elementiterator2 = propertyPath.getElements().iterator();
 		while (iterator1.hasNext() && iterator2.hasNext())
 		{
 			final Element next1 = iterator1.next();
 			final Element next2 = iterator2.next();
 			if (!next1.equals(next2))
 			{
 				return false;
 			}
 		}
 		return true;
 	}
 
 	public String toString()
 	{
 		final StringBuilder sb = new StringBuilder();
 		final Iterator<Elementiterator = .iterator();
 		Element previousElement = null;
 		while (iterator.hasNext())
 		{
 			final Element element = iterator.next();
 			if (element instanceof RootElement)
 			{
 				sb.append("/");
 			}
 			else if (element instanceof CollectionElement || element instanceof MapElement)
 			{
 				sb.append(element);
 			}
 			else if (previousElement instanceof RootElement)
 			{
 				sb.append(element);
 			}
 			else
 			{
 				sb.append('/');
 				sb.append(element);
 			}
 			previousElement = element;
 		}
 		return sb.toString();
 	}
 
 	public boolean equals(final Object o)
 	{
 		if (this == o)
 		{
 			return true;
 		}
 		if (o == null || getClass() != o.getClass())
 		{
			return false;
		}
		final PropertyPath that = (PropertyPatho;
		if (!.equals(that.elements))
		{
			return false;
		}
		return true;
	}
	public int hashCode()
	{
		return .hashCode();
	}
	public static InitialBuilder createBuilder()
	{
		return new InitialBuilderImpl();
	}
	public static PropertyPath buildWith(final String propertyNamefinal String... additionalPropertyNames)
	{
		return createBuilder().withRoot().withPropertyName(propertyNameadditionalPropertyNames).build();
	}
	public static PropertyPath buildRootPath()
	{
	}

Author(s):
Daniel Bechler
	@SuppressWarnings({"UnusedDeclaration"})
	private static final class InitialBuilderImpl implements InitialBuilder
	{
		{
		}
		{
			final List<Elementelements = new ArrayList<Element>(1);
			elements.add(RootElement.getInstance());
			return new AppendableBuilderImpl(elements);
		}
		public AppendableBuilder withPropertyPath(final PropertyPath propertyPath)
		{
			Assert.notNull(propertyPath"propertyPath");
			return new AppendableBuilderImpl(new ArrayList<Element>(propertyPath.getElements()));
		}
	}
	private static final class AppendableBuilderImpl implements AppendableBuilder
	{
		private final List<Elementelements;
		public AppendableBuilderImpl(final List<Elementelements)
		{
			Assert.notEmpty(elements"elements");
			this. = new ArrayList<Element>(elements);
		}
		public AppendableBuilder withElement(final Element element)
		{
			Assert.notNull(element"element");
			.add(element);
			return this;
		}
		public AppendableBuilder withPropertyName(final String namefinal String... names)
		{
			for (final String s : names)
			{
			}
			return this;
		}
		public <T> AppendableBuilder withCollectionItem(final T item)
		{
			return this;
		}
		public <K> AppendableBuilder withMapKey(final K key)
		{
			Assert.notNull(key"key");
			return this;
		}
		{
			{
				throw new IllegalStateException("A property path cannot be empty");
			}
			else if (!(.get(0) instanceof RootElement))
			{
				throw new IllegalStateException("A property path must start with a root element");
			}
			else if (elementCount(RootElement.class) > 1)
			{
				throw new IllegalStateException("A property path cannot contain multiple root elements");
			}
			return new PropertyPath();
		}
		private int elementCount(final Class<? extends Elementtype)
		{
			assert type != null : "Type must not be null";
			int count = 0;
			for (final Element element : )
			{
				if (type.isAssignableFrom(element.getClass()))
				{
					count++;
				}
			}
			return count;
		}
	}
	public static interface InitialBuilder
	{
	}
	public static interface AppendableBuilder
	{
	}
New to GrepCode? Check out our FAQ X