}
                };
            }

            @Override
            public int size() {
                return (int) properties.entrySet().stream()
                        .filter(PropertiesAsMap::matches)
                        .count();
            }
        };
    }

    private static boolean matches(Entry<Object, Object> entry) {

                .filter(p -> p.getArtifactId().equals(artifactId))
                .findFirst()
                .orElse(null);
        assertNotNull(plugin, "Unable to find plugin with artifactId: " + artifactId);
        List<PluginExecution> pluginExecutions = plugin.getExecutions();
        PluginExecution pluginExecution = pluginExecutions.stream()
                .filter(pe -> pe.getId().equals(expectedId))

                        FAMILY_TANDEM,
                        FAMILY_UNIX,
                        FAMILY_WIN9X,
                        FAMILY_WINDOWS,
                        FAMILY_ZOS)
                .filter(Os::isFamily)
                .findFirst()
                .orElse(null);
    }

   * individually submitted tasks and to collections of tasks submitted via {@code invokeAll} or
   * {@code invokeAny}. In the latter case, tasks will run serially on the calling thread. Tasks are
   * run to completion before a {@code Future} is returned to the caller (unless the executor has
   * been shutdown).
   *
   * <p>Although all tasks are immediately executed in the thread that submitted the task, this

    String INDEX_DOCUMENT_CRAWLER_DATA_number_of_shards = "index.document.crawler.data.number_of_shards";

    /** The key of the configuration. e.g. 10 */
    String INDEX_DOCUMENT_CRAWLER_FILTER_number_of_shards = "index.document.crawler.filter.number_of_shards";

    /** The key of the configuration. e.g. 1 */
    String INDEX_DOCUMENT_CRAWLER_QUEUE_number_of_replicas = "index.document.crawler.queue.number_of_replicas";

        }
        return parent;
    }

    private Map<String, Activation> getProfileActivations(Model model) {
        return model.getProfiles().stream()
                .filter(p -> p.getActivation() != null)
                .collect(Collectors.toMap(Profile::getId, Profile::getActivation));
    }

    private Model injectProfileActivations(Model model, Map<String, Activation> activations) {

     * Note: Project properties contains properties injected from profiles, if applicable. Their precedence is
     * {@code profile > project}, hence active profile property may override project property.
     * <p>
     * The caller of this method should decide whether there is a project in scope (hence, a project instance
     * needs to be passed) or not.
     *
     * @param project {@link Project} or {@code null}.

   */
  // TODO(kevinb): how can we omit that Iterables link when building gwt
  // javadoc?
  public static <E extends @Nullable Object> Collection<E> filter(
      Collection<E> unfiltered, Predicate<? super E> predicate) {
    if (unfiltered instanceof FilteredCollection) {
      // Support clear(), removeAll(), and retainAll() when filtering a filtered
      // collection.

     * The number of live elements in this segment's region. This does not include unset elements
     * which are awaiting cleanup.
     */
    volatile int count;

    /**
     * Number of updates that alter the size of the table. This is used during bulk-read methods to
     * make sure they see a consistent snapshot: If modCounts change during a traversal of segments

   * <p><b>{@code Stream} equivalent:</b> {@link Stream#filter}.
   */
  public static <T extends @Nullable Object> Iterable<T> filter(
      final Iterable<T> unfiltered, final Predicate<? super T> retainIfTrue) {
    checkNotNull(unfiltered);
    checkNotNull(retainIfTrue);
    return new FluentIterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return Iterators.filter(unfiltered.iterator(), retainIfTrue);
      }