String typeName) throws UnableToCompleteException { if (GeneratorChain.customGenerators == null || GeneratorChain.context != context) { fillUpGeneratorChainMap(logger, context); GeneratorChain.context = context; if (replacer.isGenerate(logger, context, typeName, replacer .getConditions())) { actualTypeName = replacer.doGenerate(logger, context, actualTypeName); AbstractGenerator aGen = (AbstractGenerator) entry.getValue(); if (superClass != null && !("".equals(superClass))) { aGen.setSuperclassName(superClass); } else { aGen.setSuperclassName(actualTypeName); if (aGen.isGenerate(logger, context, actualTypeName, aGen.getConditions())) { superClass = gen.generate(logger, context, actualTypeName); superClass = generateByCustomGenerators(logger, context, typeName, superClass, actualTypeName, generators);
private String generateByCustomGenerators(TreeLogger logger, GeneratorContext context, String typeName, String superClass, String actualTypeName, List<AbstractGenerator> awaitingGeneratos) throws UnableToCompleteException { // AbstractGenerator processedGenerator = null; for (AbstractGenerator generator : awaitingGeneratos) { if (superClass != null && !("".equals(superClass))) { generator.setSuperclassName(superClass); } else { generator.setSuperclassName(actualTypeName); } if (generator.isGenerate(logger, context, actualTypeName, generator .getConditions())) { superClass = generator.doGenerate(logger, context, actualTypeName); // processedGenerator = generator; // break; } } // if (processedGenerator != null) { // awaitingGeneratos.remove(processedGenerator); // superClass = generateByCustomGenerators(logger, context, typeName, superClass, actualTypeName, awaitingGeneratos); // } return superClass; }
GeneratorChain.replacers = new LinkedList<AbstractGenerator>(); GeneratorChain.thirdPartyGenerators = new LinkedHashMap<Generator, AbstractGenerator>(); ModuleDef moduleDef = ((CompilerContext) getPrivateField(context, "compilerContext")).getModule(); Rules rules = moduleDef.getRules(); String replaceClass = (String) getPrivateField(rul, "replacementTypeName"); gen = new ReplaceByGenerator(replaceClass); Class<? extends Generator> generatorClass = (Class<? extends Generator>)getPrivateField(rul, "generatorClass"); Constructor<?> constructor; try { AbstractGenerator myGen = (AbstractGenerator) gen; if (GeneratorChain.customGenerators.contains(gen) || GeneratorChain.replacers.contains(gen)) { newGroup = addPredicsToExisting(rul, myGen.getConditions()); myGen.setConditions(newGroup); } else { newGroup = getGroupConditions(rul.getRootCondition().getConditions(), null); myGen.setConditions(newGroup); if(gen instanceof ReplaceByGenerator){ GeneratorChain.replacers.addFirst(myGen); if(GeneratorChain.thirdPartyGenerators.containsKey(gen)){ AbstractGenerator myGen = GeneratorChain.thirdPartyGenerators.get(gen); GenPredicGroup newGroup = addPredicsToExisting(rul, myGen.getConditions()); myGen.setConditions(newGroup); GeneratorChain.thirdPartyGenerators.put(gen, myGen);
getGroupConditions(((CompoundCondition) cond) .getConditions(), actualOp)); } else { .setGeneratorPredicts(new ArrayList<GeneratorPredicate>()); myConds.getGeneratorPredicts().add(getGP(cond));
private GenPredicGroup addPredicsToExisting(Rule rul, GenPredicGroup previousConds) { List<GenPredicGroup> list = new ArrayList<GenPredicGroup>(); GenPredicGroup gpg = getGroupConditions(rul .getRootCondition().getConditions(), null); list.add(gpg); list.add(previousConds); GenPredicGroup newGroup = new GenPredicGroup(); newGroup.setMyGroups(list); newGroup.setOperator(EOperator.ANY); return newGroup; }
/** * gets GeneratorPredicate from condition * * @param cond * Condition * @return GeneratorPredicate */ private GeneratorPredicate getGP(Condition cond) { GeneratorPredicate gp = new GeneratorPredicate(); // ===================when assignable to if (cond instanceof ConditionWhenTypeAssignableTo) { gp.setEPredict(EPredicts.ASSIGNABLE); gp.setName(GeneratorPredicate.CLASS); gp.setValue(((ConditionWhenTypeAssignableTo) cond) .getAssignableToTypeName()); // ===================when type is } else if (cond instanceof ConditionWhenTypeIs) { gp.setEPredict(EPredicts.TYPEIS); gp.setName(GeneratorPredicate.CLASS); gp.setValue((String) getPrivateField(cond, "exactTypeName")); // ===================when property is } else if (cond instanceof ConditionWhenPropertyIs) { gp.setEPredict(EPredicts.PROPERTY); gp.setName((String) getPrivateField( ((ConditionWhenPropertyIs) cond), "propName")); gp.setValue((String) getPrivateField( ((ConditionWhenPropertyIs) cond), "value")); } return gp; }
case ANY: result = result || isGenerate(logger, context, typeName, group); break; case NONE: result = !isGenerate(logger, context, typeName, group); if (!result) return false; break; case ALL: result = isGenerate(logger, context, typeName, group); if (!result) return false;