Java Objects.equal方法代码示例

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
public void updateVersions(List<DependencyVersionChange> changes, Map<String, String> propertyChanges) {
    for (DependencyVersionChange change : changes) {
        String scope = change.getScope();
        boolean lazyAdd = shouldLazyAdd(change);
        if (Objects.equal(MavenScopes.PLUGIN, scope)) {
            if (PomHelper.updatePluginVersion(doc, change, propertyChanges, lazyAdd)) {
                updated = true;
            }
        } else {
            if (PomHelper.updateDependencyVersion(doc, change, propertyChanges)) {
                updated = true;
            }
            // TODO check for BOM / Parent change too!
        }
    }
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
public static MavenPlugin findPlugin(Project project, String groupId, String artifactId) {
    if (project != null) {
        MavenPluginFacet pluginFacet = project.getFacet(MavenPluginFacet.class);
        if (pluginFacet != null) {
            List<MavenPlugin> plugins = pluginFacet.listConfiguredPlugins();
            if (plugins != null) {
                for (MavenPlugin plugin : plugins) {
                    Coordinate coordinate = plugin.getCoordinate();
                    if (coordinate != null) {
                        if (Objects.equal(groupId, coordinate.getGroupId()) &&
                                Objects.equal(artifactId, coordinate.getArtifactId())) {
                            return plugin;
                        }
                    }
                }
            }
        }
    }
    return null;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
protected static Node findCamelNodeForPath(Node node, String path) {
    NodeList childNodes = node.getChildNodes();
    if (childNodes != null) {
        Map<String, Integer> nodeCounts = new HashMap<>();
        for (int i = 0, size = childNodes.getLength(); i < size; i++) {
            Node child = childNodes.item(i);
            if (child instanceof Element) {
                String actual = getIdOrIndex(child, nodeCounts);
                if (Objects.equal(actual, path)) {
                    return child;
                }
            }
        }
    }
    return null;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
public static void substituteEnvironmentVariableExpressions(Map<String, String> map, Map<String, String> environmentVariables) {
    Set<Map.Entry<String, String>> envEntries = environmentVariables.entrySet();
    for (String key : map.keySet()) {
        String text = map.get(key);
        String oldText = text;
        if (Strings.isNotBlank(text)) {
            for (Map.Entry<String, String> envEntry : envEntries) {
                String envKey = envEntry.getKey();
                String envValue = envEntry.getValue();
                if (Strings.isNotBlank(envKey) && Strings.isNotBlank(envValue)) {
                    text = text.replace("${env:" + envKey + "}", envValue);
                }
            }
            if (!Objects.equal(oldText, text)) {
                map.put(key, text);
            }
        }
    }
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
/**
 * Returns true if this namespace is a user namespace
 */
public boolean userNamespace() {
    if (Strings.isNotBlank(name)) {
        return Objects.equal("user", type);
    }
    return false;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
protected static List<String> namespacesForType(List<NamespaceDTO> namespaces, String type) {
    List<String> answer = new ArrayList<>();
    if (namespaces != null) {
        for (NamespaceDTO namespace : namespaces) {
            String name = namespace.getName();
            if (Strings.isNotBlank(name)) {
                if (Objects.equal(type, namespace.getType())) {
                    answer.add(namespace.getName());
                }
            }
        }
    }
    Collections.sort(answer);
    return answer;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
private String updateBotCommentCommand(CommandContext context, GHIssueComment comment) throws IOException {
    GHUser user = comment.getUser();
    if (user != null) {
        if (Objects.equal(context.getConfiguration().getGithubUsername(), user.getLogin())) {
            String body = comment.getBody();
            if (body != null) {
                body = body.trim();
                if (body.startsWith(PullRequests.COMMAND_COMMENT_PREFIX)) {
                    return body;
                }
            }
        }
    }
    return null;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
public static boolean hasLabel(Collection<GHLabel> labels, String label) {
    if (labels != null) {
        for (GHLabel ghLabel : labels) {
            if (Objects.equal(label, ghLabel.getName())) {
                return true;
            }
        }
    }
    return false;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
public static String updateBotIssuePendingChangesComment(CommandContext context, GHIssueComment comment) throws IOException {
    GHUser user = comment.getUser();
    if (user != null) {
        if (Objects.equal(context.getConfiguration().getGithubUsername(), user.getLogin())) {
            String body = comment.getBody();
            if (body != null) {
                body = body.trim();
                if (body.startsWith(PENDING_CHANGE_COMMENT_PREFIX)) {
                    return body;
                }
            }
        }
    }
    return null;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
/**
 * Returns the repository for the given name or null if it could not be found
 */
public static LocalRepository findRepository(List<LocalRepository> localRepositories, String name) {
    if (localRepositories != null) {
        for (LocalRepository repository : localRepositories) {
            GitRepository repo = repository.getRepo();
            if (repo != null) {
                if (Objects.equal(name, repo.getName())) {
                    return repository;
                }
            }
        }
    }
    return null;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
public GitRepositoryConfig getRepositoryDetails(String cloneUrl) {
    GitRepositoryConfig answer = github.getRepositoryDetails(cloneUrl);
    if (answer == null) {
        for (GitRepository gitRepository : git) {
            if (Objects.equal(cloneUrl, gitRepository.getCloneUrl())) {
                answer = gitRepository.getRepositoryDetails();
                if (answer != null) {
                    return answer;
                }
            }
        }
    }
    return answer;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
protected static void assertChangesValid(File file, Document doc, List<DependencyVersionChange> changes) {
    for (DependencyVersionChange change : changes) {
        if (Objects.equal(MavenScopes.PLUGIN, change.getScope())) {
            assertPluginVersionChanged(file, doc, change);
        } else {
            assertDependencyVersionChanged(file, doc, change);
        }
    }
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
public GithubOrganisation findOrganisation(String name) {
    if (organisations != null) {
        for (GithubOrganisation organisation : organisations) {
            if (Objects.equal(name, organisation.getName())) {
                return organisation;
            }
        }
    }
    return null;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
/**
 * Returns true if the actual value matches any of the String representations of the given values.
 * <p>
 * So can match against String or URL objects etc
 */
public static boolean equalAnyValue(String actual, Object... values) {
    for (Object value : values) {
        if (value != null) {
            String text = value.toString();
            if (Objects.equal(text, actual)) {
                return true;
            }
        }
    }
    return false;
}
 

import io.fabric8.utils.Objects; //导入方法依赖的package包/类
public static List<Element> findElementsWithName(Element rootElement, String elementName) {
    List<Element> answer = new ArrayList<>();
    List<Element> children = rootElement.getChildren();
    for (Element child : children) {
        if (Objects.equal(elementName, child.getName())) {
            answer.add(child);
        } else {
            answer.addAll(findElementsWithName(child, elementName));
        }
    }
    return answer;
}