Adds the int to the digest.
496733
private static long addDigest(long digest, long v)
  {
    digest = Crc64.generate(digest, (byte) (v >> 24));
    digest = Crc64.generate(digest, (byte) (v >> 16));
    digest = Crc64.generate(digest, (byte) (v >> 8));
    digest = Crc64.generate(digest, (byte) v);

    return digest;
  }
520802
public void addAll(IntBitSet set) {
        int i;

        if (set.data.length > data.length) {
            resize(set.data.length);
        }

        for (i = 0; i < set.data.length; i++) {
            data[i] |= set.data[i];
        }
    }
337063
public boolean addAll(CompactIntSet ints) {
        int oldSize = size();
        bitSet.or(ints.bitSet);
        return oldSize != size();
    }
1127693
public DynamicByteBuffer addUnsignedInt( long value ) {

        if ( 4 + length < capacity ) {
            DynamicByteBufferHelper.unsignedIntTo( buffer, length, value );
        } else {
            buffer = DynamicByteBufferHelper.grow( buffer, buffer.length * 2 + 4 );
            capacity = buffer.length;

            DynamicByteBufferHelper.unsignedIntTo( buffer, length, value );
        }

        length += 4;
        return this;

    }
631611
public void put(int index, long value) {
        if(desc.get(index) != Cursor.FIELD_TYPE_INTEGER) {
            throw new IllegalArgumentException("Inserting an integer, but expecting " + getTypeName(desc.get(index)));
        }
        this.values.add(index, value);
    }
1194661
def measure_int_put(self, measure, value):
        """"""
        if value < 0:
            # Should be an error in a later release.
            logger.warning("Cannot record negative values")
        self._measurement_map[measure] = value
294763
public function init()
    {
        $digest = $this->getDigest();
        $this->digestParts = $this->parseDigest((string) $digest);
    }
253961
public void addAll(IntCounter<E> counter) {
    for (E key : counter.keySet()) {
      int count = counter.getIntCount(key);
      incrementCount(key, count);
    }
  }
1294998
public void add(long value) {
		int index = Arrays.binarySearch(bins, value);
		if (index < 0) {
			// inexact match, take the first bin higher than value
			index = -index - 1;
		}
		hits.incrementAndGet(index);
	}
1215951
def add(self,  i, val):
        
        assert i > 0
        while i < len(self.s):
            self.s[i] += val
            i += (i & -i)
963418
public KeyVerifyParameters withDigest(byte[] digest) {
        if (digest == null) {
            this.digest = null;
        } else {
            this.digest = Base64Url.encode(digest);
        }
        return this;
    }
1217153
private static void updateLengthAndBytes(MessageDigest digest, ByteBuffer binaryValue) {
        ByteBuffer readOnlyBuffer = binaryValue.asReadOnlyBuffer();
        int size = readOnlyBuffer.remaining();
        ByteBuffer lengthBytes = ByteBuffer.allocate(INTEGER_SIZE_IN_BYTES).putInt(size);
        digest.update(lengthBytes.array());
        digest.update(readOnlyBuffer);
    }
196507
public void add(int offset, byte []buffer, int bufOffset, int length)
  {
    insertCode(offset, length);
    
    _code.set(offset, buffer, bufOffset, length);
  }
61087
public IntegerConstant addInteger(int value)
  {
    IntegerConstant entry = getIntegerByValue(value);

    if (entry != null)
      return entry;

    entry = new IntegerConstant(this, _entries.size(), value);

    addConstant(entry);

    return entry;
  }
518401
function addInt(x, n) {
  var ans=expand(x, x.length+1);
  addInt_(ans, n);
  return trim(ans, 1);
}
1028780
public void addByte(int b)
    throws IOException
  {
    int nextHead = (_byteHead + 1) % _byteBuffer.length;

    while (nextHead == _byteTail) {
      int ch = readChar();

      if (ch < 0) {
        break;
      }

      outputChar(ch);
    }

    _byteBuffer[_byteHead] = (byte) b;
    _byteHead = nextHead;
  }
1020062
public static int writeInt(byte[] target, int offset, int value) {
        target[offset] = (byte) (value >>> 24);
        target[offset + 1] = (byte) (value >>> 16);
        target[offset + 2] = (byte) (value >>> 8);
        target[offset + 3] = (byte) value;
        return Integer.BYTES;
    }