private final char[] buf = cbuf.array();

  private final Queue<String> lines = new ArrayDeque<>();
  private final LineBuffer lineBuf =
      new LineBuffer() {
        @Override
        protected void handleLine(String line, String end) {
          lines.add(line);
        }
      };

  /** Creates a new instance that will read lines from the given {@code Readable} object. */
  public LineReader(Readable readable) {

  ImmutableMapValues(ImmutableMap<K, V> map) {
    this.map = map;
  }

  @Override
  public int size() {
    return map.size();
  }

  @Override
  public UnmodifiableIterator<V> iterator() {
    return new UnmodifiableIterator<V>() {
      final UnmodifiableIterator<Entry<K, V>> entryItr = map.entrySet().iterator();

      @Override
      public boolean hasNext() {
        return entryItr.hasNext();
      }

  private final long size;

  static <E> ImmutableMultiset<E> create(Collection<? extends Entry<? extends E>> entries) {
    @SuppressWarnings("unchecked")
    Entry<E>[] entriesArray = entries.toArray((Entry<E>[]) new Entry<?>[0]);
    Map<E, Integer> delegateMap = Maps.newHashMapWithExpectedSize(entriesArray.length);
    long size = 0;
    for (int i = 0; i < entriesArray.length; i++) {
      Entry<E> entry = entriesArray[i];

    static final Ordering<@Nullable Object> ARBITRARY_ORDERING = new ArbitraryOrdering();
  }

  @J2ktIncompatible // MapMaker
  @VisibleForTesting
  static class ArbitraryOrdering extends Ordering<@Nullable Object> {

    private final AtomicInteger counter = new AtomicInteger(0);
    private final ConcurrentMap<Object, Integer> uids =
        Platform.tryWeakKeys(new MapMaker()).makeMap();

     */
    public void add(final WebApiManager webApiManager) {
        final List<WebApiManager> list = new ArrayList<>();
        Collections.addAll(list, webApiManagers);
        list.add(webApiManager);
        webApiManagers = list.toArray(new WebApiManager[list.size()]);
    }

    /**
     * Gets the appropriate web API manager for the given request.
     *

 *   <li>{@code POST_PROCESSING} - Represents the post-processing state.</li>
 *   <li>{@code NO_URL_IN_QUEUE} - Indicates that there are no URLs in the queue.</li>
 *   <li>{@code WAIT_NEW_URL} - Indicates that the crawler is waiting for new URLs.</li>
 * </ul>
 */
public interface IntervalController {
    /** Constant representing the pre-processing state. */
    int PRE_PROCESSING = 1;

    /** Constant representing the post-processing state. */

     */
    @Deprecated
    public InvalidProjectModelException(
            String projectId, String pomLocation, String message, ModelValidationResult validationResult) {
        this(projectId, message, new File(pomLocation), validationResult);
    }

    public InvalidProjectModelException(
            String projectId, String message, File pomFile, ModelValidationResult validationResult) {

    private final boolean aggregating;

    public TaskSegment(boolean aggregating) {
        this.aggregating = aggregating;
        tasks = new ArrayList<>();
    }

    public TaskSegment(boolean aggregating, Task... tasks) {
        this.aggregating = aggregating;
        this.tasks = new ArrayList<>(Arrays.asList(tasks));
    }

    @Override
    public String toString() {
        return getTasks().toString();
    }

        this.actual = actual;
    }

    public static ProjectBuildingResultWithProblemMessageAssert assertThat(ProjectBuildingResult actual) {
        return new ProjectBuildingResultWithProblemMessageAssert(actual);
    }

    public ProjectBuildingResultWithProblemMessageAssert hasProblemMessage(String problemMessage) {
        assertNotNull(actual);

        boolean hasMessage =

        if (object instanceof org.codehaus.plexus.util.xml.Xpp3Dom xpp3Dom) {
            object = xpp3Dom.getDom();
        }
        if (object instanceof XmlNode xmlNode) {
            return new Xpp3DomNodePointer(xmlNode);
        }
        return null;
    }

    @Override
    public NodePointer createNodePointer(NodePointer parent, QName name, Object object) {