}
  delete(file)
  return false
}

/** Delete file we expect but don't require to exist. */
internal fun FileSystem.deleteIfExists(path: Path) {
  try {
    delete(path)
  } catch (fnfe: FileNotFoundException) {
    return
  }
}

/** Tolerant delete, try to clear as many files as possible even after a failure. */
internal fun FileSystem.deleteContents(directory: Path) {
  var exception: IOException? = null

        boostDocumentRuleBhv.insertOrUpdate(boostDocumentRule, op -> op.setRefreshPolicy(Constants.TRUE));

    }

    public void delete(final BoostDocumentRule boostDocumentRule) {

        boostDocumentRuleBhv.delete(boostDocumentRule, op -> op.setRefreshPolicy(Constants.TRUE));

    }

    protected void setupListCondition(final BoostDocumentRuleCB cb, final BoostDocPager boostDocumentRulePager) {

        requestHeaderBhv.insertOrUpdate(requestHeader, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    public void delete(final RequestHeader requestHeader) {

        requestHeaderBhv.delete(requestHeader, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

        webAuthenticationBhv.insertOrUpdate(webAuthentication, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    public void delete(final WebAuthentication webAuthentication) {

        webAuthenticationBhv.delete(webAuthentication, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    super.atomicMove(source, target)
  }

  @Throws(IOException::class)
  override fun delete(
    path: Path,
    mustExist: Boolean,
  ) {
    if (deleteFaults.contains(path)) throw IOException("boom!")
    super.delete(path, mustExist)
  }

  @Throws(IOException::class)
  override fun deleteRecursively(
    fileOrDirectory: Path,
    mustExist: Boolean,
  ) {

	// Indicates whether MinIO will remove all versions. If set to true, all versions will be deleted;
	// if set to false the policy takes no action. This action uses the Days/Date to expire objects.
	// This check is verified for latest version of the object.
	DeleteAll Boolean `xml:"ExpiredObjectAllVersions"`

	set bool
}

// MarshalXML encodes delete marker boolean into an XML form.

        return asJson(
                new ApiUpdateResponse().id(doc.get(fessConfig.getIndexFieldDocId()).toString()).created(false).status(Status.OK).result());
    }

    // DELETE /api/admin/searchlist/doc/{doc_id}
    @Execute
    public JsonResponse<ApiResult> delete$doc(final String id) {
        try {
            final QueryBuilder query = QueryBuilders.termQuery(fessConfig.getIndexFieldDocId(), id);

	// 3. g1 tx exec insert, wait for unlock `conn.PrepareContext(ctx, query)` to finish tx and release.
	stmt, err := conn.PrepareContext(ctx, query)
	if err != nil {
		cacheStmt.prepareErr = err
		db.Mux.Lock()
		delete(db.Stmts, query)
		db.Mux.Unlock()
		return Stmt{}, err
	}

	db.Mux.Lock()
	cacheStmt.Stmt = stmt
	db.Mux.Unlock()

	return cacheStmt, nil
}

#!/bin/bash

# The website is built using MkDocs with the Material theme.
# https://squidfunk.github.io/mkdocs-material/
# It requires python3 to run.

set -ex

REPO="******@****.***:square/okhttp.git"
DIR=temp-clone

# Delete any existing temporary website clone
rm -rf $DIR

# Clone the current repo into temp folder
git clone $REPO $DIR
# Replace `git clone` with these lines to hack on the website locally
# cp -a . "../okhttp-website"

        }
        return asJson(new ApiResult.ApiUpdateResponse().id(entity.getId()).created(false).status(ApiResult.Status.OK).result());
    }

    // DELETE /api/admin/scheduler/setting/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String id) {
        final ScheduledJob entity = scheduledJobService.getScheduledJob(id).orElseGet(() -> {