public static class Holder {
        private volatile boolean set;
        private volatile Model model;

        Holder() {}

        Holder(Model model) {
            this.model = Objects.requireNonNull(model);
            this.set = true;
        }

        public static Model deref(Holder holder) {
            return holder != null ? holder.get() : null;
        }

        public Model get() {

        } else {
            this.proxies = null;
        }

        return this;
    }

    @Override
    public MavenExecutionRequest addProxy(Proxy proxy) {
        Objects.requireNonNull(proxy, "proxy cannot be null");

        for (Proxy p : getProxies()) {
            if (p.getId() != null && p.getId().equals(proxy.getId())) {
                return this;
            }
        }

      public V remove(@CheckForNull Object key) {
        V value = get(key);
        if (value != null) {
          // it's definitely in the map, so the cast and requireNonNull are safe
          @SuppressWarnings("unchecked")
          Range<K> range = (Range<K>) requireNonNull(key);
          TreeRangeMap.this.remove(range);
          return value;
        }
        return null;
      }

      @Override

      class LocalClass<T> {}
      Class<?> subclass = new LocalClass<String>() {}.getClass();
      // requireNonNull is safe because we're examining a type that's known to have a superclass.
      ParameterizedType parameterizedType =
          requireNonNull((ParameterizedType) subclass.getGenericSuperclass());
      for (ClassOwnership behavior : ClassOwnership.values()) {

      checkState(
          state == FAILED,
          "failureCause() is only valid if the service has failed, service is %s",
          state);
      // requireNonNull is safe because the constructor requires a non-null cause with state=FAILED.
      return requireNonNull(failure);
    }
  }

      }
      laterCount--;
      canRemove = true;
      /*
       * requireNonNull is safe because laterCount starts at 0, forcing us to initialize
       * currentEntry above. After that, we never clear it.
       */
      return requireNonNull(currentEntry).getElement();
    }

    @Override
    public void remove() {
      checkRemove(canRemove);

      }
      laterCount--;
      canRemove = true;
      /*
       * requireNonNull is safe because laterCount starts at 0, forcing us to initialize
       * currentEntry above. After that, we never clear it.
       */
      return requireNonNull(currentEntry).getElement();
    }

    @Override
    public void remove() {
      checkRemove(canRemove);

import static java.util.Objects.requireNonNull;

/**
 * A class building reverse tree using {@link CollectStepData} trace data provided in {@link RepositoryEvent}
 * events fired during collection.
 *
 * @since 3.9.0
 */
class ReverseTreeRepositoryListener extends AbstractRepositoryListener {
    @Override
    public void artifactResolved(RepositoryEvent event) {
        requireNonNull(event, "event cannot be null");

    }

    @Override
    public T next() {
      if (!hasNext()) {
        throw new NoSuchElementException();
      }

      // requireNonNull is safe because of the hasNext check.
      BiEntry<K, V> entry = requireNonNull(next);
      next = entry.nextInKeyInsertionOrder;
      toRemove = entry;
      remaining--;
      return output(entry);
    }

    @Override

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect;

import static java.util.Objects.requireNonNull;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.annotations.VisibleForTesting;