source: java2python/src/main/java/tudelft/utilities/j2p/t/J2P.java@ 381

package tudelft.utilities.j2p.t;

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

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

/**
 * The interface to java-python translator. A translator helps to translate java
 * Class access - function calls and field access. The result is a {@link Block}
 * containing python code and imports. Translators for a class full.class.path
 * are stored in the package
 * <code>tudelft.utilities.j2p.t.full.class.path</code>. See also
 * {@link #fetch(Object)}
 * <p>
 * Third party libraries should also put their packages in this same
 * <code>tudelft.utilities.j2p.t.XXX</code> package. For instance a translator
 * for "com.mycompany" could provide a jar with classes in
 * <code>tudelft.utilities.j2p.t.com.mycompany</code>.
 * 
 * @param <NodeType> the type of the java object that is translated into Python
 *                   code.
 */
public interface J2P {
        static final String BASE = "tudelft.utilities.j2p.t.";

        /**
         * Translates a MethodCall in java to python The impplementation may have to
         * do further calls to translate scope and arguments. This is deliberately
         * left to the translator so that it can manipulate function names, argument
         * orders etc. Specific example : SCOPE.getClass() -> type(SCOPE). Here the
         * scope SCOPE needs to be put as argument inside the call. This potential
         * reversal requires us to pass the SCOPE into the call translator....
         * 
         * 
         * @param callexp the {@link MethodCallExpr},
         * @return a Block with the translation
         */
        public ExpressionLine call(MethodCallExpr callexp);

        /**
         * 
         * @return an {@link ExpressionLine} with the simple name, plus the required
         *         imports and installs to use this. eg when there is a Range object
         *         in the immutablelist package, this might return an ExpressionLine
         *         with text "Range", import "from tudelft.immutablelist.Range
         *         import Range" and install "utilities@http://.....".
         */
        public ExpressionLine getName();

        /**
         * @param node a {@link FieldAccessExpr}
         * @return code accessing the equivalent field in Python
         */
        public ExpressionLine field(FieldAccessExpr node);

        /**
         * @param code the code that had an annotation (but this annotation is
         *             removed already)
         * @param anno the annotation to be applied to the code. This is an
         *             annotation of the code.
         * @return a translation of annotated code. Usually, annotate does just a
         *         normal translation of the code, with a few small modifications.
         */
        public Block annotate(Node code, AnnotationExpr anno);

        /************ FACTORY METHODS ************/
        /**
         * 
         * @param node the {@link Object} to be translated
         * @return translator for that node type
         * @throws ClassNotFoundException
         */
        public static J2P fetch(Object node) throws ClassNotFoundException {
                return fetch(node.getClass().getName());
        }

        /**
         * 
         * @param fully_qualified_name, as returned by {@link Class#getName()}. name
         *                              can also be a primitive type, eg "int",
         *                              referring to the java int.
         * @return a J2P that can translate the given fully_qualified_name
         * @throws IllegalArgumentException if the argument can not be handled, eg
         *                                  because there is no translator for the
         *                                  specified class
         */
        public static J2P fetch(String fully_qualified_name)
                        throws IllegalArgumentException {

                if (StubPrimitive.isPrimitive(fully_qualified_name)) {
                        return new StubPrimitive(fully_qualified_name);
                }

                String trname = BASE + fully_qualified_name;
                Class<?> clazz;
                try {
                        clazz = Class.forName(trname);
                } catch (ClassNotFoundException e) {
                        // it's not explicitly stubbed.
                        // If it's not a system class, try to stub it
                        if (!(fully_qualified_name.startsWith("java")))
                                try {
                                        return new Stub(Class.forName(fully_qualified_name));
                                } catch (ClassNotFoundException e1) {
                                        // we are going to throw anyway
                                }

                        throw new IllegalArgumentException("No translator found for "
                                        + fully_qualified_name + ", missing class " + trname
                                        + ". Please add translator or translator-modules to your project.");
                }

                // if we get here, we found explicit stub clazz
                try {
                        if (!J2P.class.isAssignableFrom(clazz))
                                throw new ClassCastException(
                                                "class " + trname + " is not implementing J2P");
                        return (J2P) clazz.getDeclaredConstructor().newInstance();
                } catch (Exception e) {
                        throw new IllegalArgumentException("Found translator " + trname
                                        + " but failed to create instance", e);
                }
        }

}