Examples with Choice org.ehrbase.client.annotations.Choice used on opensource projects

Example 1 with Choice

use of org.ehrbase.client.annotations.Choice in project openEHR_SDK by ehrbase.

the class ClassGenerator method build.

private TypeSpec.Builder build(ClassGeneratorContext context, WebTemplateNode next) {
    String className = defaultNamingStrategy.buildClassName(context, next, false, false);
    context.currentFieldNameMap.push(new HashMap<>());
    context.nodeDeque.push(next);
    context.unFilteredNodeDeque.push(next);
    TypeSpec.Builder classBuilder = TypeSpec.classBuilder(className);
    if (StringUtils.isBlank(context.currentMainClass)) {
        context.currentMainClass = className;
    }
    classBuilder.addModifiers(Modifier.PUBLIC);
    classBuilder.addAnnotation(AnnotationSpec.builder(Entity.class).build());
    if (next.isArchetype()) {
        AnnotationSpec archetypeAnnotation = AnnotationSpec.builder(Archetype.class).addMember(Archetype.VALUE, "$S", next.getNodeId()).build();
        classBuilder.addAnnotation(archetypeAnnotation);
    }
    AnnotationSpec generatedAnnotation = buildGeneratedAnnotation();
    classBuilder.addAnnotation(generatedAnnotation);
    classBuilder.addSuperinterface(findRMInterface(next));
    if (next.getChildren().stream().anyMatch(n -> n.getRmType().equals("EVENT"))) {
        WebTemplateNode event = next.getChildren().stream().filter(n -> n.getRmType().equals("EVENT")).findAny().orElseThrow();
        Walker.EventHelper eventHelper = new Walker.EventHelper(event).invoke();
        WebTemplateNode pointEvent = eventHelper.getPointEvent();
        WebTemplateNode intervalEvent = eventHelper.getIntervalEvent();
        next.getChildren().add(intervalEvent);
        next.getChildren().add(pointEvent);
        next.getChildren().remove(event);
    }
    Map<String, List<WebTemplateNode>> choices = next.getChoicesInChildren();
    List<WebTemplateNode> children = next.getChildren().stream().filter(c -> choices.values().stream().flatMap(List::stream).noneMatch(l -> l.equals(c))).collect(Collectors.toList());
    for (WebTemplateNode child : children) {
        Deque<WebTemplateNode> filtersNodes = pushToUnfiltered(context, child);
        String relativPath = context.nodeDeque.peek().buildRelativePath(child);
        if (child.getChildren().isEmpty() && !choices.containsKey(child.getAqlPath())) {
            addSimpleField(context, classBuilder, relativPath, child);
        } else if (!choices.containsKey(child.getAqlPath())) {
            addComplexField(context, classBuilder, relativPath, child);
        }
        if (!CollectionUtils.isEmpty(filtersNodes)) {
            filtersNodes.forEach(n -> context.unFilteredNodeDeque.poll());
        }
    }
    for (List<WebTemplateNode> choice : choices.values()) {
        WebTemplateNode node = choice.get(0);
        WebTemplateNode relativeNode = buildRelativeNode(context, node);
        Deque<WebTemplateNode> filtersNodes = pushToUnfiltered(context, node);
        TypeSpec interfaceSpec;
        TypeName interfaceClassName;
        if (context.currentTypeSpec.containsKey(relativeNode)) {
            interfaceSpec = context.currentTypeSpec.get(relativeNode);
            String interfacePackage = context.currentPackageName + "." + context.currentMainClass.toLowerCase() + DEFINITION_PACKAGE;
            context.classes.put(interfacePackage, interfaceSpec);
            interfaceClassName = ClassName.get(interfacePackage, interfaceSpec.name);
        } else {
            List<Pair<TypeSpec.Builder, WebTemplateNode>> builders = new ArrayList<>();
            for (WebTemplateNode child : choice) {
                TypeSpec.Builder build = build(context, child);
                builders.add(new ImmutablePair<>(build, child));
            }
            TypeSpec.Builder interfaceBuilder = TypeSpec.interfaceBuilder(defaultNamingStrategy.buildClassName(context, choice.get(0), true, false)).addModifiers(Modifier.PUBLIC);
            interfaceBuilder.addAnnotation(buildGeneratedAnnotation());
            Set<FieldSpec> cowmenField = null;
            for (Set<FieldSpec> fields : builders.stream().map(Pair::getLeft).map(s -> s.fieldSpecs).map(HashSet::new).collect(Collectors.toList())) {
                if (cowmenField == null) {
                    cowmenField = fields;
                } else {
                    cowmenField = SetUtils.intersection(cowmenField, fields);
                }
            }
            if (cowmenField == null) {
                cowmenField = Collections.emptySet();
            }
            cowmenField.forEach(f -> {
                interfaceBuilder.addMethod(buildGetter(f, true));
                interfaceBuilder.addMethod(buildSetter(f, true));
            });
            interfaceSpec = interfaceBuilder.build();
            context.currentTypeSpec.put(relativeNode, interfaceSpec);
            String interfacePackage = context.currentPackageName + "." + context.currentMainClass.toLowerCase() + DEFINITION_PACKAGE;
            context.classes.put(interfacePackage, interfaceSpec);
            interfaceClassName = ClassName.get(interfacePackage, interfaceSpec.name);
            TypeName finalInterfaceClassName = interfaceClassName;
            builders.forEach(pair -> {
                TypeSpec.Builder builder = pair.getKey().addSuperinterface(finalInterfaceClassName).addAnnotation(AnnotationSpec.builder(OptionFor.class).addMember(OptionFor.VALUE, "$S", pair.getRight().getRmType()).build());
                context.classes.put(interfacePackage, builder.build());
            });
        }
        if (choice.stream().anyMatch(WebTemplateNode::isMulti)) {
            interfaceClassName = ParameterizedTypeName.get(ClassName.get(List.class), interfaceClassName);
        }
        String relativPath = FlatPath.removeStart(new FlatPath(node.getAqlPath()), new FlatPath(next.getAqlPath())).toString();
        addField(context, classBuilder, relativPath, node, interfaceClassName, new ValueSet(ValueSet.LOCAL, ValueSet.LOCAL, Collections.emptySet()), true);
        if (!CollectionUtils.isEmpty(filtersNodes)) {
            filtersNodes.forEach(n -> context.unFilteredNodeDeque.poll());
        }
    }
    if (next.isArchetype()) {
        context.currentArchetypeName.poll();
    }
    if (children.isEmpty() && choices.isEmpty()) {
        addSimpleField(context, classBuilder, "", next);
    }
    context.currentFieldNameMap.poll();
    context.nodeDeque.poll();
    context.unFilteredNodeDeque.poll();
    return classBuilder;
}