org.hobsoft.symmetry.hydrate.HydrationContext Maven / Gradle / Ivy

Go to download
/*
 * 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.hobsoft.symmetry.hydrate;

import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import static org.hobsoft.symmetry.hydrate.Utilities.checkNotNull;

/**
 * 
 * 
 * @author Mark Hobson
 */
public abstract class HydrationContext
{
	// TODO: add remove(Class parameterType)
	
	// fields -----------------------------------------------------------------
	
	private final Map, Deque> parametersByType;
	
	// constructors -----------------------------------------------------------
	
	public HydrationContext()
	{
		this.parametersByType = new HashMap, Deque>();
	}
	
	// public methods ---------------------------------------------------------
	
	public Set> getParameterTypes()
	{
		return new HashSet>(parametersByType.keySet());
	}
	
	public  T get(Class parameterType)
	{
		T parameter = get(parameterType, null);
		
		if (parameter == null)
		{
			throw new IllegalArgumentException("Parameter not found: " + parameterType.getName());
		}
		
		return parameterType.cast(parameter);
	}
	
	public  T get(Class parameterType, T defaultParameter)
	{
		checkNotNull(parameterType, "parameterType");
		
		T parameter;
		
		if (parametersByType.containsKey(parameterType))
		{
			parameter = getParameterDeque(parameterType).peek();
		}
		else
		{
			parameter = defaultParameter;
		}
		
		return parameter;
	}
	
	public  T getOrSet(Class parameterType, T defaultParameter)
	{
		checkNotNull(defaultParameter, "defaultParameter");
		
		T parameter = get(parameterType, null);
		
		if (parameter == null)
		{
			parameter = defaultParameter;
			
			set(parameterType, parameter);
		}
		
		return parameter;
	}
	
	public Map, Object> getAll()
	{
		return getParameters(this);
	}
	
	public  void set(Class parameterType, T parameter)
	{
		checkNotNull(parameterType, "parameterType");
		checkNotNull(parameter, "parameter");
		
		parametersByType.put(parameterType, createParameterDeque(parameter));
	}
	
	public void setAll(Map, ?> parametersByType)
	{
		if (parametersByType == null)
		{
			return;
		}
		
		for (Entry, ?> entry : parametersByType.entrySet())
		{
			Class parameterType = entry.getKey();
			Object parameter = entry.getValue();
			
			setCapture(parameterType, parameter);
		}
	}
	
	public  void push(Class parameterType, T parameter)
	{
		checkNotNull(parameterType, "parameterType");
		checkNotNull(parameter, "parameter");
		
		if (parametersByType.containsKey(parameterType))
		{
			getParameterDeque(parameterType).push(parameter);
		}
		else
		{
			set(parameterType, parameter);
		}
	}
	
	public  T pop(Class parameterType)
	{
		if (!parametersByType.containsKey(parameterType))
		{
			throw new IllegalArgumentException("Parameter not found: " + parameterType.getName());
		}
		
		Deque parameterDeque = getParameterDeque(parameterType);
		T parameter = parameterDeque.pop();
		
		if (parameterDeque.isEmpty())
		{
			parametersByType.remove(parameterType);
		}
		
		return parameter;
	}
	
	// Object methods ---------------------------------------------------------
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	public int hashCode()
	{
		return parametersByType.hashCode();
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	public boolean equals(Object object)
	{
		if (!(object instanceof HydrationContext))
		{
			return false;
		}
		
		HydrationContext context = (HydrationContext) object;
		
		return parametersByType.equals(context.parametersByType);
	}
	
	// private methods --------------------------------------------------------
	
	private static  Deque createParameterDeque(T parameter)
	{
		return new LinkedList(Collections.singleton(parameter));
	}
	
	private  Deque getParameterDeque(Class parameterType)
	{
		return (Deque) parametersByType.get(parameterType);
	}
	
	private static Map, Object> getParameters(HydrationContext context)
	{
		Map, Object> parametersByType = new HashMap, Object>();
		
		for (Class parameterType : context.getParameterTypes())
		{
			Object parameter = context.get(parameterType);
			
			parametersByType.put(parameterType, parameter);
		}
		
		return parametersByType;
	}
	
	private  void setCapture(Class parameterType, Object parameter)
	{
		T castParameter = parameterType.cast(parameter);
		
		set(parameterType, castParameter);
	}
}