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.instruction;
 
 
 import java.util.List;
 
 import static com.facebook.presto.byteCode.OpCode.ACONST_NULL;
 import static com.facebook.presto.byteCode.OpCode.BIPUSH;
 import static com.facebook.presto.byteCode.OpCode.DCONST_0;
 import static com.facebook.presto.byteCode.OpCode.DCONST_1;
 import static com.facebook.presto.byteCode.OpCode.FCONST_0;
 import static com.facebook.presto.byteCode.OpCode.FCONST_1;
 import static com.facebook.presto.byteCode.OpCode.FCONST_2;
 import static com.facebook.presto.byteCode.OpCode.ICONST_0;
 import static com.facebook.presto.byteCode.OpCode.ICONST_1;
 import static com.facebook.presto.byteCode.OpCode.ICONST_2;
 import static com.facebook.presto.byteCode.OpCode.ICONST_3;
 import static com.facebook.presto.byteCode.OpCode.ICONST_4;
 import static com.facebook.presto.byteCode.OpCode.ICONST_5;
 import static com.facebook.presto.byteCode.OpCode.ICONST_M1;
 import static com.facebook.presto.byteCode.OpCode.LCONST_0;
 import static com.facebook.presto.byteCode.OpCode.LCONST_1;
 import static com.facebook.presto.byteCode.OpCode.SIPUSH;
 import static com.facebook.presto.byteCode.ParameterizedType.type;
 import static com.facebook.presto.byteCode.instruction.FieldInstruction.getStaticInstruction;
 import static com.facebook.presto.byteCode.instruction.InvokeInstruction.invokeStatic;
 import static com.google.common.base.MoreObjects.toStringHelper;
 
 @SuppressWarnings("UnusedDeclaration")
 public abstract class Constant
         implements InstructionNode
 {
     public static Constant loadNull()
     {
         return new NullConstant();
     }
 
     public static Constant loadBoolean(boolean value)
     {
         return new BooleanConstant(value);
     }
 
     public static Constant loadBoxedBoolean(boolean value)
     {
         return new BoxedBooleanConstant(value);
     }
 
     public static Constant loadInt(int value)
     {
         return new IntConstant(value);
     }
 
     public static Constant loadBoxedInt(int value)
     {
         return new BoxedIntegerConstant(value);
     }
 
     public static Constant loadFloat(float value)
     {
         return new FloatConstant(value);
     }
 
     public static Constant loadBoxedFloat(float value)
     {
         return new BoxedFloatConstant(value);
     }
 
     public static Constant loadLong(long value)
     {
         return new LongConstant(value);
     }
 
     public static Constant loadBoxedLong(long value)
     {
         return new BoxedLongConstant(value);
     }
 
     public static Constant loadDouble(double value)
     {
        return new DoubleConstant(value);
    }
    public static Constant loadBoxedDouble(double value)
    {
        return new BoxedDoubleConstant(value);
    }
    public static Constant loadNumber(Number value)
    {
        Preconditions.checkNotNull(value"value is null");
        if (value instanceof Byte) {
            return loadInt((value).intValue());
        }
        if (value instanceof Short) {
            return loadInt((value).intValue());
        }
        if (value instanceof Integer) {
            return loadInt((Integervalue);
        }
        if (value instanceof Long) {
            return loadLong((Longvalue);
        }
        if (value instanceof Float) {
            return loadFloat((Floatvalue);
        }
        if (value instanceof Double) {
            return loadDouble((Doublevalue);
        }
        throw new IllegalStateException("Unsupported number type " + value.getClass().getSimpleName());
    }
    public static Constant loadString(String value)
    {
        Preconditions.checkNotNull(value"value is null");
        return new StringConstant(value);
    }
    public static Constant loadClass(Class<?> value)
    {
        Preconditions.checkNotNull(value"value is null");
        return new ClassConstant(type(value));
    }
    public static Constant loadClass(ParameterizedType value)
    {
        Preconditions.checkNotNull(value"value is null");
        return new ClassConstant(value);
    }
    public abstract Object getValue();
    @Override
    public List<ByteCodeNodegetChildNodes()
    {
        return ImmutableList.of();
    }
    @Override
    public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
    {
        return visitor.visitConstant(parentthis);
    }
    @Override
    public String toString()
    {
        return toStringHelper(this)
                .add("value"getValue())
                .toString();
    }
    public static class NullConstant
            extends Constant
    {
        @Override
        public Object getValue()
        {
            return null;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            visitor.visitInsn(.getOpCode());
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitConstant(parentthis);
        }
    }
    public static class BooleanConstant
            extends Constant
    {
        private final boolean value;
        private BooleanConstant(boolean value)
        {
            this. = value;
        }
        @Override
        public Boolean getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            if () {
                visitor.visitInsn(.getOpCode());
            }
            else {
                visitor.visitInsn(.getOpCode());
            }
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitBooleanConstant(parentthis);
        }
    }
    public static class BoxedBooleanConstant
            extends Constant
    {
        private final boolean value;
        private BoxedBooleanConstant(boolean value)
        {
            this. = value;
        }
        @Override
        public Boolean getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            if () {
                getStaticInstruction(Boolean.class"TRUE"Boolean.class).accept(visitorgenerationContext);
            }
            else {
                getStaticInstruction(Boolean.class"FALSE"Boolean.class).accept(visitorgenerationContext);
            }
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitBoxedBooleanConstant(parentthis);
        }
    }
    public static class IntConstant
            extends Constant
    {
        private final int value;
        private IntConstant(int value)
        {
            this. = value;
        }
        @Override
        public Integer getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            if ( <= . &&  >= .) {
                switch () {
                    case -1:
                        visitor.visitInsn(.getOpCode());
                        break;
                    case 0:
                        visitor.visitInsn(.getOpCode());
                        break;
                    case 1:
                        visitor.visitInsn(.getOpCode());
                        break;
                    case 2:
                        visitor.visitInsn(.getOpCode());
                        break;
                    case 3:
                        visitor.visitInsn(.getOpCode());
                        break;
                    case 4:
                        visitor.visitInsn(.getOpCode());
                        break;
                    case 5:
                        visitor.visitInsn(.getOpCode());
                        break;
                    default:
                        visitor.visitIntInsn(.getOpCode(), );
                        break;
                }
            }
            else if ( <= . &&  >= .) {
                visitor.visitIntInsn(.getOpCode(), );
            }
            else {
                visitor.visitLdcInsn();
            }
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitIntConstant(parentthis);
        }
    }
    public static class BoxedIntegerConstant
            extends Constant
    {
        private final int value;
        private BoxedIntegerConstant(int value)
        {
            this. = value;
        }
        @Override
        public Integer getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            loadInt().accept(visitorgenerationContext);
            invokeStatic(Integer.class"valueOf"Integer.classint.class).accept(visitorgenerationContext);
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitBoxedIntegerConstant(parentthis);
        }
    }
    public static class FloatConstant
            extends Constant
    {
        private final float value;
        private FloatConstant(float value)
        {
            this. = value;
        }
        @Override
        public Float getValue()
        {
            return ;
        }
        @Override
        @SuppressWarnings("FloatingPointEquality")
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            // We can not use "value == 0.0" because when value is "-0.0" the expression
            // will evaluate to true and we would convert "-0.0" to "0.0" which is
            // not the same value
            if (Float.floatToIntBits() == Float.floatToIntBits(0.0f)) {
                visitor.visitInsn(.getOpCode());
            }
            else if ( == 1.0f) {
                visitor.visitInsn(.getOpCode());
            }
            else if ( == 2.0f) {
                visitor.visitInsn(.getOpCode());
            }
            else {
                visitor.visitLdcInsn();
            }
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitFloatConstant(parentthis);
        }
    }
    public static class BoxedFloatConstant
            extends Constant
    {
        private final float value;
        private BoxedFloatConstant(float value)
        {
            this. = value;
        }
        @Override
        public Float getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            loadFloat().accept(visitorgenerationContext);
            invokeStatic(Float.class"valueOf"Float.classfloat.class).accept(visitorgenerationContext);
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitBoxedFloatConstant(parentthis);
        }
    }
    public static class LongConstant
            extends Constant
    {
        private final long value;
        private LongConstant(long value)
        {
            this. = value;
        }
        @Override
        public Long getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            if ( == 0) {
                visitor.visitInsn(.getOpCode());
            }
            else if ( == 1) {
                visitor.visitInsn(.getOpCode());
            }
            else {
                visitor.visitLdcInsn();
            }
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitLongConstant(parentthis);
        }
    }
    public static class BoxedLongConstant
            extends Constant
    {
        private final long value;
        private BoxedLongConstant(long value)
        {
            this. = value;
        }
        @Override
        public Long getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            loadLong().accept(visitorgenerationContext);
            invokeStatic(Long.class"valueOf"Long.classlong.class).accept(visitorgenerationContext);
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitBoxedLongConstant(parentthis);
        }
    }
    public static class DoubleConstant
            extends Constant
    {
        private final double value;
        private DoubleConstant(double value)
        {
            this. = value;
        }
        @Override
        public Double getValue()
        {
            return ;
        }
        @Override
        @SuppressWarnings("FloatingPointEquality")
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            // We can not use "value == 0.0" because when value is "-0.0" the expression
            // will evaluate to true and we would convert "-0.0" to "0.0" which is
            // not the same value
            if (Double.doubleToLongBits() == Double.doubleToLongBits(0.0)) {
                visitor.visitInsn(.getOpCode());
            }
            else if ( == 1.0) {
                visitor.visitInsn(.getOpCode());
            }
            else {
                visitor.visitLdcInsn();
            }
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitDoubleConstant(parentthis);
        }
    }
    public static class BoxedDoubleConstant
            extends Constant
    {
        private final double value;
        private BoxedDoubleConstant(double value)
        {
            this. = value;
        }
        @Override
        public Double getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            loadDouble().accept(visitorgenerationContext);
            invokeStatic(Double.class"valueOf"Double.classdouble.class).accept(visitorgenerationContext);
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitBoxedDoubleConstant(parentthis);
        }
    }
    public static class StringConstant
            extends Constant
    {
        private final String value;
        private StringConstant(String value)
        {
            this. = value;
        }
        @Override
        public String getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            visitor.visitLdcInsn();
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitStringConstant(parentthis);
        }
    }
    public static class ClassConstant
            extends Constant
    {
        private final ParameterizedType value;
        private ClassConstant(ParameterizedType value)
        {
            this. = value;
        }
        @Override
        public ParameterizedType getValue()
        {
            return ;
        }
        @Override
        public void accept(MethodVisitor visitorMethodGenerationContext generationContext)
        {
            visitor.visitLdcInsn(Type.getType(.getType()));
        }
        @Override
        public <T> T accept(ByteCodeNode parentByteCodeVisitor<T> visitor)
        {
            return visitor.visitClassConstant(parentthis);
        }
    }