/*

   * Copyright 2002-2009 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.beans.factory.config;

 import java.io.IOException;

 import java.io.ObjectInputStream;

 import java.io.Serializable;

 import java.lang.annotation.Annotation;

 import java.lang.reflect.Field;

 import java.lang.reflect.Type;

 import org.springframework.core.GenericCollectionTypeResolver;

 import org.springframework.core.MethodParameter;

 import org.springframework.core.ParameterNameDiscoverer;

 import org.springframework.util.Assert;

 public class DependencyDescriptor implements Serializable {

 	private transient MethodParameter methodParameter;

 	private transient Field field;

 	private Class declaringClass;

 	private String methodName;

 	private Class[] parameterTypes;

 	private int parameterIndex;

 	private String fieldName;

 	private final boolean required;

 	private final boolean eager;

 	private transient Annotation[] fieldAnnotations;


	

 	public DependencyDescriptor(MethodParameter methodParameter, boolean required) {

 		this(methodParameter, required, true);

 	}

	

 	public DependencyDescriptor(MethodParameter methodParameter, boolean required, boolean eager) {

 		Assert.notNull(methodParameter, "MethodParameter must not be null");

 		this.methodParameter = methodParameter;

 		this.declaringClass = methodParameter.getDeclaringClass();

 		if (this.methodParameter.getMethod() != null) {

 			this.methodName = methodParameter.getMethod().getName();

 			this.parameterTypes = methodParameter.getMethod().getParameterTypes();

 		}

 		else {

 			this.parameterTypes = methodParameter.getConstructor().getParameterTypes();

 		}

 		this.parameterIndex = methodParameter.getParameterIndex();

 		this.required = required;

 		this.eager = eager;

 	}

	

	public DependencyDescriptor(Field field, boolean required) {

		this(field, required, true);

	}

	

	public DependencyDescriptor(Field field, boolean required, boolean eager) {

		Assert.notNull(field, "Field must not be null");

		this.field = field;

		this.declaringClass = field.getDeclaringClass();

		this.fieldName = field.getName();

		this.required = required;

		this.eager = eager;

	}


	

	public MethodParameter getMethodParameter() {

		return this.methodParameter;

	}

	

	public Field getField() {

		return this.field;

	}

	

	public boolean isRequired() {

		return this.required;

	}

	

	public boolean isEager() {

		return this.eager;

	}


	

	public void initParameterNameDiscovery(ParameterNameDiscoverer parameterNameDiscoverer) {

		if (this.methodParameter != null) {

			this.methodParameter.initParameterNameDiscovery(parameterNameDiscoverer);

		}

	}

	

	public String getDependencyName() {

		return (this.field != null ? this.field.getName() : this.methodParameter.getParameterName());

	}

	

	public Class<?> getDependencyType() {

		return (this.field != null ? this.field.getType() : this.methodParameter.getParameterType());

	}

	

	public Type getGenericDependencyType() {

		return (this.field != null ? this.field.getGenericType() : this.methodParameter.getGenericParameterType());

	}

	

	public Class<?> getCollectionType() {

		return (this.field != null ?

				GenericCollectionTypeResolver.getCollectionFieldType(this.field) :

				GenericCollectionTypeResolver.getCollectionParameterType(this.methodParameter));

	}

	

	public Class<?> getMapKeyType() {

		return (this.field != null ?

				GenericCollectionTypeResolver.getMapKeyFieldType(this.field) :

				GenericCollectionTypeResolver.getMapKeyParameterType(this.methodParameter));

	}

	

	public Class<?> getMapValueType() {

		return (this.field != null ?

				GenericCollectionTypeResolver.getMapValueFieldType(this.field) :

				GenericCollectionTypeResolver.getMapValueParameterType(this.methodParameter));

	}

	

	public Annotation[] getAnnotations() {

		if (this.field != null) {

			if (this.fieldAnnotations == null) {

				this.fieldAnnotations = this.field.getAnnotations();

			}

			return this.fieldAnnotations;

		}

		else {

			return this.methodParameter.getParameterAnnotations();

		}

	}

	//---------------------------------------------------------------------

	// Serialization support

	//---------------------------------------------------------------------

	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {

		// Rely on default serialization; just initialize state after deserialization.

		ois.defaultReadObject();

		// Restore reflective handles (which are unfortunately not serializable)

		try {

			if (this.fieldName != null) {

				this.field = this.declaringClass.getDeclaredField(this.fieldName);

			}

			else if (this.methodName != null) {

				this.methodParameter = new MethodParameter(

						this.declaringClass.getDeclaredMethod(this.methodName, this.parameterTypes), this.parameterIndex);

			}

			else {

				this.methodParameter = new MethodParameter(

						this.declaringClass.getDeclaredConstructor(this.parameterTypes), this.parameterIndex);

			}

		}

		catch (Throwable ex) {

			throw new IllegalStateException("Could not find original class structure", ex);

		}

	}

}