Example usage for com.google.common.base Predicates notNull

List of usage examples for com.google.common.base Predicates notNull

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.base.*
  5. Predicates
  6. notNull

Introduction

In this page you can find the example usage for com.google.common.base Predicates notNull.

Prototype

@GwtCompatible(serializable = true)
public static <T> Predicate<T> notNull()

Source Link

Document

Returns a predicate that evaluates to true if the object reference being tested is not null.

Usage

From source file:models.web.ModuleModel.java

public ModuleModel(Module module) {
    super(module);

    if (module != null) {
        this.id = UuidUtils.normalize(module.getId());
        this.baseName = module.getBaseDisplayName();
        this.name = module.getDisplayName();
        this.url = module.getRoute();
        this.canPartiallyRender = module.canPartiallyRender();
        this.allowSelfOutput = module.allowSelfOutput();
        this.relevancyScore = 1.0;

        if (module.getSubModules() != null) {
            this.subModules = Lists.transform(
                    Lists.newArrayList(Iterables.filter(module.getSubModules(), Predicates.notNull())),
                    new Function<Module, ModuleModel>() {
                        @Override
                        @Nullable//w ww  .j  a v  a 2  s.co  m
                        public ModuleModel apply(@Nullable Module input) {
                            return new ModuleModel(input);
                        }
                    });
        }
    }
}

From source file:de.metas.ui.web.window.model.lookup.LookupDataSource.java

default LookupValuesList findByIds(final Collection<? extends Object> ids) {
    if (ids.isEmpty()) {
        return LookupValuesList.EMPTY;
    }/*from   ww  w. ja v a2s.  c o  m*/

    return new HashSet<>(ids).stream().map(this::findById).filter(Predicates.notNull())
            .collect(LookupValuesList.collect());
}

From source file:com.analog.lyric.dimple.model.core.EdgeStateList.java

@Override
public Iterator<EdgeState> iterator() {
    // Skip over null entries
    return Iterators.filter(super.iterator(), Predicates.notNull());
}

From source file:com.isotrol.impe3.api.support.BasicPrincipal.java

public BasicPrincipal(final String username, final String displayName, final Iterable<String> roles,
        final Map<String, String> properties) {
    this.username = username;
    this.displayName = displayName;
    if (roles == null) {
        this.roles = ImmutableSet.of();
    } else {/* w ww . j  av a2 s  . co  m*/
        this.roles = ImmutableSet.copyOf(Iterables.filter(roles, Predicates.notNull()));
    }
    if (properties == null) {
        this.properties = ImmutableMap.of();
    } else {
        this.properties = ImmutableMap.copyOf(filterKeys(filterValues(properties, notNull()), notNull()));
    }
}

From source file:net.shibboleth.idp.session.logic.LogoutPropagationFlowDescriptorSelector.java

/**
 * Constructor./* w w w  .  j a va  2  s . co  m*/
 *
 * @param flows the logout propagation flows to select from
 */
public LogoutPropagationFlowDescriptorSelector(
        @Nonnull @NonnullElements final List<LogoutPropagationFlowDescriptor> flows) {
    Constraint.isNotNull(flows, "Flows cannot be null");

    availableFlows = new ArrayList<>(Collections2.filter(flows, Predicates.notNull()));
}

From source file:controllers.ModuleController.java

