@Override
    public void log(final LogType key, final Object... objs) {
        if (!ComponentUtil.available()) {
            if (logger.isDebugEnabled()) {
                logger.debug("container was destroyed.");
            }
            return;
        }
        super.log(key, objs);
    }

    @Override
    protected void processStartCrawling(final Object... objs) {
        super.processStartCrawling(objs);

                            "input": {"title": "Input"},
                            "ctx": {"title": "Context", "type": "object"},
                        },
                    },
                    "HTTPValidationError": {
                        "title": "HTTPValidationError",
                        "type": "object",
                        "properties": {
                            "detail": {

   * href="http://gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html">efficiently splittable</a>.
   * This may harm parallel performance.
   */
  @Beta
  public static <A extends @Nullable Object, B extends @Nullable Object, R extends @Nullable Object>
      Stream<R> zip(
          Stream<A> streamA, Stream<B> streamB, BiFunction<? super A, ? super B, R> function) {
    checkNotNull(streamA);
    checkNotNull(streamB);

  // Always equal is a valid total ordering. And it works for any Object.
  private static final class AlwaysEqual extends Ordering<@Nullable Object>
      implements Serializable {
    private static final AlwaysEqual INSTANCE = new AlwaysEqual();

    @Override
    @SuppressWarnings("UnusedVariable") // intentionally weird Comparator
    public int compare(@Nullable Object o1, @Nullable Object o2) {
      return 0;
    }

    @Override

    }

    @Override
    protected String getItemEndpointSuffix() {
        return ITEM_ENDPOINT_SUFFIX;
    }

    @Override
    protected Map<String, Object> createTestParam(int id) {
        final Map<String, Object> requestBody = new HashMap<>();
        final String keyProp = NAME_PREFIX + id;
        requestBody.put(KEY_PROPERTY, keyProp);
        requestBody.put("target", "target" + id);

    delegateList.forEach(action);
  }

  @GwtIncompatible // not present in emulated superclass
  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    return delegateList.copyIntoArray(dst, offset);
  }

  @Override
  Object @Nullable [] internalArray() {
    return delegateList.internalArray();
  }

  @Override
  int internalArrayStart() {

        Map<Object, ToolchainModel> merged = new LinkedHashMap<>();

        for (ToolchainModel dominantModel : dominant) {
            Object key = getToolchainModelKey(dominantModel);

            merged.put(key, dominantModel);
        }

        for (ToolchainModel recessiveModel : recessive) {
            Object key = getToolchainModelKey(recessiveModel);

                            "input": {"title": "Input"},
                            "ctx": {"title": "Context", "type": "object"},
                        },
                    },
                    "HTTPValidationError": {
                        "title": "HTTPValidationError",
                        "type": "object",
                        "properties": {
                            "detail": {

                            "input": {"title": "Input"},
                            "ctx": {"title": "Context", "type": "object"},
                        },
                    },
                    "HTTPValidationError": {
                        "title": "HTTPValidationError",
                        "type": "object",
                        "properties": {
                            "detail": {

                        "title": "Image",
                        "type": "object",
                    },
                    "ValidationError": {
                        "title": "ValidationError",
                        "required": ["loc", "msg", "type"],
                        "type": "object",
                        "properties": {
                            "loc": {