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

package tudelft.utilities.j2p.t;

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

import com.github.javaparser.ast.expr.FieldAccessExpr;
import com.github.javaparser.ast.expr.MethodCallExpr;

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;

        /**
         * 
         * @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 String getName() {
                switch (type) {
                case "int":
                        return "int";
                case "boolean":
                        return "bool";
                case "char":
                        return "str"; // should we?
                case "long":
                        return "int";
                case "float":
                        return "float";
                case "double":
                        return "float";
                case "short":
                        return "int";
                case "void":
                        return "None"; // PEP-484: None is considered equivalent to
                                                        // type(None)

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

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

        @Override
        public String getImport() {
                return null;
        }

}