Set<CombinedInterface> getSetProp() { return null; }

    Map<CombinedInterface, JavaClassWithParameterizedTypes> getMapProp() { return null; }

    List<?> getWildcardProp() { return null; }

    List<? extends CombinedInterface> getUpperBoundProp() { return null; }

    List<? super CombinedInterface> getLowerBoundProp() { return null; }

        MethodMetaData overriddenMethod = null;
        if (getter != null) {
            overriddenMethod = getter.getOverriddenMethod();
        }
        if (overriddenMethod == null && setter != null) {
            overriddenMethod = setter.getOverriddenMethod();
        }
        if (overriddenMethod != null) {
            return overriddenMethod.getOwnerClass().findDeclaredProperty(name);

        if (!typeDeclaration.isPublic()) {
            return;
        }
        ClassMetaData outerClass = classStack.isEmpty() ? null : getCurrentClass();
        String baseName = typeDeclaration.getNameAsString();
        String className = outerClass == null ? packageName + '.' + baseName : outerClass.getClassName() + '.' + baseName;
        String comment = getJavadocComment(typeDeclaration);

    public void pushText(String rawCommentText) {
        if (rawCommentText == null) {
            return;
        }

        StringBuilder builder = new StringBuilder();
        try {
            BufferedReader reader = new BufferedReader(new StringReader(rawCommentText));
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.replaceFirst("\\s*\\* ?", "");

            if (!isIncubating((JApiHasAnnotations) member) && !isInject((JApiHasAnnotations) member)) {
                return violationError(member);
            }
        }
        return null;
    }

    private Violation violationError(JApiCompatibility member) {
        return acceptOrReject(member, Violation.error(member, "Is not annotated with @Incubating"));
    }

    }

    @Override
    public Violation maybeViolation(final JApiCompatibility member) {

        if (shouldSkipViolationCheckFor(member) || getRepository().isSince(getCurrentVersion(), member)) {
            return null;
        }

        return acceptOrReject(member, Violation.error(member, SINCE_ERROR_MESSAGE + getCurrentVersion()));
    }

    private boolean shouldSkipViolationCheckFor(JApiCompatibility member) {

        DeploymentRegistry registry = getDeploymentRegistry();
        JavaApplicationHandle handle = registry.get(getPath(), JavaApplicationHandle.class);
        if (handle == null) {
            JavaExecHandleBuilder builder = getExecActionFactory().newJavaExec();
            builder.setExecutable(getJavaLauncher().get().getExecutablePath().getAsFile());

        List<Error> errorsForFile = new ArrayList<>();

        try (BufferedReader br = new BufferedReader(new FileReader(sourceFile))) {
            String line = br.readLine();
            while (line != null) {
                lineNumber++;
                gatherDeadLinksInLine(sourceFile, line, lineNumber, errorsForFile);
                gatherDeadJavadocLinksInLine(sourceFile, line, lineNumber, errorsForFile);

                if (overriddenProp != null) {
                    for (ExtraAttributeDoc attributeDoc : overriddenProp.getAdditionalValues()) {
                        additionalValues.put(attributeDoc.getKey(), attributeDoc);
                    }
                }
            }

            for (int i = 1; i < header.size(); i++) {
                if (cells.get(i).getFirstChild() == null) {
                    continue;

            String pluginId = mixin.getPluginId();
            ClassExtensionDoc classExtensionDoc = plugins.get(pluginId);
            if (classExtensionDoc == null) {
                classExtensionDoc = new ClassExtensionDoc(pluginId, classDoc);
                plugins.put(pluginId, classExtensionDoc);
            }