// Modification Operations

  /**
   * Stores a key-value pair in this multimap.
   *
   * <p>Some multimap implementations allow duplicate key-value pairs, in which case {@code put}
   * always adds a new key-value pair and increases the multimap size by 1. Other implementations
   * prohibit duplicates, and storing a key-value pair that's already in the multimap has no effect.
   *

            ptList.add(Constants.PROCESS_TYPE_BOTH);
            pathMappingHelper.setPathMappingList(options.sessionId, pathMappingService.getPathMappingList(ptList));

            // duplicate host
            try {
                final DuplicateHostHelper duplicateHostHelper = ComponentUtil.getDuplicateHostHelper();
                duplicateHostHelper.init();
            } catch (final Exception e) {

    public static final int ACB_HOMDIRREQ = 2;
    /** Account control bit flag: Password is not required */
    public static final int ACB_PWNOTREQ = 4;
    /** Account control bit flag: Temporary duplicate account */
    public static final int ACB_TEMPDUP = 8;
    /** Account control bit flag: Normal user account */
    public static final int ACB_NORMAL = 16;
    /** Account control bit flag: MNS logon user account */

    public static final int ACB_HOMDIRREQ = 2;
    /** Account control bit flag: Password is not required */
    public static final int ACB_PWNOTREQ = 4;
    /** Account control bit flag: Temporary duplicate account */
    public static final int ACB_TEMPDUP = 8;
    /** Account control bit flag: Normal user account */
    public static final int ACB_NORMAL = 16;
    /** Account control bit flag: MNS logon user account */

   * Section 7.2.1.2. The iteration order follows the lexicographical order. This means that the
   * first permutation will be in ascending order, and the last will be in descending order.
   *
   * <p>Duplicate elements are considered equal. For example, the list [1, 1] will have only one
   * permutation, instead of two. This is why the elements have to implement {@link Comparable}.
   *

          @SuppressWarnings("unchecked")
          V value = (V) v;
          builder.add(mapEntry(key, value));
        }
      }
      checkArgument(keySet.size() == elements.length, "Duplicate keys");
      return multimapGenerator.create(builder.toArray()).asMap();
    }

    @SuppressWarnings("unchecked")
    @Override
    public Entry<K, Collection<V>>[] createArray(int length) {

/**
 * A {@link Multiset} whose contents will never change, with many other important properties
 * detailed at {@link ImmutableCollection}.
 *
 * <p><b>Grouped iteration.</b> In all current implementations, duplicate elements always appear
 * consecutively when iterating. Elements iterate in order by the <i>first</i> appearance of that
 * element when the multiset was created.
 *
 * <p>See the Guava User Guide article on <a href=

single process running those previous steps *even* if afterwards, you start **multiple processes** (multiple workers) for the application itself. If those steps were run by **multiple processes**, they would **duplicate** the work by running it in **parallel**, and if the steps were something delicate like a database migration, they could cause conflicts with each other.

Of course, there are some cases where there's no problem in running the previous steps multiple times, in that case, it's...

  }

  /**
   * Returns an {@code ImmutableRangeSet} representing the union of the specified ranges.
   *
   * <p>This is the smallest {@code RangeSet} which encloses each of the specified ranges. Duplicate
   * or connected ranges are permitted, and will be coalesced in the result.
   *
   * @since 21.0
   */
  public static <C extends Comparable<?>> ImmutableRangeSet<C> unionOf(Iterable<Range<C>> ranges) {

            docList.clear();
        }
    }

    /**
     * Deletes old documents that have the same URL but different document IDs
     * as the documents in the provided list. This prevents duplicate documents
     * from accumulating in the index.
     *
     * @param searchEngineClient the search engine client to use for deletion
     * @param docList the list of new documents to check against