lombok.experimental.Tolerate Java Examples

/**
 * Checks if there is a (non-default) constructor. In case of multiple constructors (overloading), only
 * the first constructor decides if EXISTS_BY_USER or EXISTS_BY_LOMBOK is returned.
 * 
 * @param node Any node that represents the Type (JCClassDecl) to look in, or any child node thereof.
 */
public static MemberExistsResult constructorExists(JavacNode node) {
	node = upToTypeNode(node);
	
	if (node != null && node.get() instanceof JCClassDecl) {
		top: for (JCTree def : ((JCClassDecl)node.get()).defs) {
			if (def instanceof JCMethodDecl) {
				JCMethodDecl md = (JCMethodDecl) def;
				if (md.name.contentEquals("<init>")) {
					if ((md.mods.flags & Flags.GENERATEDCONSTR) != 0) continue;
					List<JCAnnotation> annotations = md.getModifiers().getAnnotations();
					if (annotations != null) for (JCAnnotation anno : annotations) {
						if (typeMatches(Tolerate.class, node, anno.getAnnotationType())) continue top;
					}
					return getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
				}
			}
		}
	}
	
	return MemberExistsResult.NOT_EXISTS;
}
 

/**
 * Checks if there is a (non-default) constructor. In case of multiple constructors (overloading), only
 * the first constructor decides if EXISTS_BY_USER or EXISTS_BY_LOMBOK is returned.
 * 
 * @param node Any node that represents the Type (TypeDeclaration) to look in, or any child node thereof.
 */
public static MemberExistsResult constructorExists(EclipseNode node) {
	while (node != null && !(node.get() instanceof TypeDeclaration)) {
		node = node.up();
	}
	
	if (node != null && node.get() instanceof TypeDeclaration) {
		TypeDeclaration typeDecl = (TypeDeclaration)node.get();
		if (typeDecl.methods != null) top: for (AbstractMethodDeclaration def : typeDecl.methods) {
			if (def instanceof ConstructorDeclaration) {
				if ((def.bits & ASTNode.IsDefaultConstructor) != 0) continue;
				
				if (def.annotations != null) for (Annotation anno : def.annotations) {
					if (typeMatches(Tolerate.class, node, anno.type)) continue top;
				}
				
				return getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
			}
		}
	}
	
	return MemberExistsResult.NOT_EXISTS;
}
 

protected Collection<? extends PsiElement> generatePsiElements(@NotNull PsiClass psiParentClass, @Nullable PsiMethod psiParentMethod, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiBuilderClass) {
  final Collection<PsiMethod> result = new ArrayList<>();

  final Collection<String> existedMethodNames = PsiClassUtil.collectClassMethodsIntern(psiBuilderClass).stream()
    .filter(psiMethod -> PsiAnnotationSearchUtil.isNotAnnotatedWith(psiMethod, Tolerate.class))
    .map(PsiMethod::getName).collect(Collectors.toSet());

  BuilderHandler builderHandler = getBuilderHandler();
  final List<BuilderInfo> builderInfos = builderHandler.createBuilderInfos(psiAnnotation, psiParentClass, psiParentMethod, psiBuilderClass);

  //create constructor
  result.addAll(builderHandler.createConstructors(psiBuilderClass, psiAnnotation));

  // create builder methods
  builderInfos.stream()
    .filter(info -> info.notAlreadyExistingMethod(existedMethodNames))
    .map(BuilderInfo::renderBuilderMethods)
    .forEach(result::addAll);

  // create 'build' method
  final String buildMethodName = builderHandler.getBuildMethodName(psiAnnotation);
  if (!existedMethodNames.contains(buildMethodName)) {
    result.add(builderHandler.createBuildMethod(psiAnnotation, psiParentClass, psiParentMethod, psiBuilderClass, buildMethodName, builderInfos));
  }

  // create 'toString' method
  if (!existedMethodNames.contains(ToStringProcessor.METHOD_NAME)) {
    result.add(builderHandler.createToStringMethod(psiAnnotation, psiBuilderClass));
  }

  return result;
}
 

@Tolerate
public Location() {
}
 

@Tolerate
@Deprecated // use `isTls()` instead, left here for rails
public boolean getTls() {
    return isTls();
}
 

@Tolerate
@Deprecated // use `getUsername()` instead
public String getUserName() {
    return getUsername();
}
 

protected void filterToleratedElements(@NotNull Collection<? extends PsiModifierListOwner> definedMethods) {
  definedMethods.removeIf(definedMethod -> PsiAnnotationSearchUtil.isAnnotatedWith(definedMethod, Tolerate.class));
}
 

@Tolerate
public TolerateWithValue(int age) {
  this(age, "unknown");
}
 

@Tolerate
public TolerateWithData(int age) {
  this(age, "unknown");
}
 

@Tolerate
public BuilderWithTolerateBuilder value(String s) {
	return this.value(Integer.parseInt(s));
}
 

@Tolerate
public BuilderWithTolerateBuilder value(String s) {
	return this.value(Integer.parseInt(s));
}
 

@Tolerate
private Office() {}
 

@Tolerate
private Employee() {}
 

