Java UnsignedInts.toLong方法代码示例

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
@Override
protected void handleValidStoreMsg(PB.DHTTopLevelMsg.Builder topLevelResponseMsg, PB.DHTStoreValueMsg storeValueMsg) throws Exception {
  if(storeValueMsg.hasSignature()==false){
    throw new Exception("The store message "+storeValueMsg+" does not have a signature");
  }
  if(storeValueMsg.hasKey()==false){
    throw new Exception("The store message "+storeValueMsg+" does not have a key");
  }
  if(storeValueMsg.hasValue()==false){
    throw new Exception("The store message "+storeValueMsg+" does not have a value");
  }
  final byte[] key=storeValueMsg.getKey().toByteArray();
  final byte[] value=storeValueMsg.getValue().toByteArray();
  if(key.length!=32){
    throw new Exception("The store message "+storeValueMsg+" does not have a key of proper length");
  }
  if(storeValueMsg.hasNonce()==false){
    throw new Exception("Nonce is missing "+storeValueMsg);
  }
  final long nonceInMessage=UnsignedInts.toLong(storeValueMsg.getNonce());

  if(isTransactionValid(storeValueMsg)){
    storeKeyValue(key, value, nonceInMessage);
  }
  //TODO Add status message?
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
protected UserEventRecord parseRecord(byte[] recordBytes, DatabasePageHeader header,
                                      long recordNumber) throws IOException {
  DataInput input = this.dataInputFactory.create(new ByteArrayInputStream(recordBytes));
  LOGGER.debug(format("Parsing user event record from bytes [%s]...", toHexString(recordBytes)));

  long systemSeconds = UnsignedInts.toLong(input.readInt());
  long displaySeconds = UnsignedInts.toLong(input.readInt());
  UserEventRecord.UserEventType eventType = UserEventRecord.UserEventType.fromId(input.readByte());
  byte eventSubType = input.readByte();
  long eventLocalTimeInSeconds = UnsignedInts.toLong(input.readInt());
  long eventValue = UnsignedInts.toLong(input.readInt());
  int actualReceiverCrc = input.readUnsignedShort();

  validateCrc(actualReceiverCrc, recordBytes);

  UserEventRecord userEventRecord = new UserEventRecord(systemSeconds, displaySeconds,
      eventLocalTimeInSeconds, eventType, eventSubType, eventValue);
  LOGGER.debug(format("Parsed UserEventRecord: [%s]", userEventRecord));

  return userEventRecord;
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
public List<ManufacturingParameters> getManufacturingParameters() {
  List<ManufacturingParameters> manufacturingParameters = newArrayList();
  try {
    for (DatabasePage page : getPages()) {
      ByteArrayInputStream inputStream = new ByteArrayInputStream(page.getPageData());
      DataInput input = this.dataInputFactory.create(inputStream);
      // TODO: something better than ignoring the data?
      long systemSeconds = UnsignedInts.toLong(input.readInt());
      long displaySeconds = UnsignedInts.toLong(input.readInt());

      byte[] xmlBytes = new byte[inputStream.available() - 2];
      input.readFully(xmlBytes);

      validateCrc(input.readUnsignedShort(), page.getPageData());

      XmlMapper xmlMapper = new XmlMapper();
      ManufacturingParameters parameterPage = xmlMapper.readValue(new String(xmlBytes, "UTF-8"),
              ManufacturingParameters.class);
      manufacturingParameters.add(parameterPage);
    }
    return manufacturingParameters;
  } catch (IOException e) {
    throw Throwables.propagate(e);
  }
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
protected GlucoseReadRecord parseRecord(byte[] recordBytes, DatabasePageHeader header,
                                      long recordNumber) throws IOException {
  DataInput input = this.dataInputFactory.create(new ByteArrayInputStream(recordBytes));
  LOGGER.debug(format("Parsing glucose record from bytes [%s]", toHexString(recordBytes)));

  long systemSeconds = UnsignedInts.toLong(input.readInt());
  long displaySeconds = UnsignedInts.toLong(input.readInt());
  int glucoseValueWithFlags = input.readUnsignedShort();
  byte trendAndArrowNoise = input.readByte();
  int actualReceiverCrc = input.readUnsignedShort();

  validateCrc(actualReceiverCrc, recordBytes);

  GlucoseReadRecord glucoseReadRecord = new GlucoseReadRecord(systemSeconds, displaySeconds,
          glucoseValueWithFlags, trendAndArrowNoise, recordNumber, header.getPageNumber());
  LOGGER.debug(format("Parsed GlucoseRead: [%s]", glucoseReadRecord));

  return glucoseReadRecord;
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
public static boolean checkChecksum(byte[] bytes) {
    if ((bytes == null) || (bytes.length < 4)) return false;
    final CRC32 crc = new CRC32();
    crc.update(bytes, 0, bytes.length - 4);
    final long buffer_crc = UnsignedInts.toLong(ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).getInt(bytes.length - 4));
    return buffer_crc == crc.getValue();
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
/** The entry data. */
public byte[] data() {
  // Read the offset and variable lengths from the central directory and then try to map in the
  // data section in one shot.
  long offset = UnsignedInts.toLong(cd.getInt(cdindex + CENOFF));
  int nameLength = cd.getChar(cdindex + CENNAM);
  int extLength = cd.getChar(cdindex + CENEXT);
  int compression = cd.getChar(cdindex + CENHOW);
  switch (compression) {
    case 0x8:
      return getBytes(
          offset,
          nameLength,
          extLength,
          UnsignedInts.toLong(cd.getInt(cdindex + CENSIZ)),
          /*deflate=*/ true);
    case 0x0:
      return getBytes(
          offset,
          nameLength,
          extLength,
          UnsignedInts.toLong(cd.getInt(cdindex + CENLEN)),
          /*deflate=*/ false);
    default:
      throw new AssertionError(
          String.format("unsupported compression mode: 0x%x", compression));
  }
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
@Override
public PartitionOwner getPartitionOwner(I vertexId) {
  long unsignedHashCode = UnsignedInts.toLong(vertexId.hashCode());
  // The reader can verify that unsignedHashCode of HASH_LIMIT - 1 yields
  // index of size - 1, and unsignedHashCode of 0 yields index of 0.
  int index = (int)
      ((unsignedHashCode * getPartitionOwners().size()) / HASH_LIMIT);
  return partitionOwnerList.get(index);
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
@Override
public void fromBytes(byte[] responseAsBytes) {
  super.fromBytes(responseAsBytes);
  try {
    DataInput dataInput = dataInputFactory.create(new ByteArrayInputStream(responseAsBytes));
    this.firstPage = UnsignedInts.toLong(dataInput.readInt());
    this.lastPage = UnsignedInts.toLong(dataInput.readInt());

  } catch (IOException e) {
    throw Throwables.propagate(e);
  }
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
private DatabasePageHeader readPageHeader(byte[] headerBytes) {
  try {
    DataInput dataInput = this.dataInputFactory.create(new ByteArrayInputStream(headerBytes));

    long firstRecordIndex = UnsignedInts.toLong(dataInput.readInt());
    long numberOfRecords = UnsignedInts.toLong(dataInput.readInt());
    RecordType recordType = RecordType.fromId(dataInput.readByte());
    byte revision = dataInput.readByte();
    long pageNumber = UnsignedInts.toLong(dataInput.readInt());
    long reserved2 = UnsignedInts.toLong(dataInput.readInt());
    long reserved3 = UnsignedInts.toLong(dataInput.readInt());
    long reserved4 = UnsignedInts.toLong(dataInput.readInt());
    int crc = dataInput.readUnsignedShort();

    int expectedCrc = DecodingUtils.getCrc16(headerBytes, 0, PAGE_HEADER_SIZE - 2);

    if (crc != expectedCrc) {
      throw new IllegalStateException(format("Invalid crc, expected [%s], received [%s]",
              Integer.toHexString(expectedCrc), Integer.toHexString(crc)));
    }

    return new DatabasePageHeader(firstRecordIndex, numberOfRecords, recordType, revision,
            pageNumber, reserved2, reserved3, reserved4, crc);

  } catch (IOException e) {
    throw Throwables.propagate(e);
  }
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
@Override
public long padToLong() {
  return UnsignedInts.toLong(hash);
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
public ZipIterable(Path path) throws IOException {
  this.path = path;
  this.chan = FileChannel.open(path, StandardOpenOption.READ);
  // Locate the EOCD
  long size = chan.size();
  if (size < ENDHDR) {
    throw new ZipException("invalid zip archive");
  }
  long eocdOffset = size - ENDHDR;
  MappedByteBuffer eocd = chan.map(MapMode.READ_ONLY, eocdOffset, ENDHDR);
  eocd.order(ByteOrder.LITTLE_ENDIAN);
  int index = 0;
  int commentSize = 0;
  if (!isSignature(eocd, 0, 5, 6)) {
    // The archive may contain a zip file comment; keep looking for the EOCD.
    long start = Math.max(0, size - ENDHDR - 0xFFFF);
    eocd = chan.map(MapMode.READ_ONLY, start, (size - start));
    eocd.order(ByteOrder.LITTLE_ENDIAN);
    index = (int) ((size - start) - ENDHDR);
    while (index > 0) {
      index--;
      eocd.position(index);
      if (isSignature(eocd, index, 5, 6)) {
        commentSize = (int) ((size - start) - ENDHDR) - index;
        eocdOffset = start + index;
        break;
      }
    }
  }
  checkSignature(path, eocd, index, 5, 6, "ENDSIG");
  int totalEntries = eocd.getChar(index + ENDTOT);
  long cdsize = UnsignedInts.toLong(eocd.getInt(index + ENDSIZ));
  int actualCommentSize = eocd.getChar(index + ENDCOM);
  if (commentSize != actualCommentSize) {
    throw new ZipException(
        String.format(
            "zip file comment length was %d, expected %d", commentSize, actualCommentSize));
  }
  // If the number of entries is 0xffff, check if the archive has a zip64 EOCD locator.
  if (totalEntries == ZIP64_MAGICCOUNT) {
    // Assume the zip64 EOCD has the usual size; we don't support zip64 extensible data sectors.
    long zip64eocdOffset = size - ENDHDR - ZIP64_LOCHDR - ZIP64_ENDHDR;
    MappedByteBuffer zip64eocd = chan.map(MapMode.READ_ONLY, zip64eocdOffset, ZIP64_ENDHDR);
    zip64eocd.order(ByteOrder.LITTLE_ENDIAN);
    // Note that zip reading is necessarily best-effort, since an archive could contain 0xFFFF
    // entries and the last entry's data could contain a ZIP64_ENDSIG. Some implementations
    // read the full EOCD records and compare them.
    if (zip64eocd.getInt(0) == ZIP64_ENDSIG) {
      cdsize = zip64eocd.getLong(ZIP64_ENDSIZ);
      eocdOffset = zip64eocdOffset;
    }
  }
  this.cd = chan.map(MapMode.READ_ONLY, eocdOffset - cdsize, cdsize);
  cd.order(ByteOrder.LITTLE_ENDIAN);
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
private long readUnsignedInt() throws IOException {
    return UnsignedInts.toLong(mInput.readInt());
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
public long getEntryTime(ClockType clockType, TimeUnit units) {
    long entryTime = clockType == ClockType.THREAD ?
            UnsignedInts.toLong(mEntryThreadTime) : UnsignedInts.toLong(mEntryGlobalTime);
    return units.convert(entryTime, VmTraceData.getDefaultTimeUnits());
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
public long getExitTime(ClockType clockType, TimeUnit units) {
    long exitTime = clockType == ClockType.THREAD ?
            UnsignedInts.toLong(mExitThreadTime) : UnsignedInts.toLong(mExitGlobalTime);
    return units.convert(exitTime, VmTraceData.getDefaultTimeUnits());
}
 

import com.google.common.primitives.UnsignedInts; //导入方法依赖的package包/类
public long getInclusiveTime(ClockType clockType, TimeUnit units) {
    long inclusiveTime = clockType == ClockType.THREAD ?
            UnsignedInts.toLong(mExitThreadTime - mEntryThreadTime) :
            UnsignedInts.toLong(mExitGlobalTime - mEntryGlobalTime);
    return units.convert(inclusiveTime, VmTraceData.getDefaultTimeUnits());
}