final N node;
  final BaseGraph<N> graph;

  IncidentEdgeSet(BaseGraph<N> graph, N node) {
    this.graph = graph;
    this.node = node;
  }

  @Override
  public boolean remove(@Nullable Object o) {
    throw new UnsupportedOperationException();
  }

  @Override
  public int size() {
    if (graph.isDirected()) {
      return graph.inDegree(node)
          + graph.outDegree(node)

            if (primaryChannel == null) {
                primaryChannel = channel;
            }
        }

        public void removeChannel(ChannelInfo channel) {
            channels.remove(channel);
            if (primaryChannel == channel && !channels.isEmpty()) {
                primaryChannel = channels.get(0);
            }
        }

        public ChannelInfo getPrimaryChannel() {

                paramMap.put(HcHttpClient.PROXY_CREDENTIALS_PROPERTY, new UsernamePasswordCredentials(
                        paramMap.remove(Param.Client.PROXY_USERNAME).toString(), paramMap.remove(Param.Client.PROXY_PASSWORD).toString()));
            }
        } else {
            initializeDefaultHttpProxy(paramMap);
        }

        crawlerClientFactory = factory;

import org.jspecify.annotations.Nullable;

/**
 * This class provides a skeletal implementation of the {@link ListIterator} interface across a
 * fixed number of elements that may be retrieved by position. It does not support {@link #remove},
 * {@link #set}, or {@link #add}.
 *
 * @author Jared Levy
 */
@GwtCompatible
abstract class AbstractIndexedListIterator<E extends @Nullable Object>
    extends UnmodifiableListIterator<E> {

		obj.WriteObjFile(ctxt, buf)
	}
	if !ok || diag {
		if failedFile != "" {
			log.Printf("assembly of %s failed", failedFile)
		} else {
			log.Print("assembly failed")
		}
		buf.Close()
		os.Remove(*flags.OutputFile)
		os.Exit(1)
	}

    }
  }

  inline fun <reified T : CallEvent> removeUpToEvent(): T = removeUpToEvent(T::class.java)

  inline fun <reified T : CallEvent> findEvent(): T = eventSequence.first { it is T } as T

  /**
   * Remove and return the next event from the recorded sequence.
   *
   * @param eventClass a class to assert that the returned event is an instance of, or null to
   *     take any event class.

 *     the same lambda function as passed into {@link #using(Function)}.
 *     <p>This class is scheduled to be removed in October 2019.
 */
// TODO(b/68134636): Remove by 2019-10
@Deprecated
@Beta
@GwtCompatible
public abstract class TreeTraverser<T> {
  /** Constructor for use by subclasses. */
  public TreeTraverser() {}

  /**

                if (file.isDirectory()) {
                    FileUtils.deleteDirectory(file);
                } else {
                    file.delete();
                }
            }

            it.remove();
        }

        warnAboutCleanup = false;
    }

    public void assertFileExistence(File dir, String filename, boolean shouldExist) {
        File file = new File(dir, filename);

            return parent.toArray(a);
        }

        public boolean add(final E e) {
            return parent.add(e);
        }

        public boolean remove(final Object o) {
            return parent.remove(o);
        }

        public boolean containsAll(final Collection<?> c) {
            return parent.containsAll(c);
        }

            }
            final int style = STYLES[index++];
            return DateFormat.getTimeInstance(style, locale);
        }

        @Override
        public void remove() {
            throw new ClUnsupportedOperationException("remove");
        }

    }

    /**
     * An {@link Iterator} that iterates over {@link DateFormat} instances corresponding to the styles supported by the locale.
     *