*/
  @Override
  protected long edgeCount() {
    return delegate().edges().size();
  }

  @Override
  public boolean isDirected() {
    return delegate().isDirected();
  }

  @Override
  public boolean allowsSelfLoops() {
    return delegate().allowsSelfLoops();
  }

  @Override
  public ElementOrder<N> nodeOrder() {
    return delegate().nodeOrder();
  }

  @Override

 * or {@link SettingsStaxReader}
 */
@Deprecated
public class SettingsXpp3Reader {

    private final SettingsStaxReader delegate;

    public SettingsXpp3Reader() {
        delegate = new SettingsStaxReader();
    }

    public SettingsXpp3Reader(ContentTransformer contentTransformer) {
        delegate = new SettingsStaxReader(contentTransformer::transform);
    }

    /**

      for (delegate in eventListeners) {
        delegate.responseHeadersStart(call)
      }
    }

    override fun responseHeadersEnd(
      call: Call,
      response: Response,
    ) {
      for (delegate in eventListeners) {
        delegate.responseHeadersEnd(call, response)
      }
    }

    override fun responseBodyStart(call: Call) {
      for (delegate in eventListeners) {

  public boolean isTerminated() {
    return delegate().isTerminated();
  }

  @Override
  public void shutdown() {
    delegate().shutdown();
  }

  @Override
  @CanIgnoreReturnValue
  public List<Runnable> shutdownNow() {
    return delegate().shutdownNow();
  }

  @Override
  public void execute(Runnable command) {
    delegate().execute(command);
  }

  @Override

  @Override
  protected abstract Deque<E> delegate();

  @Override
  public void addFirst(@ParametricNullness E e) {
    delegate().addFirst(e);
  }

  @Override
  public void addLast(@ParametricNullness E e) {
    delegate().addLast(e);
  }

  @Override
  public Iterator<E> descendingIterator() {
    return delegate().descendingIterator();
  }

  @Override
  @ParametricNullness

    this(new TreeMap<K, V>(map));
  }

  private SafeTreeMap(NavigableMap<K, V> delegate) {
    this.delegate = delegate;
    if (delegate == null) {
      throw new NullPointerException();
    }
    for (K k : keySet()) {
      checkValid(k);
    }
  }

  @Override
  public @Nullable Entry<K, V> ceilingEntry(K key) {
    return delegate.ceilingEntry(checkValid(key));
  }

  @Override

  @Override
  public boolean containsKey(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    return (delegate != null) ? delegate.containsKey(key) : indexOf(key) != -1;
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.get(key);
    }
    int index = indexOf(key);
    if (index == -1) {

    protected Object delegate;

    public BaseObject() {}

    public BaseObject(Object delegate, BaseObject parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent != null ? parent::replace : null;
    }

    public BaseObject(Object delegate, ChildrenTracking parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");

    protected Object delegate;

    public BaseObject() {}

    public BaseObject(Object delegate, BaseObject parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent != null ? parent::replace : null;
    }

    public BaseObject(Object delegate, ChildrenTracking parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");

      insertionOrder = castOrCopyToList(delegate.order(insertionOrder));
      reverse(insertionOrder);
      return insertionOrder;
    }

    TestSortedMapGenerator<K, V> delegate() {
      return (TestSortedMapGenerator<K, V>) delegate;
    }

    @Override
    public Entry<K, V> belowSamplesLesser() {
      return delegate().aboveSamplesGreater();
    }

    @Override