Add an unsigned 8 byte integer field to template.

        This is an convenience method that simply calls `Uint` keyword with predefined length.
502008
def u64(self, name, value=None, align=None):
        """"""
        self.uint(8, name, value, align)
1024208
def append_var_uint32(self, value):
        
        if not 0 <= value <= wire_format.UINT32_MAX:
            raise errors.EncodeError('Value out of range: %d' % value)
        self.append_var_uint64(value)
344379
public void addField(String fieldName, String type, short flags) {
        short fieldNameIndex = itsConstantPool.addUtf8(fieldName);
        short typeIndex = itsConstantPool.addUtf8(type);
        itsFields.add(new ClassFileField(fieldNameIndex, typeIndex, flags));
    }
840010
def uint64(self, val):
        """"""
        try:
            self.msg += [pack("!Q", val)]
        except struct.error:
            raise ValueError("Expected uint64")
        return self
1147897
private void writeIntegerField(String fieldName, Object value) throws IOException
   {
      int val = ((Number) value).intValue();
      if (val != 0)
      {
         m_writer.writeNameValuePair(fieldName, val);
      }
   }
747147
public void addField(String fieldName, String type, short flags,
        int value) {
        short fieldNameIndex = itsConstantPool.addUtf8(fieldName);
        short typeIndex = itsConstantPool.addUtf8(type);
        ClassFileField field = new ClassFileField(fieldNameIndex, typeIndex,
            flags);
        field.setAttributes(itsConstantPool.addUtf8("ConstantValue"),
            (short) 0,
            (short) 0,
            itsConstantPool.addConstant(value));
        itsFields.add(field);
    }
61576
def uint32_to_uint8(cls, img):
        
        return np.flipud(img.view(dtype=np.uint8).reshape(img.shape + (4,)))
100115
def _uint2objs(ftype, num, length=None):
    """"""
    if num == 0:
        objs = [ftype.box(0)]
    else:
        _num = num
        objs = list()
        while _num != 0:
            objs.append(ftype.box(_num & 1))
            _num >>= 1

    if length:
        if length < len(objs):
            fstr = "overflow: num = {} requires length >= {}, got length = {}"
            raise ValueError(fstr.format(num, len(objs), length))
        else:
            while len(objs) < length:
                objs.append(ftype.box(0))

    return objs
259866
public void addUnsignedShort( int value ) {

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

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

        length += 2;


    }
846725
def get_uint8(self):
        

        value = self.get_int()
        if value < 0 or value > 255:
            raise dns.exception.SyntaxError('%d is not an unsigned 8-bit integer' % value)
        return value
423790
def write_int(self, value):
        """"""
        format = '!I'
        self.data.append(struct.pack(format, int(value)))
        self.size += 4
1008215
@Override
  public void add(int value) {
    int key = toIntUnsigned(highbits(value));
    if (key != currentKey) {
      if (key < currentKey) {
        underlying.add(value);
        return;
      } else {
        appendToUnderlying();
        currentKey = key;
      }
    }
    C tmp = container.add(lowbits(value));
    if (tmp != container) {
      container = tmp;
    }
  }
1160074
def append_little_endian64(self, unsigned_value):
        
        if not 0 <= unsigned_value <= wire_format.UINT64_MAX:
            raise errors.EncodeError(
                'Unsigned 64-bit out of range: %d' % unsigned_value)
        self.append_raw_bytes(struct.pack(
            wire_format.FORMAT_UINT64_LITTLE_ENDIAN, unsigned_value))
115183
function insertIntegerToByteArray (number, buffer, from, size) {
  let value = bigInt(number) // convert a number-like object into a big integer

  for (let pos = 0; pos < size; pos++) {
    const divmod = value.divmod(256)
    buffer[from + pos] = divmod.remainder.toJSNumber()
    value = divmod.quotient
  }

  return buffer
}
254445
async def uint(self, elem, elem_type, params=None):
        
        if self.writing:
            return IntegerModel(elem, elem_type.WIDTH) if self.modelize else elem
        else:
            return elem.val if isinstance(elem, IModel) else elem
1006648
def bin(self, size, name, value=None):
        
        self._add_field(Binary(size, name, value))
1259090
def _send_unsigned_long(self,value):
        

        # Coerce to int. This will throw a ValueError if the value can't 
        # actually be converted.
        if type(value) != int:
            new_value = int(value)

            if self.give_warnings:
                w = "Coercing {} into int ({})".format(value,new_value)
                warnings.warn(w,Warning)
                value = new_value

        # Range check
        if value > self.board.unsigned_long_max or value < self.board.unsigned_long_min:
            err = "Value {} exceeds the size of the board's unsigned long.".format(value)
            raise OverflowError(err)
          
        return struct.pack(self.board.unsigned_long_type,value)