if isErrBucketNotFound(err) {
			return batchKeyRotationJobError{
				Code:           "NoSuchSourceBucket",
				Description:    "The specified source bucket does not exist",
				HTTPStatusCode: http.StatusNotFound,
			}
		}
		return err
	}
	if GlobalKMS == nil {
		return errKMSNotConfigured
	}
	if err := r.Encryption.Validate(); err != nil {
		return err
	}

     */
    public void setShareAccess(final int shareAccess) {
        this.shareAccess = shareAccess;
    }

    /**
     * Set the create disposition specifying what action to take if file exists or doesn't exist
     * @param createDisposition the createDisposition to set
     */
    public void setCreateDisposition(final int createDisposition) {
        this.createDisposition = createDisposition;
    }

    /**

    return Iterators.all(iterable.iterator(), predicate);
  }

  /**
   * Returns the first element in {@code iterable} that satisfies the given predicate; use this
   * method only when such an element is known to exist. If it is possible that <i>no</i> element
   * will match, use {@link #tryFind} or {@link #find(Iterable, Predicate, Object)} instead.
   *

            if (!result.isEmpty()) {
                delete(userDN, adminEnv);
            } else {
                logger.info("User does not exist in LDAP server: name={}", user.getName());
            }
        });

    }

    /**
     * Inserts or updates a role in the LDAP directory.
     *

			filter,
			[]string{}, // only need DN, so pass no attributes here
			nil,
		)

		searchResult, err := conn.Search(searchRequest)
		if err != nil {
			// Object does not exist error?
			if ldap.IsErrorWithCode(err, 32) {
				ndn, err := ldap.ParseDN(dn)
				if err != nil {
					return nil, err
				}
				nonExistentUsers = append(nonExistentUsers, ndn.String())
				continue
			}

		}
	}
	if opts.ReplicationRequest && opts.DeleteMarker && defPool.Index >= 0 {
		// If the request is a delete marker replication request, return a default pool
		// in cases where the object does not exist.
		// This is to ensure that the delete marker is replicated to the destination.
		return defPool, noReadQuorumPools, nil
	}
	return PoolObjInfo{}, noReadQuorumPools, toObjectErr(errFileNotFound, bucket, object)
}

		if err == nil && opts.CheckPrecondFn(obj) {
			return nil, PreConditionFailed{}
		}
		if err != nil && !isErrVersionNotFound(err) && !isErrObjectNotFound(err) {
			return nil, err
		}

		// if object doesn't exist return error for If-Match conditional requests
		// If-None-Match should be allowed to proceed for non-existent objects
		if err != nil && opts.HasIfMatch && (isErrObjectNotFound(err) || isErrVersionNotFound(err)) {

      ask_for_var='Please specify the home path of the Android NDK to use.',
      check_success=valid_ndk_path,
      error_msg=('The path %s or its child file "source.properties" '
                 'does not exist.'))
  write_action_env_to_bazelrc('ANDROID_NDK_HOME', android_ndk_home_path)
  write_action_env_to_bazelrc(
      'ANDROID_NDK_API_LEVEL',
      get_ndk_api_level(environ_cp, android_ndk_home_path))

		if err != nil {
			writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
			return
		}
		if foundResult == nil {
			err := errors.New("Specified user does not exist on LDAP server")
			APIErr := errorCodes.ToAPIErrWithErr(ErrAdminNoSuchUser, err)
			writeErrorResponseJSON(ctx, w, APIErr, r.URL)
			return
		}

		// In case of LDAP/OIDC we need to set `opts.claims` to ensure

    /**
     * Imports crawling information and parameters from a CSV file.
     * The CSV format expected is: SessionId, SessionCreatedTime, Key, Value, CreatedTime.
     * Creates new crawling sessions if they don't exist and adds parameters to them.
     *
     * @param reader the Reader containing CSV data to import
     */
    public void importCsv(final Reader reader) {
        @SuppressWarnings("resource")