* href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>Warning:</b> The methods of {@code ForwardingSet} forward <b>indiscriminately</b> to the
 * methods of the delegate. For example, overriding {@link #add} alone <b>will not</b> change the
 * behavior of {@link #addAll}, which can lead to unexpected behavior. In this case, you should

   * @param expected expected value of {@link #container}
   */
  /*
   * TODO: improve this and other implementations and move out of this framework
   * for wider use
   *
   * TODO: could we incorporate the overriding logic from AbstractListTester, by
   * examining whether the features include KNOWN_ORDER?
   */
  protected void expectContents(Collection<E> expected) {
    assertEqualIgnoringOrder(expected, actualContents());
  }

 *
 * <p><b>Warning:</b> The methods of {@code ForwardingBlockingDeque} forward <b>indiscriminately</b>
 * to the methods of the delegate. For example, overriding {@link #add} alone <b>will not</b> change
 * the behaviour of {@link #offer} which can lead to unexpected behaviour. In this case, you should

   * unspecified if this method is called more than once on the same instance.
   */
  public HashCode hash() {
    return hasher.hash();
  }

  // Overriding close() because FilterOutputStream's close() method pre-JDK8 has bad behavior:
  // it silently ignores any exception thrown by flush(). Instead, just close the delegate stream.
  // It should flush itself if necessary.
  @Override

    private static final Logger logger = LogManager.getLogger(FessActionAdjustmentProvider.class);

    // _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
    // you can adjust your actions by overriding
    // default methods defined at the interface
    // _/_/_/_/_/_/_/_/_/_/

    protected Map<String, List<Pair<String, String>>> responseHeaderMap = new HashMap<>();

 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>Warning:</b> The methods of {@code ForwardingMapEntry} forward <i>indiscriminately</i> to
 * the methods of the delegate. For example, overriding {@link #getValue} alone <i>will not</i>
 * change the behavior of {@link #equals}, which can lead to unexpected behavior. In this case, you

    public void addProfile(Profile profile) {
        String profileId = profile.getId();

        Profile existing = profilesById.get(profileId);
        if (existing != null) {
            logger.warn("Overriding profile: '" + profileId + "' (source: " + existing.getSource()
                    + ") with new instance from source: " + profile.getSource());
        }

        profilesById.put(profile.getId(), profile);

        if (!ignoredArtifacts.contains(artifact)) {
            logger.warn("\n\tArtifact " + artifact + " retains local artifactScope '" + artifact.getScope()
                    + "' overriding broader artifactScope '" + ignoredScope + "'\n"
                    + "\tgiven by a dependency. If this is not intended, modify or remove the local artifactScope.\n");
            ignoredArtifacts.add(artifact);
        }
    }

 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>Warning:</b> The methods of {@code ForwardingMultiset} forward <b>indiscriminately</b> to
 * the methods of the delegate. For example, overriding {@link #add(Object, int)} alone <b>will
 * not</b> change the behavior of {@link #add(Object)}, which can lead to unexpected behavior. In
 * this case, you should override {@code add(Object)} as well, either providing your own

    super(new EnumMap<K, V>(keyType), new HashMap<V, K>());
    // TODO: cpovirk - Pre-size the HashMap based on the number of enum values?
    this.keyTypeOrObjectUnderJ2cl = keyType;
  }

  // Overriding these 3 methods to show that values may be null (but not keys)

  @Override
  K checkKey(K key) {
    return checkNotNull(key);
  }

  @CanIgnoreReturnValue
  @Override