* if the returned {@link Iterable} contains duplicate elements. Implementations of such
   * algorithms should document their behavior in the presence of duplicates.
   *
   * <p>The elements of the returned {@code Iterable} must each be:
   *
   * <ul>
   *   <li>Non-null
   *   <li>Usable as {@code Map} keys (see the Guava User Guide's section on <a

    // DELETE /api/admin/dict/protwords/setting/{dictId}/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String dictId, final long id) {
        protwordsService.getProtwordsItem(dictId, id).ifPresent(entity -> {
            protwordsService.delete(dictId, entity);
            saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
        }).orElse(() -> {

          <association>
            <type>RepositoryPolicy</type>
          </association>
        </field>
      </fields>
      <!-- prevent modello generation of an incorrect equals method. Could be avoided by using <identity/> tags to mark ID as the only identity field -->
      <codeSegments>
        <codeSegment>
          <version>1.0.0</version>

            resultList.add(executorService.submit(() -> {
                try {
                    if (externalContext != null) {
                        requestOpt.ifPresent(externalContext::setRequest);
                        responseOpt.ifPresent(externalContext::setResponse);
                    }
                    return searcher.search(query, reqParams, userBean);
                } finally {

	xioutil "github.com/minio/minio/internal/ioutil"
	"github.com/minio/pkg/v3/mimedb"
	"github.com/pkg/sftp"
	"golang.org/x/crypto/ssh"
)

// Maximum write offset for incoming SFTP blocks.
// Set to 100MiB to prevent hostile DOS attacks.
const ftpMaxWriteOffset = 100 << 20

type sftpDriver struct {
	permissions *ssh.Permissions
	endpoint    string
}

//msgp:ignore sftpMetrics
type sftpMetrics struct{}

The connection lock is never held while doing I/O (even closing a socket) to prevent contention.

     * the interrupting thread doesn't interrupt the _next_ thing to run on this thread.
     *
     * Note: We don't reset the interrupted bit, just wait for it to be set. If this is a thread
     * pool thread, the thread pool will reset it for us. Otherwise, the interrupted bit may have
     * been intended for something else, so don't clear it.
     */
    boolean restoreInterruptedBit = false;

    // DELETE /api/admin/dict/kuromoji/setting/{dictId}/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String dictId, final long id) {
        kuromojiService.getKuromojiItem(dictId, id).ifPresent(entity -> {
            kuromojiService.delete(dictId, entity);
            saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
        }).orElse(() -> {

    assertEquals(expected.length(), source.length());
  }

  public void testLengthIfKnown() throws IOException {
    Optional<Long> lengthIfKnown = source.lengthIfKnown();
    if (lengthIfKnown.isPresent()) {
      assertEquals(expected.length(), (long) lengthIfKnown.get());
    }
  }

  public void testReadLines_withProcessor() throws IOException {
    List<String> list =
        source.readLines(

        Set<AccessorKey> seenOldAccessorsOfUpgradedProperties = (Set<AccessorKey>) context.userData[SEEN_OLD_REMOVED_ACCESSORS_OF_UPGRADED_PROPERTIES]
        UpgradedProperties.maybeGetKeyOfOldAccessorOfUpgradedProperty(member, context).ifPresent { seenOldAccessorsOfUpgradedProperties.add(it) }

        def change = new ApiChange(
            context.className,
            Violation.describe(member),
            changes
        )