Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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 com.facebook.presto.byteCode;
 
 
 
 import java.util.List;
 
 import static com.facebook.presto.byteCode.Access.STATIC;
 import static com.facebook.presto.byteCode.Access.toAccessModifier;
 import static com.facebook.presto.byteCode.ParameterizedType.type;
 import static com.google.common.collect.Iterables.transform;
 import static org.objectweb.asm.Opcodes.RETURN;
 
 @SuppressWarnings("UnusedDeclaration")
 public class MethodDefinition
 {
     private final Scope scope;
     private final ClassDefinition declaringClass;
     private final EnumSet<Accessaccess;
     private final String name;
     private final List<AnnotationDefinitionannotations = new ArrayList<>();
     private final ParameterizedType returnType;
     private final List<Parameterparameters;
     private final List<ParameterizedTypeparameterTypes;
     private final List<ParameterizedTypeexceptions = new ArrayList<>();
 
     private final Block body;
     private String comment;
 
     public MethodDefinition(
             ClassDefinition declaringClass,
             EnumSet<Accessaccess,
             String name,
             ParameterizedType returnType,
             Parameter... parameters
     )
     {
         this(declaringClassaccessnamereturnType, ImmutableList.copyOf(parameters));
     }
 
     public MethodDefinition(
             ClassDefinition declaringClass,
             EnumSet<Accessaccess,
             String name,
             ParameterizedType returnType,
             Iterable<Parameterparameters
     )
     {
         this. = declaringClass;
          = new Block();
 
         this. = access;
         this. = name;
         if (returnType != null) {
             this. = returnType;
         }
         else {
             this. = type(void.class);
         }
         this. = ImmutableList.copyOf(parameters);
         this. = Lists.transform(this., Parameter::getType);
         this. = ImmutableList.copyOf(transform(parametersinput -> new ArrayList<>()));
 
         Optional<ParameterizedTypethisType = Optional.empty();
         if (!access.contains()) {
             thisType = Optional.of(declaringClass.getType());
         }
          = new Scope(thisTypeparameters);
     }
 
     {
         return ;
     }
 
    {
        return ImmutableList.copyOf();
    }
    {
        return ImmutableList.copyOf(.get(index));
    }
    public EnumSet<AccessgetAccess()
    {
        return ;
    }
    public String getName()
    {
        return ;
    }
    {
        return ;
    }
    public List<ParametergetParameters()
    {
        return ;
    }
    {
        return ;
    }
    {
        return ;
    }
    public MethodDefinition addException(Class<? extends ThrowableexceptionClass)
    {
        .add(type(exceptionClass));
        return this;
    }
    public MethodDefinition comment(String formatObject... args)
    {
        this. = String.format(formatargs);
        return this;
    }
    public String getComment()
    {
        return ;
    }
    public Scope getScope()
    {
        return ;
    }
    public Variable getThis()
    {
        return .getThis();
    }
    public String getMethodDescriptor()
    {
        return methodDescription();
    }
    public Block getBody()
    {
        return ;
    }
    {
        AnnotationDefinition annotationDefinition = new AnnotationDefinition(type);
        .add(annotationDefinition);
        return annotationDefinition;
    }
    {
        AnnotationDefinition annotationDefinition = new AnnotationDefinition(type);
        .add(annotationDefinition);
        return annotationDefinition;
    }
    public AnnotationDefinition declareParameterAnnotation(Class<?> typeint parameterIndex)
    {
        AnnotationDefinition annotationDefinition = new AnnotationDefinition(type);
        .get(parameterIndex).add(annotationDefinition);
        return annotationDefinition;
    }
    public AnnotationDefinition declareParameterAnnotation(ParameterizedType typeint parameterIndex)
    {
        AnnotationDefinition annotationDefinition = new AnnotationDefinition(type);
        .get(parameterIndex).add(annotationDefinition);
        return annotationDefinition;
    }
    public void visit(ClassVisitor visitor)
    {
        visit(visitorfalse);
    }
    public void visit(ClassVisitor visitorboolean addReturn)
    {
        String[] exceptions = new String[this..size()];
        for (int i = 0; i < exceptions.lengthi++) {
            exceptions[i] = this..get(i).getClassName();
        }
        MethodVisitor methodVisitor = visitor.visitMethod(toAccessModifier(),
                ,
                getMethodDescriptor(),
                genericMethodSignature(),
                exceptions);
        if (methodVisitor == null) {
            return;
        }
        // visit method annotations
        for (AnnotationDefinition annotation : ) {
            annotation.visitMethodAnnotation(methodVisitor);
        }
        // visit parameter annotations
        for (int parameterIndex = 0; parameterIndex < .size(); parameterIndex++) {
            List<AnnotationDefinitionparameterAnnotations1 = this..get(parameterIndex);
            for (AnnotationDefinition parameterAnnotation : parameterAnnotations1) {
                parameterAnnotation.visitParameterAnnotation(parameterIndexmethodVisitor);
            }
        }
        // visit code
        methodVisitor.visitCode();
        // visit instructions
        MethodGenerationContext generationContext = new MethodGenerationContext(methodVisitor);
        generationContext.enterScope();
        .accept(methodVisitorgenerationContext);
        if (addReturn) {
            new InsnNode().accept(methodVisitor);
        }
        generationContext.exitScope();
        // done
        methodVisitor.visitMaxs(-1, -1);
        methodVisitor.visitEnd();
    }
    public String toSourceString()
    {
        StringBuilder sb = new StringBuilder();
        Joiner.on(' ').appendTo(sb).append(' ');
        sb.append(.getJavaClassName()).append(' ');
        sb.append().append('(');
        Joiner.on(", ").appendTo(sbtransform(, Parameter::getSourceString)).append(')');
        return sb.toString();
    }
    @Override
    public String toString()
    {
        return toSourceString();
    }
    public static String methodDescription(Class<?> returnTypeClass<?>... parameterTypes)
    {
        return methodDescription(returnType, ImmutableList.copyOf(parameterTypes));
    }
    public static String methodDescription(Class<?> returnTypeList<Class<?>> parameterTypes)
    {
        return methodDescription(
                type(returnType),
                Lists.transform(parameterTypes, ParameterizedType::type)
        );
    }
    public static String methodDescription(
            ParameterizedType returnType,
            ParameterizedType... parameterTypes
    )
    {
        return methodDescription(returnType, ImmutableList.copyOf(parameterTypes));
    }
    public static String methodDescription(
            ParameterizedType returnType,
            List<ParameterizedTypeparameterTypes
    )
    {
        StringBuilder sb = new StringBuilder();
        sb.append("(");
        Joiner.on("").appendTo(sbtransform(parameterTypes, ParameterizedType::getType));
        sb.append(")");
        sb.append(returnType.getType());
        return sb.toString();
    }
    public static String genericMethodSignature(
            ParameterizedType returnType,
            ParameterizedType... parameterTypes
    )
    {
        return genericMethodSignature(returnType, ImmutableList.copyOf(parameterTypes));
    }
    public static String genericMethodSignature(
            ParameterizedType returnType,
            List<ParameterizedTypeparameterTypes
    )
    {
        StringBuilder sb = new StringBuilder();
        sb.append("(");
        Joiner.on("").appendTo(sbparameterTypes);
        sb.append(")");
        sb.append(returnType);
        return sb.toString();
    }
New to GrepCode? Check out our FAQ X