Append data to the store.
Because ordering dictates that there only be one outstanding append from a given connection, this is implemented
by adding the append to a queue.
334922
@Override
    public void append(Append append) {
        log.trace("Processing append received from client {}", append);
        UUID id = append.getWriterId();
        synchronized (lock) {
            Long lastEventNumber = latestEventNumbers.get(Pair.of(append.getSegment(), id));
            Preconditions.checkState(lastEventNumber != null, "Data from unexpected connection: %s.", id);
            Preconditions.checkState(append.getEventNumber() >= lastEventNumber, "Event was already appended.");
            waitingAppends.put(id, append);
        }
        pauseOrResumeReading();
        performNextWrite();
    }
558255
def append(self, item):
        
        try:
            self._data[self._position] = item
        except IndexError:
            self._grow()
            self._data[self._position] = item
        self._position += 1
        return self
974859
function addToQueue(queue, packageInfo) {
  var exists;

  function matchesVersion(version, range) {
    var matches;

    try {
      matches = semver.satisfies(packageInfo.version, item.version);
    }
    catch (err) {
      matches = false;
    }

    return matches;
  }

  exists = queue.some(function(item) {
    var matches = false;

    if (item.name === packageInfo.name) {
      matches = matchesVersion(packageInfo.version, item.version);
    }

    return matches;
  });

  if (!exists) {
    queue.push(packageInfo);
  }
}
247155
def append(self, entry):
        """"""
        if not self.is_appendable(entry):
            raise ValueError('entry not appendable')
        self.data += entry.data
284059
def append(self, item: TransItem):
        

        self.data[item.key].append(item)
1329875
boolean appendRecordAndInsert(BinaryRow record, int hashCode) throws IOException {
		final int posHashCode = findBucket(hashCode);
		// get the bucket for the given hash code
		final int bucketArrayPos = posHashCode >> table.bucketsPerSegmentBits;
		final int bucketInSegmentPos = (posHashCode & table.bucketsPerSegmentMask) << BUCKET_SIZE_BITS;
		final MemorySegment bucket = this.buckets[bucketArrayPos];

		if (!table.tryDistinctBuildRow ||
				!partition.isInMemory() ||
				!findFirstSameBuildRow(bucket, hashCode, bucketInSegmentPos, record)) {
			int pointer = partition.insertIntoBuildBuffer(record);
			if (pointer != -1) {
				// record was inserted into an in-memory partition. a pointer must be inserted into the buckets
				insertToBucket(bucket, bucketInSegmentPos, hashCode, pointer, true, true);
				return true;
			} else {
				return false;
			}
		} else {
			// distinct build rows in memory.
			return true;
		}
	}
1360780
def add(self, queue_item):
        

        hash_key = queue_item.get_hash()
        items = self.__get_var("items_" + queue_item.status)

        if hash_key in items.keys():
            return

        items[queue_item.get_hash()] = queue_item

        self.count_total += 1
315485
@Override
	public Appendable append(CharSequence csq, int start, int end) {
		final int otherLen = end - start;
		grow(this.len + otherLen);
		for (int pos = start; pos < end; pos++) {
			this.value[this.len + pos] = csq.charAt(pos);
		}
		this.len += otherLen;
		return this;
	}
717674
public void append(final byte[] data, final int start, final int len) {
		final int oldLength = this.bytes.length;
		setCapacity(this.bytes.length + len, true);
		System.arraycopy(data, start, this.bytes, oldLength, len);
	}
1259297
def Append(self, item):
    
    if self._index >= self._size:
      self._index = self._index % self._size

    try:
      self._list[self._index] = item
    except IndexError:
      self._list.append(item)
    self._index += 1
9442
def addRecord(self, record):
        
        if self._destroyed:
            return
        
        if not self.uiRecordBTN.isChecked():
            return
        
        self._queue.append(record)
209868
def add_data(self, *args):
        """"""
        for data in args:
            self._data.append(to_binary(data))
96349
def append(self, data):
        
        if isinstance(data, list) and len(data) > 0:
            self.nodes.append(data)
        else:
            self.nodes.append([data])
639002
def append(self, data):
        """"""
        index = self.n_blocks # note off by one so use as index
        self[index] = data
        self.refs.append(data)
864214
async def append(self, reply: Reply) \
            -> None:
        
        result = reply.result
        identifier = result.get(f.IDENTIFIER.nm)
        txnId = result.get(TXN_ID)
        logger.debug("Reply being sent {}".format(reply))
        if self._isNewTxn(identifier, reply, txnId):
            self.addToProcessedTxns(identifier, txnId, reply)
        if identifier not in self.responses:
            self.responses[identifier] = asyncio.Queue()
        await self.responses[identifier].put(reply)
1133933
def append(label, block)
      if store.key?(label.to_sym) && store[label.to_sym].respond_to?(:<<)
        store[label.to_sym] << block
      else
        store[label.to_sym] = []
        store[label.to_sym] << block
      end
    end
1116134
function _append($data)
	{
		if (strlen($data) - 4 > $this->_limit) {
			$data = $this->_addContinue($data);
		}
		$this->_data		.= $data;
		$this->_datasize	+= strlen($data);
	}