add(element, 1);
    return true;
  }

  /**
   * A sensible definition of {@link #addAll(Collection)} in terms of {@link #add(Object)} and
   * {@link #add(Object, int)}. If you override either of these methods, you may wish to override
   * {@link #addAll(Collection)} to forward to this implementation.
   *
   * @since 7.0
   */
  @Override

                    List<Plugin> pre = predecessors.get(entry.getKey());
                    if (pre != null) {
                        result.addAll(pre);
                    }
                    result.add(entry.getValue());
                }
                result.addAll(pending);

                target.setPlugins(result);
            }
        }

        @Override

            duplicateHostList = new ArrayList<>();
        }
        try {
            final DuplicateHostService duplicateHostService = ComponentUtil.getComponent(DuplicateHostService.class);
            duplicateHostList.addAll(duplicateHostService.getDuplicateHostList());
        } catch (final AutoBindingFailureException e) {
            logger.warn("DuplicateHostService is not found.", e);
        }
    }

    /**

        List<T> copy = null;

        if (original != null) {
            copy = new ArrayList<>();

            if (!original.isEmpty()) {
                copy.addAll(original);
            }
        }

        return copy;
    }

                    }
                }

                if (!missing.isEmpty()) {
                    throw e;
                }
            }

            resolved.addAll(result.getArtifacts());
        }

        return resolved;
    }

    private Set<String> getIgnorableArtifacts(Collection<? extends MavenProject> projects) {

            this.repositories = new ArrayList<>(repositories.size());
            for (RemoteRepository repository : repositories) {
                if (repository.isRepositoryManager()) {
                    this.repositories.addAll(repository.getMirroredRepositories());
                } else {
                    this.repositories.add(repository);
                }
            }
            this.parentRealm = parentRealm;

	sec := time.Now().Unix()
	l.forwardTo(sec)
	winIdx := sec % 60
	l.Totals[winIdx].add(t)
	l.LastSec = sec
}

// Add  a new duration data
func (l *lastMinuteLatency) addAll(sec int64, a AccElem) {
	l.forwardTo(sec)
	winIdx := sec % 60
	l.Totals[winIdx].merge(a)
	l.LastSec = sec
}

// Merge all recorded latencies of last minute into one

     */
    public void addUrl(final RequestData url) {
        childUrlSet.add(url);
    }

    /**
     * Add child URLs.
     * @param c the collection of request data to add to the child URL set
     */
    public void addAllUrl(final Collection<RequestData> c) {
        if (c != null) {
            childUrlSet.addAll(c);
        }
    }

    /**

                identifiable.setSourceLevel(recessiveSourceLevel);

                identifiables.add(identifiable);
            }
        }

        dominant.addAll(0, identifiables);
    }

    /**
     * @param identifiables
     * @return a map
     */
    private static <T extends IdentifiableBase> Map<String, T> mapById(List<T> identifiables) {

        Lifecycle myLifecycle =
                new Lifecycle("etl", Arrays.asList("extract", "transform", "load"), Collections.emptyMap());
        myLifecycles.add(myLifecycle);
        myLifecycles.addAll(defaultLifeCycles.getLifeCycles());

        Map<String, Lifecycle> lifeCycles = myLifecycles.stream().collect(Collectors.toMap(Lifecycle::getId, l -> l));
        PlexusContainer mockedPlexusContainer = mock(PlexusContainer.class);