* each {@code Artifact} is associated to a specific version instead of a range of versions.
     * If the {@linkplain #getBaseVersion() base version} contains a meta-version such as {@code SNAPSHOT},
     * those keywords are replaced by, for example, the actual timestamp.
     *
     * @see ArtifactCoordinates#getVersionConstraint()
     */
    @Nonnull
    Version getVersion();

    /**

  # Can use regexp here: `generated.*`, regexp is applied on full path,
  # including the path prefix if one is set.
  # Default dirs are skipped independently of this option's value (see exclude-dirs-use-default).
  # "/" will be replaced by current OS file path separator to properly work on Windows.
  # Default: []
  exclude-dirs:
    - genfiles$
    - vendor$
  # Which files to exclude: they will be analyzed, but issues from them won't be reported.

	},
}

var internal32KByteBuffer = sync.Pool{
	New: func() any {
		m := make([]byte, 0, biggerBufMin)
		return &m
	},
}

// GetByteBuffer can be replaced with a function that returns a small
// byte buffer.
// When replacing PutByteBuffer should also be replaced
// There is no minimum size.
var GetByteBuffer = func() []byte {
	b := *internalByteBuffer.Get().(*[]byte)
	return b[:0]
}

        return blockProperty.deprecated || blockMethod.deprecated
    }

    boolean isIncubating() {
        return blockProperty.incubating || blockMethod.incubating
    }

    boolean isReplaced() {
        return blockProperty.replaced
    }

    @Override
    String getReplacement() {
        return blockProperty.replacement
    }

    PropertyDoc getBlockProperty() {
        return blockProperty
    }

#
# Windows-specific utilities.
#

# Docker on Windows has difficulty using volumes other than C:\, when it comes
# to setting up up volume mappings.
# Thus, the drive letter is replaced with C:\, in case it's
# something else (ex. T:), which is frequently the case inside Kokoro jobs.
function replace_drive_letter_with_c () {
  sed -E "s|^[a-zA-Z]:|C:|g" <<< $1

        return metaData.deprecated && !referringClass.deprecated
    }

    boolean isIncubating() {
        return metaData.incubating || metaData.ownerClass.incubating
    }

    boolean isReplaced() {
        return metaData.replaced
    }

    @Override
    String getReplacement() {
        return metaData.replacement
    }

    Element getDescription() {
        return comment.find { it.nodeName == 'para' }

        when {
          startsWith('"'.code.toByte()) -> readQuotedString()
          else -> readToken()
        } ?: return // Expected a value.

      val replaced = parameters.put(peek, parameterValue)
      peek = null
      if (replaced != null) return // Unexpected duplicate parameter.
      if (!skipCommasAndWhitespace() && !exhausted()) return // Expected ',' or EOF.
    }

                caution.appendChild(document.createTextNode("Incubating"));
            }
            if (propDoc.isReplaced()) {
                Element caution = document.createElement("caution");
                td.appendChild(caution);
                caution.appendChild(document.createTextNode("Replaced"));
            }
            td.appendChild(document.importNode(propDoc.getDescription(), true));
        }
    }

              || countMap.replace(element, existingCounter, newCounter);
        }
      } else {
        if (existingCounter.compareAndSet(oldValue, newCount)) {
          if (newCount == 0) {
            // Just CASed to 0; remove the entry to clean up the map. If the removal fails,
            // another thread has already replaced it with a new counter, which is fine.

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(
            RemovalNotification.create("one", 1, RemovalCause.EXPLICIT),
            RemovalNotification.create("one", 1, RemovalCause.REPLACED))
        .addEqualityGroup(RemovalNotification.create("1", 1, RemovalCause.EXPLICIT))
        .addEqualityGroup(RemovalNotification.create("one", 2, RemovalCause.EXPLICIT))
        .testEquals();
  }