}

// DeleteBulkReq - send multiple paths in same delete request.
type DeleteBulkReq struct {
	Paths []string `msg:"p"`
}

// DeleteVersionsErrsResp - collection of delete errors
// for bulk version deletes
type DeleteVersionsErrsResp struct {
	Errs []string `msg:"e"`

    /** The key of the configuration. e.g. true */
    String FTP_ROLE_FROM_FILE = "ftp.role.from.file";

    /** The key of the configuration. e.g. fess_basic_config.bulk,fess_config.bulk,fess_user.bulk,system.properties,fess.json,doc.json */
    String INDEX_BACKUP_TARGETS = "index.backup.targets";

    protected int splitSize = 10;

    /**
     * Maximum size of the thumbnail generation task queue.
     */
    protected int thumbnailTaskQueueSize = 10000;

    /**
     * Number of tasks to process in bulk operations.
     */
    protected int thumbnailTaskBulkSize = 100;

    /**
     * Timeout in milliseconds for thumbnail task queue operations.
     */
    protected long thumbnailTaskQueueTimeout = 10 * 1000L;

   */
  @CanIgnoreReturnValue
  @Override
  public boolean put(@ParametricNullness K key, @ParametricNullness V value) {
    addNode(key, value, null);
    return true;
  }

  // Bulk Operations

  /**
   * {@inheritDoc}
   *
   * <p>If any entries for the specified {@code key} already exist in the multimap, their values are
   * changed in-place without affecting the iteration order.
   *

    Collection<V> collection = map.get(key);
    if (collection == null) {
      collection = createCollection(key);
      map.put(key, collection);
    }
    return collection;
  }

  // Bulk Operations

  /**
   * {@inheritDoc}
   *
   * <p>The returned collection is immutable.
   */
  @Override
  public Collection<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values) {

	errs := statAllDirs(ctx, storageDisks, bucket, object)
	danglingObject := isObjectDirDangling(errs)
	if danglingObject {
		if !dryRun && remove {
			var wg sync.WaitGroup
			// Remove versions in bulk for each disk
			for index, disk := range storageDisks {
				if disk == nil {
					continue
				}
				wg.Add(1)
				go func(index int, disk StorageAPI) {
					defer wg.Done()

			t.Fatalf("TestXLStorage %d:  Expected the error to be : \"%v\", got: \"%v\".", i+1, testCase.expectedErr, err)
		}
	}
}

// TestXLStorageDeleteVersion will test if version deletes and bulk deletes work as expected.
func TestXLStorageDeleteVersion(t *testing.T) {
	// create xlStorage test setup
	xl, _, err := newXLStorageTestSetup(t)
	if err != nil {

   * in the returned list.
   *
   * <p>The function is applied lazily, invoked when needed. This is necessary for the returned list
   * to be a view, but it means that the function will be applied many times for bulk operations
   * like {@link List#contains} and {@link List#hashCode}. For this to perform well, {@code
   * function} should be fast. To avoid lazy evaluation when the returned list doesn't need to be a

	}
	volume := r.Form.Get(storageRESTVolume)
	err := s.getStorage().MakeVol(r.Context(), volume)
	if err != nil {
		s.writeErrorResponse(w, err)
	}
}

// MakeVolBulkHandler - create multiple volumes as a bulk operation.
func (s *storageRESTServer) MakeVolBulkHandler(w http.ResponseWriter, r *http.Request) {
	if !s.IsValid(w, r) {
		return
	}
	volumes := strings.Split(r.Form.Get(storageRESTVolumes), ",")

    /** The key of the message: Started re-indexing. */
    public static final String SUCCESS_reindex_started = "{success.reindex_started}";

    /** The key of the message: Started a bulk process. */
    public static final String SUCCESS_bulk_process_started = "{success.bulk_process_started}";

    /** The key of the message: Printed a thread dump to a log file. */