source: java2python/src/main/java/tudelft/utilities/j2p/t/StubPrimitive.java@ 372

package tudelft.utilities.j2p.t;

import java.util.Arrays;
import java.util.List;

import com.github.javaparser.ast.Node;
import com.github.javaparser.ast.expr.FieldAccessExpr;
import com.github.javaparser.ast.expr.MethodCallExpr;
import com.github.javaparser.resolution.declarations.ResolvedAnnotationDeclaration;

import tudelft.utilities.j2p.formatting.Block;
import tudelft.utilities.j2p.formatting.ExpressionLine;

/***
 * Stub but for primitives (int, boolean, byte, char..)
 */
public class StubPrimitive implements J2P {

        private static final List<String> primitivetypes = Arrays.asList("boolean",
                        "byte", "char", "float", "int", "long", "short", "double", "void");

        private String type;

        private ExpressionLine INTTYPE = new ExpressionLine("int");

        private ExpressionLine BOOLTYPE = new ExpressionLine("bool");

        private ExpressionLine CHARTYPE = new ExpressionLine("str");

        private ExpressionLine FLOATTYPE = new ExpressionLine("float");

        // PEP-484: None is considered equivalent to type(None)
        private ExpressionLine VOIDTYPE = new ExpressionLine("None");

        /**
         * 
         * @param type
         * @return true if given type is primitive type. Note that "void" is also
         *         supported as if it were a primitive type. This is because there
         *         is not a "void" class and we need a Stub for the void type
         */
        static public boolean isPrimitive(String type) {
                return primitivetypes.contains(type);
        }

        /**
         * 
         * @param primitive "int","char", etc
         */
        public StubPrimitive(String primitive) {
                this.type = primitive;
                getName(); // check if type is legla
        }

        @Override
        public ExpressionLine call(MethodCallExpr callexp) {
                throw new IllegalArgumentException(
                                "Not implemented " + this.getClass() + callexp);
        }

        @Override
        public ExpressionLine getName() {
                switch (type) {
                case "int":
                        return INTTYPE;
                case "boolean":
                        return BOOLTYPE;
                case "char":
                        return CHARTYPE; // should we?
                case "long":
                        return INTTYPE;
                case "float":
                        return FLOATTYPE;
                case "double":
                        return FLOATTYPE;
                case "short":
                        return INTTYPE;
                case "void":
                        return VOIDTYPE;

                }
                throw new IllegalArgumentException("Unknown type " + type);
        }

        @Override
        public ExpressionLine field(FieldAccessExpr node) {
                throw new IllegalArgumentException(
                                "primitive " + type + "has no field");
        }

        @Override
        public Block annotate(Node code, ResolvedAnnotationDeclaration annotation) {
                throw new IllegalArgumentException(
                                "Primitives do not support annotation");
        }

}