private static List<ModuleModel> getNextModules(String input) {
    // get all the supplied view models.
    List<ViewModel> suppliedViewModels = Lists.newArrayList();
    JsonNode inputJson = Json.parse(input);

    // convert json nodes to view models.
    if (inputJson != null && inputJson.isArray()) {
        suppliedViewModels = Lists// ww  w  . j a  va  2  s.  co  m
                .newArrayList(Iterators.transform(inputJson.getElements(), new Function<JsonNode, ViewModel>() {
                    @Override
                    @Nullable
                    public ViewModel apply(@Nullable JsonNode input) {
                        if (!input.isTextual()) {
                            return null;
                        }
                        return createViewModelQuietly(
                                fetchResource(UuidUtils.create(input.asText()), PersistentObject.class), null);

                    }
                }));
    } else if (inputJson != null && inputJson.isObject()) {
        suppliedViewModels.add(createViewModelQuietly(inputJson, null));
    }

    suppliedViewModels = Lists.newArrayList(Iterables.filter(suppliedViewModels, Predicates.notNull()));

    // get all the modules that can use these inputs.
    Map<Module, Double> nullModulesMap = Maps.newHashMap();
    Map<Module, Double> modulesMap = Maps.newHashMap();
    Reflections reflections = new Reflections("controllers.modules", Play.application().classloader());
    for (Class<? extends Module> moduleClass : reflections.getSubTypesOf(Module.class)) {
        // we're not interested in abstract classes.
        if (Modifier.isAbstract(moduleClass.getModifiers())) {
            continue;
        }

        // get the Module.Requires/Requireses annotation for each module class.
        // the requirements within each Module.Require are ANDed.
        // the requirements across multiple Module.Require annotations are ORed.
        List<Module.Requires> requireds = Lists.newArrayList();
        if (moduleClass.isAnnotationPresent(Module.Requires.class)) {
            requireds.add(moduleClass.getAnnotation(Module.Requires.class));
        }
        if (moduleClass.isAnnotationPresent(Module.Requireses.class)) {
            Collections.addAll(requireds, moduleClass.getAnnotation(Module.Requireses.class).value());
        }

        if (requireds.size() == 0) {
            requireds.add(null);
        }

        for (Module.Requires required : requireds) {
            final Set<Class<? extends ViewModel>> requiredViewModelClasses = Sets.newHashSet();
            if (required != null) {
                Collections.addAll(requiredViewModelClasses, required.value());
            }

            // get all the supplied view modules that are relevant to this module.
            List<ViewModel> usefulViewModels = Lists
                    .newArrayList(Iterables.filter(suppliedViewModels, new Predicate<ViewModel>() {
                        @Override
                        public boolean apply(@Nullable ViewModel input) {
                            // if this class is required, then return true.
                            if (requiredViewModelClasses.contains(input.getClass())) {
                                return true;
                            }

                            // if any of its super classes are required, that also works.
                            for (Class<?> superClass : ClassUtils.getAllSuperclasses(input.getClass())) {
                                if (requiredViewModelClasses.contains(superClass)) {
                                    return true;
                                }
                            }

                            return false;
                        }
                    }));

            // if all the requirements were satisfied.
            if (usefulViewModels.size() >= requiredViewModelClasses.size()) {
                // try to create an instance of the module.
                Module module = null;
                try {
                    module = moduleClass.newInstance();
                    module.setViewModels(usefulViewModels);
                } catch (InstantiationException | IllegalAccessException | IllegalArgumentException e) {
                    module = null;
                } finally {
                    // if no module was created, just ignore.
                    if (module == null) {
                        continue;
                    }
                }

                // let's not divide by zero!
                double relevancyScore = suppliedViewModels.size() != 0
                        ? usefulViewModels.size() / (double) suppliedViewModels.size()
                        : 1.0;

                // keep null modules separate.
                Map<Module, Double> targetModulesMap = null;
                if (requiredViewModelClasses.size() > 0) {
                    // if a module of this type does not exist, add it.
                    if (Maps.filterKeys(modulesMap, Predicates.instanceOf(moduleClass)).size() == 0) {
                        targetModulesMap = modulesMap;
                    }
                } else {
                    targetModulesMap = nullModulesMap;
                }
                if (targetModulesMap != null) {
                    targetModulesMap.put(module, relevancyScore);
                }
            }
        }
    }

    // use null modules only if there are no regular ones.
    if (modulesMap.size() == 0) {
        modulesMap = nullModulesMap;
    }

    // convert to view models.
    Set<ModuleModel> moduleViewModels = Sets.newHashSet(
            Iterables.transform(modulesMap.entrySet(), new Function<Entry<Module, Double>, ModuleModel>() {
                @Override
                @Nullable
                public ModuleModel apply(@Nullable Entry<Module, Double> input) {
                    return new ModuleModel(input.getKey()).setRelevancyScore(input.getValue());
                }
            }));

    // order first by relevance and then by name.
    return Ordering.from(new Comparator<ModuleModel>() {
        @Override
        public int compare(ModuleModel o1, ModuleModel o2) {
            int relDiff = (int) Math.round((o2.relevancyScore - o1.relevancyScore) * 1000);
            if (relDiff == 0) {
                return o1.name.compareTo(o2.name);
            }

            return relDiff;
        }
    }).sortedCopy(moduleViewModels);
}

From source file:org.apache.brooklyn.util.core.xstream.ImmutableSetConverter.java

public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
    Collection<?> collection = Lists.newArrayList();
    populateCollection(reader, context, collection);
    return ImmutableSet.copyOf(Iterables.filter(collection, Predicates.notNull()));
}

From source file:google.registry.util.SendEmailUtils.java

/**
 * Sends an email from Nomulus to the specified recipients. Returns true iff sending was
 * successful.//from  ww w . ja v  a 2s.c  o m
 */
public static boolean sendEmail(Iterable<String> addresses, final String subject, String body) {
    try {
        Message msg = emailService.createMessage();
        msg.setFrom(new InternetAddress(CONFIG.getGoogleAppsSendFromEmailAddress(),
                CONFIG.getGoogleAppsAdminEmailDisplayName()));
        List<InternetAddress> emails = FluentIterable.from(addresses)
                .transform(new Function<String, InternetAddress>() {
                    @Override
                    public InternetAddress apply(String emailAddress) {
                        try {
                            return new InternetAddress(emailAddress);
                        } catch (AddressException e) {
                            logger.severefmt(e, "Could not send email to %s with subject '%s'.", emailAddress,
                                    subject);
                            // Returning null excludes this address from the list of recipients on the email.
                            return null;
                        }
                    }
                }).filter(Predicates.notNull()).toList();
        if (emails.isEmpty()) {
            return false;
        }
        msg.addRecipients(Message.RecipientType.TO, toArray(emails, InternetAddress.class));
        msg.setSubject(subject);
        msg.setText(body);
        emailService.sendMessage(msg);
    } catch (Throwable t) {
        logger.severefmt(t, "Could not email to addresses %s with subject '%s'.",
                Joiner.on(", ").join(addresses), subject);
        return false;
    }
    return true;
}

From source file:org.apache.brooklyn.util.core.xstream.ImmutableListConverter.java

public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
    Collection<?> collection = Lists.newArrayList();
    populateCollection(reader, context, collection);
    return ImmutableList.copyOf(Iterables.filter(collection, Predicates.notNull()));
}

From source file:org.eclipse.xtext.scoping.impl.LoadOnDemandResourceDescriptions.java

@Override
public Iterable<IResourceDescription> getAllResourceDescriptions() {
    return Iterables.filter(Iterables.transform(validUris, new Function<URI, IResourceDescription>() {
        @Override//from   w  ww.  j  a  v  a2 s  .c  o m
        public IResourceDescription apply(URI from) {
            return getResourceDescription(from);
        }
    }), Predicates.notNull());
}