Examples with Quadruple com.ms.silverking.collection.Quadruple used on opensource projects

Example 1 with Quadruple

use of com.ms.silverking.collection.Quadruple in project SilverKing by Morgan-Stanley.

the class WrapperGenerator method generate.

/**
 * Loop through all ParseElements in the list.
 * For text, put as is.
 * For other elements, process according to type.
 * @param c
 * @param elements
 * @param outputDir
 * @param loopIndex
 * @param depth TODO
 * @throws IOException
 */
private void generate(Context c, List<ParseElement> elements, File outputDir, int loopIndex, int depth) throws IOException {
    int i;
    if (debugGeneration) {
        Thread.dumpStack();
        System.out.printf("generate elements %d loopIndex %d depth %d\n", elements.size(), loopIndex, depth);
    }
    i = 0;
    while (i < elements.size()) {
        ParseElement e;
        e = elements.get(i);
        c = c.loopIndex(loopIndex);
        if (debugGeneration) {
            System.out.printf("%s%d\t%s\n", StringUtil.replicate(debugTab, depth), i, e);
        }
        if (e instanceof Text) {
            outStreams.print(c, (Text) e);
            i++;
        } else if (e instanceof Expression) {
            Pair<Context, String> result;
            result = ((Expression) e).evaluate(c);
            c = result.getV1();
            if (result.getV2() != null) {
                outStreams.print(c, result.getV2());
            }
            i++;
        } else if (e instanceof LoopElement) {
            LoopElement le;
            le = (LoopElement) e;
            if (!isValidLoopTarget(c.getLoopElement(), le.getTarget())) {
                generateLoopTargetException(le);
            } else {
                List<ParseElement> loopElements;
                Context _c;
                int newLoopIndex;
                newLoopIndex = 0;
                loopElements = getLoopElements(elements, i);
                _c = c.loopElement(le);
                if (debugGeneration) {
                    System.out.printf("G%sLoop %d %d\n", StringUtil.replicate(debugTab, depth), i, i + loopElements.size());
                }
                switch(le.getTarget()) {
                    case Packages:
                        for (GenPackageClasses genPackageClasses : c.getPackages()) {
                            Context packageContext;
                            packageContext = _c.genPackageClasses(genPackageClasses);
                            generate(packageContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case Classes:
                        // _c = c.loopElements(c.getPackageClasses().size());
                        for (Class _class : c.getPackageClasses()) {
                            Context classContext;
                            classContext = _c.class_(_class);
                            generate(classContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case Methods:
                        // _c = c.loopElements(c.getClass_().getDeclaredMethods().length);
                        for (Method m : getMethodsForGeneration(c.getClass_())) {
                            // for (Method m : c.getClass_().getMethods()) {
                            if (!Modifier.isStatic(m.getModifiers()) && Modifier.isPublic(m.getModifiers())) {
                                System.out.printf("Method\t%s\t%s\t%s\n", m.getName(), !JNIUtil.omitted(m), referenceFinder.allReferencesPresent(m));
                            }
                            if (!Modifier.isStatic(m.getModifiers()) && Modifier.isPublic(m.getModifiers()) && !JNIUtil.omitted(m) && referenceFinder.allReferencesPresent(m)) {
                                Context methodContext;
                                methodContext = _c.method(m);
                                generate(methodContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case StaticMethods:
                        // _c = c.loopElements(c.getClass_().getDeclaredMethods().length);
                        for (Method m : getMethodsForGeneration(c.getClass_())) {
                            // for (Method m : c.getClass_().getMethods()) {
                            if (Modifier.isStatic(m.getModifiers()) && Modifier.isPublic(m.getModifiers()) && !JNIUtil.omitted(m) && referenceFinder.allReferencesPresent(m)) {
                                Context methodContext;
                                methodContext = _c.method(m);
                                generate(methodContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case Constructors:
                        for (Constructor constructor : c.getClass_().getConstructors()) {
                            if (Modifier.isPublic(constructor.getModifiers()) && !JNIUtil.omitted(constructor) && referenceFinder.allReferencesPresent(constructor)) {
                                Context constructorContext;
                                constructorContext = _c.constructor(constructor);
                                generate(constructorContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case NonEmptyConstructors:
                        for (Constructor constructor : c.getClass_().getConstructors()) {
                            if (Modifier.isPublic(constructor.getModifiers()) && !JNIUtil.omitted(constructor) && referenceFinder.allReferencesPresent(constructor)) {
                                if (constructor.getParameterCount() > 0) {
                                    Context constructorContext;
                                    constructorContext = _c.constructor(constructor);
                                    generate(constructorContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                                }
                            }
                        }
                        break;
                    case Parameters:
                        _c = c.loopElements(c.getActiveParameters().length);
                        for (Parameter p : c.getActiveParameters()) {
                            Context parameterContext;
                            parameterContext = _c.parameter(p);
                            generate(parameterContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case StaticFields:
                        for (Field f : getStaticFieldsForGeneration(c.getClass_())) {
                            if (referenceFinder.referencePresent(f.getClass())) {
                                Context fieldContext;
                                fieldContext = _c.field(f);
                                generate(fieldContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case Enums:
                        for (Class ec : getEnumsForGeneration(c.getClass_())) {
                            if (referenceFinder.referencePresent(ec)) {
                                Context enumContext;
                                enumContext = _c.enum_(ec);
                                generate(enumContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case EnumValues:
                        for (String v : getEnumValuesForGeneration(c.getEnum())) {
                            Context enumValueContext;
                            enumValueContext = _c.enumValue(v);
                            generate(enumValueContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case Interfaces:
                        for (Class i_ : getInterfacesForGeneration(c.getClass_())) {
                            if (referenceFinder.referencePresent(i_)) {
                                Context iContext;
                                iContext = _c.interface_(i_);
                                generate(iContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case InheritedClasses:
                        Set<Class> inheritedClasses;
                        Set<Class> ic2;
                        inheritedClasses = JNIUtil.getAllInheritedClasses(c.getClass_());
                        ic2 = new HashSet<>();
                        for (Class inheritedClass : inheritedClasses) {
                            if (isBaseClass(inheritedClass) || referenceFinder.referencePresent(inheritedClass)) {
                                ic2.add(inheritedClass);
                            }
                        }
                        _c = c.loopElements(ic2.size());
                        for (Class inheritedClass : ic2) {
                            Context icContext;
                            icContext = _c.inheritedClass(inheritedClass);
                            generate(icContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case ReferencedClasses:
                        Set<Class> _referencedClasses;
                        Set<Class> referencedClasses;
                        Set<Class> _inheritedClasses;
                        Set<Class> rc2;
                        _inheritedClasses = JNIUtil.getAllInheritedClasses(c.getClass_());
                        // System.out.printf("\ngetReferencedClasses\t%s\n", c.getClass_().getName());
                        _referencedClasses = JNIUtil.getReferencedClasses(c.getClass_());
                        referencedClasses = new HashSet<>();
                        referencedClasses.addAll(_referencedClasses);
                        referencedClasses.addAll(_inheritedClasses);
                        // System.out.printf("\n%s\t%s\n\n", c.getClass_().getName(), CollectionUtil.toString(referencedClasses));
                        rc2 = new HashSet<>();
                        for (Class referencedClass : referencedClasses) {
                            if (referenceFinder.referencePresent(referencedClass)) {
                                rc2.add(referencedClass);
                            } else {
                            // System.out.printf("ReferencedClasses ignoring %s\n", referencedClass.getName());
                            }
                        }
                        _c = c.loopElements(rc2.size());
                        for (Class referencedClass : rc2) {
                            Context rcContext;
                            // System.out.printf("ReferencedClasses adding %s\n", referencedClass.getName());
                            rcContext = _c.referencedClass(referencedClass);
                            generate(rcContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    default:
                        throw new RuntimeException("Panic");
                }
                i += loopElements.size() + 2;
            }
        } else if (e instanceof IfElement) {
            Quadruple<IfElement, List<ParseElement>, List<ParseElement>, Integer> ifStatement;
            ifStatement = getIfElements(elements, i);
            generate(c, IfElement.evaluate(c, ifStatement.getTripleAt1()), outputDir, loopIndex, depth + 1);
            i = ifStatement.getV4();
        } else if (e instanceof SwitchElement) {
            Triple<SwitchElement, List<Pair<CaseElement, List<ParseElement>>>, Integer> switchStatement;
            switchStatement = getSwitchElements(elements, i);
            generate(c, SwitchElement.evaluate(c, switchStatement.getPairAt1()), outputDir, loopIndex, depth + 1);
            i = switchStatement.getV3();
        } else {
            throw new RuntimeException("Unhandled element " + e);
        }
    }
}