Java Code Examples for java.nio.ByteBuffer#getDouble()

public static int binarySearchDoubles(ByteBuffer buffer, int count, double key) {
    int from = 0;
    int to = count;

    --to;

    while (from <= to) {
        int mid = from + to >>> 1;
        double midVal = buffer.getDouble(mid << 3);
        if (midVal < key) {
            from = mid + 1;
        } else if (midVal > key) {
            to = mid - 1;
        } else {
            return mid;
        }
    }

    return -(from + 1);
}
 

static PartitionMetric fromBuffer(ByteBuffer buffer) throws UnknownVersionException {
  byte version = buffer.get();
  if (version > METRIC_VERSION) {
    throw new UnknownVersionException("Cannot deserialize the topic metrics for version " + version + ". "
                                          + "Current version is " + METRIC_VERSION);
  }
  RawMetricType rawMetricType = RawMetricType.forId(buffer.get());
  long time = buffer.getLong();
  int brokerId = buffer.getInt();
  int topicLength = buffer.getInt();
  String topic = new String(buffer.array(), buffer.arrayOffset() + buffer.position(), topicLength, StandardCharsets.UTF_8);
  buffer.position(buffer.position() + topicLength);
  int partition = buffer.getInt();
  double value = buffer.getDouble();
  return new PartitionMetric(rawMetricType, time, brokerId, topic, partition, value);
}
 

public double[] readDoubleArrayBE(int numValues) throws IOException {
    int numBytesRead = fillBuffer(numValues * 8);
    if (numBytesRead < numValues * 8) {
        throw new EOFException(
                String.format("Cannot read double array (shortage): expected = %d, actual = %d",
                        numValues * 8, numBytesRead));
    }

    ByteBuffer byteBuffer = ByteBuffer.wrap(buffer).order(ByteOrder.BIG_ENDIAN);

    double[] result = new double[numValues];
    for (int i = 0; i < numValues; i++) {
        result[i] = byteBuffer.getDouble();
    }

    return result;
}
 

/**
 * Reads an 8-byte little endian double.
 */
public double readDouble() throws IOException {
	byte[] bytes = new byte[8];
	this.reader.readFully(bytes);
	ByteBuffer bb = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
	return bb.getDouble();
}
 

@Override
public void fromBinary(final byte[] bytes) {
  final ByteBuffer b = ByteBuffer.wrap(bytes);
  count = VarintUtils.readUnsignedLong(b);
  x = b.getDouble();
  y = b.getDouble();
  z = b.getDouble();
  distance = b.getDouble();
  int i = VarintUtils.readUnsignedInt(b);
  values = new double[i];
  for (; i > 0; i--) {
    values[i - 1] = b.getDouble();
  }
}
 

static BrokerMetric fromBuffer(ByteBuffer buffer) throws UnknownVersionException {
  byte version = buffer.get();
  if (version > METRIC_VERSION) {
    throw new UnknownVersionException("Cannot deserialize the topic metrics for version " + version + ". "
                                          + "Current version is " + METRIC_VERSION);
  }
  RawMetricType rawMetricType = RawMetricType.forId(buffer.get());
  long time = buffer.getLong();
  int brokerId = buffer.getInt();
  double value = buffer.getDouble();
  return new BrokerMetric(rawMetricType, time, brokerId, value);
}
 

public static Object readObject(ByteBuffer buffer) {
  ClassSerializeId serializeId = ClassSerializeId.values()[buffer.get()];
  switch (serializeId) {
    case BOOLEAN:
      return buffer.get() == 1;
    case FLOAT:
      return buffer.getFloat();
    case DOUBLE:
      return buffer.getDouble();
    case LONG:
      return buffer.getLong();
    case INTEGER:
      return buffer.getInt();
    case BINARY:
      int length = buffer.getInt();
      byte[] bytes = new byte[length];
      buffer.get(bytes);
      return new Binary(bytes);
    case NULL:
      return null;
    case STRING:
    default:
      length = buffer.getInt();
      bytes = new byte[length];
      buffer.get(bytes);
      return new String(bytes);
  }
}
 

public double readNumber() {
    if (buffer[offset] != 0x00) {
        throw new IllegalArgumentException("Number type ID (0x00) expected.");
    }
    offset++;
    ByteBuffer bb = ByteBuffer.wrap(buffer, offset, 8);
    double result = bb.getDouble();
    offset += 8;
    return result;
}
 

@Override
public void fromBinary(final byte[] bytes) {
  final ByteBuffer buf = ByteBuffer.wrap(bytes);
  final int length = bytes.length / 8;
  resolutionPerDimension = new double[length];
  for (int i = 0; i < length; i++) {
    resolutionPerDimension[i] = buf.getDouble();
  }
}
 

/**
 * Decodes a byte array into a float value.
 */
public static Number decodeFloat(byte[] value) throws TlvException {
    ByteBuffer floatBb = ByteBuffer.wrap(value);
    if (value.length == 4) {
        return floatBb.getFloat();
    } else if (value.length == 8) {
        return floatBb.getDouble();
    } else {
        throw new TlvException("Invalid length for a float value: " + value.length);
    }
}
 

