/*

  * 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.apache.commons.classscan.bcel;

 import java.util.Set;

 import org.apache.bcel.classfile.Method;

 import org.apache.bcel.classfile.ParameterAnnotationEntry;

 import org.apache.bcel.generic.Type;

 import org.apache.commons.classscan.model.MetaAnnotation;

 import org.apache.commons.classscan.model.MetaParameter;

 import org.apache.commons.classscan.model.MetaType;

 import org.apache.commons.classscan.spi.model.SpiMetaClassLoader;

 import org.apache.commons.classscan.spi.model.SpiMetaMethod;

 import org.apache.commons.classscan.spi.model.SpiMetaParameter;

 import org.apache.commons.classscan.util.ResolveSet;

 public class BcelMethod implements SpiMetaMethod {

     private final String methodName;

     private final boolean isStatic;

     private final AnnotationMap annotations;

     private MetaType returnType;

     private String returnTypeDescriptor;

     private final ResolveSet<SpiMetaParameter> paramTypes;

     public BcelMethod(Method method) {

         methodName = method.getName();

         isStatic = method.isStatic();

         annotations = AnnotationMap.createAnnotations(method.getAnnotationEntries());

         returnTypeDescriptor = method.getReturnType().getSignature();

         paramTypes = createParameters(method);

     }

         @Override

         public boolean resolve(SpiMetaClassLoader classLoader) {

                 returnType = classLoader.resolveTypeForDescriptor(returnTypeDescriptor);

                 if(returnType==null) {

                         return false;

                 }

                 returnTypeDescriptor = null;

                 return annotations.resolve(classLoader)

                                 && paramTypes.resolve(classLoader);

         }

     @Override

     public String getName() {

         return methodName;

     }

     @Override

     public Set<? extends MetaAnnotation> getAnnotations() {

         return annotations;

     }

     @Override

     public MetaAnnotation getAnnotation(String annotationName) {

         return annotations.getValue(annotationName);

     }

     @Override

     public boolean isStatic() {

         return isStatic;

     }

     @Override

     public MetaType getType() {

         return returnType;

     }

     @Override

     public Set<? extends MetaParameter> getParameters() {

         return paramTypes;

     }

     private ResolveSet<SpiMetaParameter> createParameters(Method method) {

         final Type[] types = method.getArgumentTypes();

         if (types.length == 0) {

             return ResolveSet.emptyResolveSet();

         }

         final ParameterAnnotationEntry[] parameterAnnotations = method.getParameterAnnotationEntries();

         SpiMetaParameter[] metaParameterArray = new SpiMetaParameter[types.length];

         for (int i = 0; i < metaParameterArray.length; ++i) {

             // there may be less annotations than parameters

             ParameterAnnotationEntry arg = i < parameterAnnotations.length ? parameterAnnotations[i] : null;

             metaParameterArray[i] = new BcelParameter(types[i], arg);

         }

         ResolveSet<SpiMetaParameter> parameters = new ResolveSet<SpiMetaParameter>(metaParameterArray);

         return parameters;

     }

 }