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.node;
 
 
 import java.util.*;
 
 import static java.util.Collections.*;

Author(s):
Daniel Bechler
 
 public class DefaultNode implements Node
 {
 	private final Accessor accessor;
 	private final Map<ElementNodechildren = new LinkedHashMap<ElementNode>(10);
 
 	private State state = .;
 	private Node parentNode;
 	private Node circleStartNode;
 	private Class<?> valueType;
 
 	public DefaultNode(final Node parentNodefinal Accessor accessorfinal Class<?> valueType)
 	{
 		Assert.notNull(accessor"accessor");
 		this. = accessor;
 		this. = valueType;
 		setParentNode(parentNode);
 	}
 
 	public DefaultNode(final Accessor accessorfinal Class<?> valueType)
 	{
 		this(.accessorvalueType);
 	}
 
 	public DefaultNode(final Class<?> valueType)
 	{
 		this(., RootAccessor.getInstance(), valueType);
 	}
 
 	public State getState()
 	{
 		return this.;
 	}
 
 	public boolean matches(final PropertyPath path)
 	{
 		return path.matches(getPropertyPath());
 	}
 
 	public boolean hasChanges()
 	{
 		if (isAdded() || isChanged() || isRemoved())
 		{
 			return true;
 		}
 		final AtomicBoolean result = new AtomicBoolean(false);
 		{
 			public void accept(final Node nodefinal Visit visit)
 			{
 				if (node.hasChanges())
 				{
 					result.set(true);
 					visit.stop();
 				}
 			}
 		});
 		return result.get();
 	}
 
 	public final boolean isAdded()
 	{
 		return  == .;
 	}
 
 	public final boolean isChanged()
 	{
 		return  == .;
	}
	public final boolean isRemoved()
	{
		return  == .;
	}
	public final boolean isUntouched()
	{
		return  == .;
	}
	public boolean isCircular()
	{
		return  == .;
	}
	public final PropertyPath getPropertyPath()
	{
		if ( != null)
		{
			return PropertyPath.createBuilder()
							   .build();
		}
		else if ( instanceof RootAccessor)
		{
			return PropertyPath.createBuilder().withRoot().build();
		}
		else
		{
		}
	}
	{
	}
	public boolean isCollectionNode()
	{
		return false;
	}
	{
	}
	public boolean isMapNode()
	{
		return false;
	}
	public MapNode toMapNode()
	{
	}
	public Class<?> getType()
	{
		if ( instanceof TypeAwareAccessor)
		{
		}
		return ;
	}
	public void setType(final Class<?> aClass)
	{
		this. = aClass;
	}
	public boolean hasChildren()
	{
		return !.isEmpty();
	}
	{
		return .values();
	}
	public Node getChild(final String propertyName)
	{
		return .get(new NamedPropertyElement(propertyName));
	}
	public Node getChild(final PropertyPath path)
	{
		final PropertyVisitor visitor = new PropertyVisitor(path);
		visitChildren(visitor);
		return visitor.getNode();
	}
	public Node getChild(final Element pathElement)
	{
		return .get(pathElement);
	}
	public boolean addChild(final Node node)
	{
		if (node.isRootNode())
		{
			throw new IllegalArgumentException("Detected attempt to add root node as child. " +
					"This is not allowed and must be a mistake.");
		}
		else if (node == this)
		{
			throw new IllegalArgumentException("Detected attempt to add a node to itself. " +
					"This would cause inifite loops and must never happen.");
		}
		else if (node.getParentNode() != null && node.getParentNode() != this)
		{
			throw new IllegalArgumentException("Detected attempt to add child node that is already the " +
					"child of another node. Adding nodes multiple times is not allowed, since it could " +
					"cause infinite loops.");
		}
		final Element pathElement = node.getPathElement();
		if (node.getParentNode() == null)
		{
			node.setParentNode(this);
			.put(pathElementnode);
		}
		else if (node.getParentNode() == this)
		{
			.put(pathElementnode);
		}
		else
		{
			throw new IllegalStateException("Detected attempt to replace the parent node of node at path '" + getPropertyPath() + "'");
		}
		if ( == . && node.hasChanges())
		{
		}
		return true;
	}
	public final void visit(final Visitor visitor)
	{
		final Visit visit = new Visit();
		try
		{
			visit(visitorvisit);
		}
		catch (final StopVisitationException ignored)
		{
		}
	}
	protected final void visit(final Visitor visitorfinal Visit visit)
	{
		try
		{
			visitor.accept(thisvisit);
		}
		catch (final StopVisitationException e)
		{
			visit.stop();
		}
		if (visit.isAllowedToGoDeeper() && hasChildren())
		{
			visitChildren(visitor);
		}
		if (visit.isStopped())
		{
		}
	}
	public final void visitChildren(final Visitor visitor)
	{
		for (final Node child : getChildren())
		{
			try
			{
				child.visit(visitor);
			}
			{
				return;
			}
		}
	}
	{
		if ( instanceof PropertyAccessor)
		{
		}
		return unmodifiableSet(Collections.<Annotation>emptySet());
	}
	public <T extends Annotation> T getPropertyAnnotation(final Class<T> annotationClass)
	{
		if ( instanceof PropertyAccessor)
		{
			return ((PropertyAccessor).getReadMethodAnnotation(annotationClass);
		}
		return null;
	}
	public final boolean isRootNode()
	{
		return  instanceof RootAccessor;
	}
	public final boolean isEqualsOnly()
	{
	}
	public final boolean isIgnored()
	{
		return  == . || .isIgnored();
	}
	public final Set<StringgetCategories()
	{
		final Set<Stringset = new TreeSet<String>();
		if ( != null)
		{
		}
		if (.getCategories() != null)
		{
		}
		return set;
	}
	public void setState(final State state)
	{
		Assert.notNull(state"state");
		this. = state;
	}
	{
		return ;
	}
	public final void setParentNode(final Node parentNode)
	{
		if (this. != null && this. != parentNode)
		{
			throw new IllegalStateException("The parent of a node cannot be changed, once it's set.");
		}
		this. = parentNode;
	}
	public Object get(final Object target)
	{
		return .get(target);
	}
	public void set(final Object targetfinal Object value)
	{
		.set(targetvalue);
	}
	public void unset(final Object target)
	{
		.unset(target);
	}
	public Object canonicalGet(Object target)
	{
		if ( != null)
		{
			target = .canonicalGet(target);
		}
		return .get(target);
	}
	public void canonicalSet(Object targetfinal Object value)
	{
		if ( != null)
		{
			target = .canonicalGet(target);
		}
		.set(targetvalue);
	}
	public void canonicalUnset(Object target)
	{
		if ( != null)
		{
			target = .canonicalGet(target);
		}
		.unset(target);
	}
	public String toString()
	{
		final StringBuilder sb = new StringBuilder();
		sb.append("(");
		sb.append("state=");
		if (getType() != null)
		{
		}
		if (getChildren().size() == 1)
		{
			sb.append(", ").append(getChildren().size()).append(" child");
		}
		else if (getChildren().size() > 1)
		{
			sb.append(", ").append(getChildren().size()).append(" children");
		}
		else
		{
			sb.append(", no children");
		}
		{
			sb.append(", categorized as ").append(getCategories());
		}
		sb.append(", accessed via ").append();
		sb.append(')');
		return sb.toString();
	}
	public boolean equals(final Object o)
	{
		if (this == o)
		{
			return true;
		}
		if (o == null || getClass() != o.getClass())
		{
			return false;
		}
		final DefaultNode that = (DefaultNodeo;
		if (!.equals(that.accessor))
		{
			return false;
		}
		return true;
	}
	public int hashCode()
	{
		return .hashCode();
	}
	{
	}
	public void setCircleStartPath(final PropertyPath circularStartPath)
	{
		this. = circularStartPath;
	}
	{
	}
	public void setCircleStartNode(final Node circleStartNode)
	{
		this. = circleStartNode;
	}
New to GrepCode? Check out our FAQ X