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.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 public class ParameterizedType
 {
     public static ParameterizedType typeFromJavaClassName(String className)
     {
         checkNotNull(className"type is null");
         if (className.endsWith("/")) {
             checkArgument(!className.endsWith(";"), "Invalid class name %s"className);
         }
         return new ParameterizedType(className.replace('.''/'));
     }
 
     public static ParameterizedType typeFromPathName(String className)
     {
         checkNotNull(className"type is null");
         if (className.indexOf(".") > 0) {
             checkArgument(!className.endsWith(";"), "Invalid class name %s"className);
         }
         return new ParameterizedType(className);
     }
 
     public static ParameterizedType type(Type type)
     {
         checkNotNull(type"type is null");
         return new ParameterizedType(type.getInternalName());
     }
 
     public static ParameterizedType type(Class<?> type)
     {
         checkNotNull(type"type is null");
         return new ParameterizedType(type);
     }
 
     public static ParameterizedType type(Class<?> typeClass<?>... parameters)
     {
         checkNotNull(type"type is null");
         return new ParameterizedType(typeparameters);
     }
 
     public static ParameterizedType type(Class<?> typeParameterizedType... parameters)
     {
         checkNotNull(type"type is null");
         return new ParameterizedType(typeparameters);
     }
 
     private final String type;
     private final String className;
     private final String simpleName;
     private final List<Stringparameters;
 
     private final boolean isInterface;
     @Nullable
     private final Class<?> primitiveType;
     @Nullable
     private final ParameterizedType arrayComponentType;
 
     public ParameterizedType(String className)
     {
         checkNotNull(className"className is null");
         checkArgument(!className.contains("."), "Invalid class name %s"className);
         checkArgument(!className.endsWith(";"), "Invalid class name %s"className);
 
         this. = className;
         this. = className.substring(className.lastIndexOf("/") + 1);
         this. = "L" + className + ";";
         this. = ImmutableList.of();
 
         this. = false;
         this. = null;
         this. = null;
     }
 
     private ParameterizedType(Class<?> type)
    {
        checkNotNull(type"type is null");
        this. = toInternalIdentifier(type);
        this. = getPathName(type);
        this. = type.getSimpleName();
        this. = ImmutableList.of();
        this. = type.isInterface();
        this. = type.isPrimitive() ? type : null;
        this. = type.isArray() ? type(type.getComponentType()) : null;
    }
    private ParameterizedType(Class<?> typeClass<?>... parameters)
    {
        checkNotNull(type"type is null");
        this. = toInternalIdentifier(type);
        this. = getPathName(type);
        this. = type.getSimpleName();
        ImmutableList.Builder<Stringbuilder = ImmutableList.builder();
        for (Class<?> parameter : parameters) {
            builder.add(toInternalIdentifier(parameter));
        }
        this. = builder.build();
        this. = type.isInterface();
        this. = type.isPrimitive() ? type : null;
        this. = type.isArray() ? type(type.getComponentType()) : null;
    }
    private ParameterizedType(Class<?> typeParameterizedType... parameters)
    {
        checkNotNull(type"type is null");
        this. = toInternalIdentifier(type);
        this. = getPathName(type);
        this. = type.getSimpleName();
        ImmutableList.Builder<Stringbuilder = ImmutableList.builder();
        for (ParameterizedType parameter : parameters) {
            builder.add(parameter.toString());
        }
        this. = builder.build();
        this. = type.isInterface();
        this. = type.isPrimitive() ? type : null;
        this. = type.isArray() ? type(type.getComponentType()) : null;
    }
    public String getClassName()
    {
        return ;
    }
    public String getJavaClassName()
    {
        return .replace('/''.');
    }
    public String getSimpleName()
    {
        return ;
    }
    public String getType()
    {
        return ;
    }
    public Type getAsmType()
    {
        return Type.getObjectType();
    }
    public String getGenericSignature()
    {
        StringBuilder sb = new StringBuilder();
        if ( != null ||  != null) {
            return ;
        }
        sb.append('L').append();
        if (!.isEmpty()) {
            sb.append("<");
            for (String parameterType : ) {
                sb.append(parameterType);
            }
            sb.append(">");
        }
        sb.append(";");
        return sb.toString();
    }
    public boolean isGeneric()
    {
        return !.isEmpty();
    }
    public boolean isInterface()
    {
        return ;
    }
    @Nullable
    public Class<?> getPrimitiveType()
    {
        return ;
    }
    public boolean isPrimitive()
    {
        return  != null;
    }
    @Nullable
    {
        return ;
    }
    @Override
    public boolean equals(Object o)
    {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        ParameterizedType that = (ParameterizedTypeo;
        if (!.equals(that.type)) {
            return false;
        }
        return true;
    }
    @Override
    public int hashCode()
    {
        return .hashCode();
    }
    @Override
    public String toString()
    {
        return getGenericSignature();
    }
    public static String getPathName(Class<?> n)
    {
        return n.getName().replace('.''/');
    }
    private static String toInternalIdentifier(Class<?> n)
    {
        if (n.isArray()) {
            n = n.getComponentType();
            if (n.isPrimitive()) {
                if (n == .) {
                    return "[B";
                }
                else if (n == .) {
                    return "[Z";
                }
                else if (n == .) {
                    return "[S";
                }
                else if (n == .) {
                    return "[C";
                }
                else if (n == .) {
                    return "[I";
                }
                else if (n == .) {
                    return "[F";
                }
                else if (n == .) {
                    return "[D";
                }
                else if (n == .) {
                    return "[J";
                }
                else {
                    throw new RuntimeException("Unrecognized type in compiler: " + n.getName());
                }
            }
            else {
                return "[" + toInternalIdentifier(n);
            }
        }
        else {
            if (n.isPrimitive()) {
                if (n == .) {
                    return "B";
                }
                else if (n == .) {
                    return "Z";
                }
                else if (n == .) {
                    return "S";
                }
                else if (n == .) {
                    return "C";
                }
                else if (n == .) {
                    return "I";
                }
                else if (n == .) {
                    return "F";
                }
                else if (n == .) {
                    return "D";
                }
                else if (n == .) {
                    return "J";
                }
                else if (n == .) {
                    return "V";
                }
                else {
                    throw new RuntimeException("Unrecognized type in compiler: " + n.getName());
                }
            }
            else {
                return "L" + getPathName(n) + ";";
            }
        }
    }
New to GrepCode? Check out our FAQ X