/**
 * Checks if there is a method with the provided name. In case of multiple methods (overloading), only
 * the first method decides if EXISTS_BY_USER or EXISTS_BY_LOMBOK is returned.
 * 
 * @param methodName the method name to check for.
 * @param node Any node that represents the Type (JCClassDecl) to look in, or any child node thereof.
 * @param caseSensitive If the search should be case sensitive.
 * @param params The number of parameters the method should have; varargs count as 0-*. Set to -1 to find any method with the appropriate name regardless of parameter count.
 */
public static MemberExistsResult methodExists(String methodName, JavacNode node, boolean caseSensitive, int params) {
	node = upToTypeNode(node);
	
	if (node != null && node.get() instanceof JCClassDecl) {
		top: for (JCTree def : ((JCClassDecl)node.get()).defs) {
			if (def instanceof JCMethodDecl) {
				JCMethodDecl md = (JCMethodDecl) def;
				String name = md.name.toString();
				boolean matches = caseSensitive ? name.equals(methodName) : name.equalsIgnoreCase(methodName);
				if (matches) {
					if (params > -1) {
						List<JCVariableDecl> ps = md.params;
						int minArgs = 0;
						int maxArgs = 0;
						if (ps != null && ps.length() > 0) {
							minArgs = ps.length();
							if ((ps.last().mods.flags & Flags.VARARGS) != 0) {
								maxArgs = Integer.MAX_VALUE;
								minArgs--;
							} else {
								maxArgs = minArgs;
							}
						}
						
						if (params < minArgs || params > maxArgs) continue;
					}
					
					List<JCAnnotation> annotations = md.getModifiers().getAnnotations();
					if (annotations != null) for (JCAnnotation anno : annotations) {
						if (typeMatches(Tolerate.class, node, anno.getAnnotationType())) continue top;
					}
					
					return getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
				}
			}
		}
	}
	
	return MemberExistsResult.NOT_EXISTS;
}
 

/**
 * Checks if there is a method with the provided name. In case of multiple methods (overloading), only
 * the first method decides if EXISTS_BY_USER or EXISTS_BY_LOMBOK is returned.
 * 
 * @param methodName the method name to check for.
 * @param node Any node that represents the Type (TypeDeclaration) to look in, or any child node thereof.
 * @param caseSensitive If the search should be case sensitive.
 * @param params The number of parameters the method should have; varargs count as 0-*. Set to -1 to find any method with the appropriate name regardless of parameter count.
 */
public static MemberExistsResult methodExists(String methodName, EclipseNode node, boolean caseSensitive, int params) {
	while (node != null && !(node.get() instanceof TypeDeclaration)) {
		node = node.up();
	}
	
	if (node != null && node.get() instanceof TypeDeclaration) {
		TypeDeclaration typeDecl = (TypeDeclaration)node.get();
		if (typeDecl.methods != null) top: for (AbstractMethodDeclaration def : typeDecl.methods) {
			if (def instanceof MethodDeclaration) {
				char[] mName = def.selector;
				if (mName == null) continue;
				boolean nameEquals = caseSensitive ? methodName.equals(new String(mName)) : methodName.equalsIgnoreCase(new String(mName));
				if (nameEquals) {
					if (params > -1) {
						int minArgs = 0;
						int maxArgs = 0;
						if (def.arguments != null && def.arguments.length > 0) {
							minArgs = def.arguments.length;
							if ((def.arguments[def.arguments.length - 1].type.bits & ASTNode.IsVarArgs) != 0) {
								minArgs--;
								maxArgs = Integer.MAX_VALUE;
							} else {
								maxArgs = minArgs;
							}
						}
						
						if (params < minArgs || params > maxArgs) continue;
					}
					
					if (def.annotations != null) for (Annotation anno : def.annotations) {
						if (typeMatches(Tolerate.class, node, anno.type)) continue top;
					}
					
					return getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
				}
			}
		}
	}
	
	return MemberExistsResult.NOT_EXISTS;
}
 

@Tolerate
public Token() {
}
 

@Tolerate
public ResultData(){}
 

@Tolerate
public User() {
}
 

@Tolerate
public Device() {
}
 

@Tolerate
public OauthClientDetails() {
}
 

@Tolerate
public OAuth2Authentication authentication() {
    return SerializationUtils.deserialize(authentication);
}
 

@Tolerate
public OAuth2AccessToken token() {
    return SerializationUtils.deserialize(token);
}
 

@Tolerate
public AuthorizationCode() {
}
 

@Tolerate
public UserForm() {}
 

@Tolerate
public void setServer(String server) {
  setServer(Optional.ofNullable(server));
}
 

@Tolerate
public void setChannel(String channel) {
  setChannel(Optional.ofNullable(channel));
}
 

@Tolerate
public void setMessage(String message) {
  setMessage(Optional.ofNullable(message));
}
 

@Tolerate
public void setTarget(BungeeChatAccount target) {
  setTarget(Optional.ofNullable(target));
}
 

@Tolerate
public void setSender(BungeeChatAccount sender) {
  setSender(Optional.ofNullable(sender));
}
 

@Tolerate
public SubMenuVO(){}