void getOne(ByteBuffer b, PrimitiveType t, int index) {
    switch (t) {
    case BYTE: b.get(index); break;
    case CHAR: b.getChar(index); break;
    case SHORT: b.getShort(index); break;
    case INT: b.getInt(index); break;
    case LONG: b.getLong(index); break;
    case FLOAT: b.getFloat(index); break;
    case DOUBLE: b.getDouble(index); break;
    }
}
 

public static DataBuffer createFromByteBuffer(ByteBuffer bb,int bb_pos,DataBuffer.Type type,int length,int elementSize) {
    bb.order(ByteOrder.LITTLE_ENDIAN);
    DataBuffer ret = Nd4j.createBuffer(ByteBuffer.allocateDirect(length *   elementSize),type,length,0);
    switch(type) {
        case DOUBLE:
            for(int i = 0; i < ret.length(); i++) {
                double doubleGet = bb.getDouble(bb.capacity() - bb_pos + (i * elementSize));
                ret.put(i,doubleGet);
            }
            break;
        case FLOAT:
            for(int i = 0; i < ret.length(); i++) {
                float floatGet = bb.getFloat(bb.capacity() - bb_pos + (i * elementSize));
                ret.put(i,floatGet);
            }
            break;
        case INT:
            for(int i = 0; i < ret.length(); i++) {
                int intGet = bb.getInt(bb.capacity() - bb_pos  + (i * elementSize));
                ret.put(i,intGet);
            }
            break;
        case LONG:
            for(int i = 0; i < ret.length(); i++) {
                long longGet = bb.getLong(bb.capacity() - bb_pos  + (i * elementSize));
                ret.put(i,longGet);
            }
            break;
    }

    return ret;
}
 

private static VectorLayer readPolylineShapes(DataInputStream br, int shapeNum) throws IOException {
    VectorLayer aLayer = new VectorLayer(ShapeTypes.Polyline);
    int RecordNum, ContentLength, aShapeType;
    double x, y;
    byte[] bytes;
    ByteBuffer buffer;
    
    //PointD aPoint;
    for (int i = 0; i < shapeNum; i++) {
        bytes = new byte[8];
        br.read(bytes);
        buffer = ByteBuffer.wrap(bytes);
        //br.skipBytes(12); 
        buffer.order(ByteOrder.BIG_ENDIAN);
        RecordNum = buffer.getInt();
        ContentLength = buffer.getInt();
        
        bytes = new byte[ContentLength * 2];
        br.read(bytes);
        buffer = ByteBuffer.wrap(bytes);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        aShapeType = buffer.getInt();

        PolylineShape aPL = new PolylineShape();
        Extent extent = new Extent();
        extent.minX = buffer.getDouble();
        extent.minY = buffer.getDouble();
        extent.maxX = buffer.getDouble();
        extent.maxY = buffer.getDouble();
        aPL.setExtent(extent);

        aPL.setPartNum(buffer.getInt());
        int numPoints = buffer.getInt();
        aPL.parts = new int[aPL.getPartNum()];
        List<PointD> points = new ArrayList<>();

        //firstly read out parts begin pos in file 
        for (int j = 0; j < aPL.getPartNum(); j++) {
            aPL.parts[j] = buffer.getInt();
        }

        //read out coordinates 
        for (int j = 0; j < numPoints; j++) {
            x = buffer.getDouble();
            y = buffer.getDouble();
            PointD aPoint = new PointD();
            aPoint.X = x;
            aPoint.Y = y;
            points.add(aPoint);
        }
        aPL.setPoints(points);
        aLayer.addShape(aPL);
    }

    //Create legend scheme            
    aLayer.setLegendScheme(LegendManage.createSingleSymbolLegendScheme(ShapeTypes.Polyline, Color.darkGray, 1.0F));

    return aLayer;
}
 

@Override
public Double getFromBuffer(ByteBuffer byteBuffer) {
  return byteBuffer.getDouble();
}
 

@Nonnull
public static MinMaxRangePair fromByteBuffer(ByteBuffer byteBuffer) {
  return new MinMaxRangePair(byteBuffer.getDouble(), byteBuffer.getDouble());
}
 

public static double byteArrayToDouble(byte[] data) {
	ByteBuffer byteBuffer = ByteBuffer.wrap(data);
	return byteBuffer.getDouble();
}
 

public static double toDouble(ByteBuffer bytes) {
    return bytes.getDouble(bytes.position());
}
 

@Override
public Double deserialize(ByteBuffer in) {
    return in.getDouble();
}
 

/**
 * Create by decoding the value from the given buffer
 *
 * @param src buffer where the value is stored
 **/
DoubleValue(ByteBuffer src) {
    value = src.getDouble();
}
 

/**
 * Convert a byte array to an double (little endian).
 * 
 * @param data the byte array to convert.
 * @return the double.
 */
public static double byteArrayToDoubleLE( byte[] data ) {
    ByteBuffer buffer = ByteBuffer.wrap(data);
    buffer.order(ByteOrder.LITTLE_ENDIAN);
    return buffer.getDouble();
}