Java VisibilityKind.PUBLIC_LITERAL属性代码示例

/**
 * 
 * 
 * @return VisibilityKind
 */
private VisibilityKind getSelectedVisibilityKind() {
    if (this.publicButton.getSelection()) {
        return VisibilityKind.PUBLIC_LITERAL;
    } else if (this.privateButton.getSelection()) {
        return VisibilityKind.PRIVATE_LITERAL;
    } else if (this.protectedButton.getSelection()) {
        return VisibilityKind.PROTECTED_LITERAL;
    } else if (this.packageButton.getSelection()) {
        return VisibilityKind.PACKAGE_LITERAL;
    }
    return null;
}
 

public static VisibilityKind getVisibilityOfNamedElementFromModifiers(NamedElement element, int modifiers) {
	if (Modifier.isPrivate(modifiers)) {
		return VisibilityKind.PRIVATE_LITERAL;
	} else if (Modifier.isProtected(modifiers)) {
		return VisibilityKind.PROTECTED_LITERAL;
	} else if (Modifier.isPublic(modifiers)) {
		return VisibilityKind.PUBLIC_LITERAL;
	} else {
		return getVisibilityOfElementWithoutVisibilityModifier(element);
	}
}
 

private static VisibilityKind getVisibilityOfElementWithoutVisibilityModifier(NamedElement element) {
	if (element instanceof Property) {
		return VisibilityKind.PRIVATE_LITERAL;
	} else if (element instanceof Operation || element instanceof org.eclipse.uml2.uml.Classifier) {
		return VisibilityKind.PUBLIC_LITERAL;
	} else {
		return VisibilityKind.PACKAGE_LITERAL;
	}
}
 

public static boolean shouldSkip(IRenderingSession context, NamedElement element) {
	switch (context.getSettings()
               .getSelection(ShowMinimumVisibilityOptions.class)) {
       case Private:
       	break;
       case Protected:
       	if (element.getVisibility() == VisibilityKind.PRIVATE_LITERAL)
       		return true;
       default:
       	if (element.getVisibility() != VisibilityKind.PUBLIC_LITERAL)
       		return true;
       }
	
	return false;
}
 

protected static List<Package> getAllImportedPackages(Package package_, List<Package> allImportedPackages) {
    for (PackageImport packageImport : package_.getPackageImports())
        if (packageImport.getVisibility() == VisibilityKind.PUBLIC_LITERAL) {
            Package importedPackage = packageImport.getImportedPackage();
            if (importedPackage != null && !allImportedPackages.contains(importedPackage)) {
            	allImportedPackages.add(importedPackage);
                getAllImportedPackages(importedPackage, allImportedPackages);
            }
        }
    return allImportedPackages;
}
 

private <T extends NamedElement> boolean isVisible(Namespace current, T element, boolean fullyQualified) {
    // TODO support protected and package visibility
    if (PACKAGE.getPackage().isInstance(element))
        return true;
    Package elementPackage = element.getNearestPackage();
    if (elementPackage == current.getNearestPackage())
        return true;
    if (fullyQualified)
        return element.getVisibility() == VisibilityKind.PUBLIC_LITERAL;
    List<Package> importedPackages = current.getImportedPackages();
    if (importedPackages.contains(elementPackage))
        return true;
    return current instanceof Package && ((Package) current).visibleMembers().contains(element);
}
 

public static boolean isTestCase(Operation op) {
	if (op.getVisibility() != VisibilityKind.PUBLIC_LITERAL)
		return false;
	if (!op.getOwnedParameters().isEmpty())
		return false;
	if (op.isStatic())
		return false;
    return op.getClass_() != null && isTestClass(op.getClass_());
}
 

@Override
public void caseAImportDecl(final AImportDecl node) {
    final Package currentPackageSnapshot = namespaceTracker.currentPackage();
    modifierProcessor.collectModifierToken(node.getOptionalImportModifier());
    final Set<Modifier> tmpModifiers = modifierProcessor.getModifiers(true);
    final VisibilityKind importVisibility = tmpModifiers.isEmpty() ? VisibilityKind.PUBLIC_LITERAL : getVisibility(
            tmpModifiers.iterator().next(), VisibilityKind.PUBLIC_LITERAL);
    String qualifiedIdentifier = TextUMLCore.getSourceMiner().getQualifiedIdentifier(node.getQualifiedIdentifier());
    final String alias;
    if (node.getOptionalAlias() instanceof AOptionalAlias) {
        AOptionalAlias optionalAlias = (AOptionalAlias) node.getOptionalAlias();
        alias = Util.stripEscaping(optionalAlias.getIdentifier().getText());
    } else
        alias = null;
    getRefTracker().add(
            new DeferredReference<NamedElement>(qualifiedIdentifier, IRepository.PACKAGE.getNamedElement(),
                    namespaceTracker.currentPackage()) {
                @Override
                protected void onBind(NamedElement element) {
                    if (element == null) {
                        problemBuilder.addProblem(new UnresolvedSymbol(getSymbolName()),
                                node.getQualifiedIdentifier());
                        return;
                    }
                    if (element instanceof Package) {
                        if (alias != null) {
                            problemBuilder.addError("Imported packages cannot be aliased",
                                    node.getQualifiedIdentifier());
                            return;
                        }
                        Package importedPackage = (Package) element;
                        if (currentPackageSnapshot.getImportedPackages().contains(importedPackage))
                            // just ignore
                            return;
                        PackageImport created = currentPackageSnapshot.createPackageImport(importedPackage);
                        created.setVisibility(importVisibility);
                    } else {
                        PackageableElement packageableElement = (PackageableElement) element;
                        ElementImport elementImport = currentPackageSnapshot.createElementImport(packageableElement);
                        elementImport.setVisibility(importVisibility);
                        if (alias != null)
                            elementImport.setAlias(alias);
                    }
                }
            }, IReferenceTracker.Step.PACKAGE_IMPORTS);
}