sync.Mutex
}

// BatchConfig represents the batch config
type BatchConfig[I any] struct {
	Limit         uint32
	Store         Store[I]
	CommitTimeout time.Duration
	Log           logger
}

// Add adds the item to the batch
func (b *Batch[I]) Add(item I) error {
	b.Lock()
	defer b.Unlock()

	if b.isFull() {
		if b.store == nil {
			return ErrBatchFull
		}
		// commit batch to store

    Builder(int capacity, boolean makeHashTable) {
      super(capacity);
      if (makeHashTable) {
        this.hashTable = new @Nullable Object[chooseTableSize(capacity)];
      }
    }

    /**
     * Adds {@code element} to the {@code ImmutableSet}. If the {@code ImmutableSet} already
     * contains {@code element}, then {@code add} has no effect (only the previously added element
     * is retained).
     *

     * @param id The identifier of the profile.
     */
    public void deactivateOptionalProfile(String id) {
        this.activations.put(id, ActivationSettings.deactivatedOpt());
    }

    /**
     * Adds a profile activation to the request.
     * @param id The identifier of the profile.
     * @param active Should the profile be activated?
     * @param optional Can the build continue if the profile does not exist?
     */

	TotalRequests  int64
	FailedRequests int64
}

// TargetList - holds list of targets indexed by target ID.
type TargetList struct {
	sync.RWMutex
	targets map[TargetID]Target
}

// Add - adds unique target to target list.
func (list *TargetList) Add(targets ...Target) error {
	list.Lock()
	defer list.Unlock()

	for _, target := range targets {
		if _, ok := list.targets[target.ID()]; ok {

			c.onEvict(k, v.Value)
		}
		delete(c.items, k)
	}
	for _, b := range c.buckets {
		for _, ent := range b.entries {
			delete(b.entries, ent.Key)
		}
	}
	c.evictList.Init()
}

// Add adds a value to the cache. Returns true if an eviction occurred.
// Returns false if there was no eviction: the item was already in the cache,
// or the size was not exceeded.
func (c *LRU[K, V]) Add(key K, value V) (evicted bool) {

* x[1] MUL x1, x2, t0 ADDS t0, acc3 UMULH x1, x2, t1 ADCS t1, acc4 ADC $0, ZR, acc5 MUL x1, x3, t0 ADDS t0, acc4 UMULH x1, x3, t1 ADC t1, acc5 // x[3] * x[2] MUL x2, x3, t0 ADDS t0, acc5 UMULH x2, x3, acc6 ADC $0, acc6 MOVD $0, acc7 // *2 ADDS acc1, acc1 ADCS acc2, acc2 ADCS acc3, acc3 ADCS acc4, acc4 ADCS acc5, acc5 ADCS acc6, acc6 ADC $0, acc7 // Missing products MUL x0, x0, acc0 UMULH x0, x0, t0 ADDS t0, acc1, acc1 MUL x1, x1, t0 ADCS t0, acc2, acc2 UMULH x1, x1, t1 ADCS t1, acc3, acc3 MUL x2,...

# Dex Quickstart Guide [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)

      double prev = 0.0;
      for (double x : VALUES) {
        assertBitEquals(prev, aa.getAndSet(i, x));
        prev = x;
      }
    }
  }

  /** getAndAdd returns previous value and adds given value */
  public void testGetAndAdd() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i : new int[] {0, SIZE - 1}) {
      for (double x : VALUES) {
        for (double y : VALUES) {

    exec.shutdown();
    exec.awaitTermination(100, MILLISECONDS);
  }

  /**
   * Tests that all listeners complete, even if they were added before or after the future was
   * finishing. Also acts as a concurrency test to make sure the locking is done correctly when a
   * future is finishing so that no listeners can be lost.
   */
  public void testAllListenersCompleteSuccessfully()

     * Gets the map of display keys to query strings.
     *
     * @return the query map
     */
    public Map<String, String> getQueryMap() {
        return queryMap;
    }

    /**
     * Adds a query to the query map with the specified display key.
     *
     * @param key the display key for the query
     * @param query the query string to add
     */