Java Code Examples for com.esotericsoftware.kryo.io.Input#readLong()

private PSTreeNode(final Kryo kryo, final Input input) {
    final boolean oldReferences = kryo.getReferences();
    kryo.setReferences(false);

    name = input.readString();
    rank = input.readString();
    parent = input.readInt();
    length = input.readLong();
    final int numChildren = input.readInt();
    children = new HashSet<>(numChildren);
    for (int i = 0; i < numChildren; i++) {
        children.add(Integer.valueOf(input.readString()));
    }

    kryo.setReferences(oldReferences);
}
 

public ArrayMetaData<long[]> read(Kryo kryo, Input input, Class<ArrayMetaData<long[]>> type) {
    try {
        long[] arrData = arrayMetaData.getArrData();
        thatArrMetaData = arrayMetaData.recv(input);
        int arrSegNum = thatArrMetaData.getSegNum();
        for (int i = 0; i < arrSegNum; i++) {
            int from = thatArrMetaData.getFrom(i);
            int to = thatArrMetaData.getTo(i);
            for (int j = from; j < to; j++) {
                arrData[j] = input.readLong();
            }
        }
        thatArrMetaData.setArrData(arrData);
    } catch (IOException e) {
        LOG.error("double array read exception", e);
        System.exit(1);
    }
    return thatArrMetaData;

}
 

@SuppressWarnings("unchecked")
@Override
protected Feature readObject(Kryo kryo, Input input, Class<Feature> clas, long requestId, String streamId, long sequenceNr) throws Exception {
	String name = input.readString();
	long duration = input.readLong();
	List<Descriptor> sparseDescriptors = kryo.readObject(input, ArrayList.class);
	
		int xl = input.readInt();
		float[][][] denseDescriptor = null;
		if(xl > 0){
			int yl = input.readInt();
			int zl = input.readInt();
			denseDescriptor = new float[xl][yl][zl];
			for(int x=0; x<xl; x++){
				for(int y=0; y<yl; y++){
					for(int z=0; z<zl; z++){
						denseDescriptor[x][y][z] = input.readFloat();
					}
				}
			}
		}
	
	Feature feature = new Feature(streamId, sequenceNr, name, duration, sparseDescriptors, denseDescriptor);
	feature.setRequestId(requestId);
	return feature;
}
 

@SuppressWarnings("unchecked")
@Override
public Type read(Kryo kryo, Input input, Class<Type> clas) {
	long requestId = input.readLong();
	String streamId = input.readString();
	long sequenceNr = input.readLong();
	HashMap<String, Object> metadata = kryo.readObject(input, HashMap.class);
	try {
		Type result = readObject(kryo, input, clas, requestId, streamId, sequenceNr);
		result.setMetadata(metadata);
		return result;
	} catch (Exception e) {
		//TODO
	}
	return null;
}
 

@Override
public DefaultPort read(Kryo kryo, Input input, Class<DefaultPort> aClass) {
    Element element = (Element) kryo.readClassAndObject(input);
    PortNumber number = kryo.readObject(input, PortNumber.class);
    boolean isEnabled = input.readBoolean();
    Port.Type type = kryo.readObject(input, Port.Type.class);
    long portSpeed = input.readLong();
    Annotations annotations = (Annotations) kryo.readClassAndObject(input);

    return new DefaultPort(element, number, isEnabled, type, portSpeed, annotations);
}
 

@Override
public Pair read(Kryo kryo, Input input, Class<Pair> arg2) {
    
    long value = input.readLong();
    String key = input.readString();
    Pair inner = new Pair();
    inner.setKey(key);
    inner.setValue(value);
    return inner;
}
 

private CDF( final Kryo kryo, final Input input ) {
    final int len = input.readInt();
    cdfFractions = new float[len];
    for ( int idx = 0; idx != len; ++idx ) {
        cdfFractions[idx] = input.readFloat();
    }
    nCounts = input.readLong();
}
 

@Override
public ComputeContentEvent read(Kryo kryo, Input input,
		Class<ComputeContentEvent> type) {
	long splitId = input.readLong(true);
	long learningNodeId = input.readLong(true);
	
	int dataLength = input.readInt(true);
	double[] preSplitDist = new double[dataLength];
	
	for(int i = 0; i < dataLength; i++){
		preSplitDist[i] = input.readDouble(PRECISION, true);
	}
	
	return new ComputeContentEvent(splitId, learningNodeId, preSplitDist);
}
 

private IntHistogram( final Kryo kryo, final Input input ) {
    final int len = input.readInt();
    counts = new long[len];
    long total = 0L;
    for ( int idx = 0; idx != len; ++idx ) {
        final long val = input.readLong();
        final double idxSum = val * idx;
        total += val;
        counts[idx] = val;
    }
    totalObservations = total;
}
 

@Override
public TradeCustomer read(Kryo kryo, Input input, Class<TradeCustomer> arg2) {
    
    Pair custormer = kryo.readObject(input, Pair.class);
    Pair trade = kryo.readObject(input, Pair.class);
    
    long timeStamp = input.readLong();
    String buffer = input.readString();
    
    TradeCustomer inner = new TradeCustomer(timeStamp, trade, custormer, buffer);
    return inner;
}
 

@Override
public ComputeContentEvent read(Kryo kryo, Input input,
    Class<ComputeContentEvent> type) {
  long splitId = input.readLong(true);
  long learningNodeId = input.readLong(true);

  int dataLength = input.readInt(true);
  double[] preSplitDist = new double[dataLength];

  for (int i = 0; i < dataLength; i++) {
    preSplitDist[i] = input.readDouble();
  }

  return new ComputeContentEvent(splitId, learningNodeId, preSplitDist);
}
 

@Override
public Pair read(Kryo kryo, Input input, Class<Pair> arg2) {

    long value = input.readLong();
    String key = input.readString();
    Pair inner = new Pair();
    inner.setKey(key);
    inner.setValue(value);
    return inner;
}
 

public Tuple deserialize(Input input) {
    int targetTaskId = 0;
    long timeStamp = 0l;
    int taskId = 0;
    int streamId = 0;
    String componentName = null;
    String streamName = null;
    MessageId id = null;
    boolean isBatchTuple = false;

    try {
        targetTaskId = input.readInt();
        timeStamp = input.readLong();
        isBatchTuple = input.readBoolean();
        taskId = input.readInt(true);
        streamId = input.readInt(true);
        componentName = _context.getComponentId(taskId);
        streamName = _ids.getStreamName(componentName, streamId);

        List<Object> values;
        int groupId = -1;
        long batchId =  -1;
        if (isBatchTuple) {
            if(_isTransactionTuple) {
                batchId = input.readLong(true);
            }
            values = new ArrayList<>();
            int len = input.readInt(true);
            if (_ackerNum > 0) {
                for (int i = 0; i < len; i++) {
                    values.add(new Pair<>(MessageId.deserialize(input), _kryo.deserializeFrom(input)));
                }
            } else {
                for (int i = 0; i < len; i++) {
                    values.add(new Pair<MessageId, List<Object>>(null, _kryo.deserializeFrom(input)));
                }
            }
        } else {
            id = MessageId.deserialize(input);
            values = _kryo.deserializeFrom(input);
        }

        TupleImplExt tuple = new TupleImplExt(_context, values, taskId, streamName, id);
        tuple.setBatchTuple(isBatchTuple);
        tuple.setTargetTaskId(targetTaskId);
        tuple.setCreationTimeStamp(timeStamp);
        if (_isTransactionTuple) {
            tuple.setBatchId(batchId);
        }
        return tuple;
    } catch (Exception e) {
        StringBuilder sb = new StringBuilder();

        sb.append("Deserialize error:");
        sb.append("targetTaskId:").append(targetTaskId);
        sb.append(",creationTimeStamp:").append(timeStamp);
        sb.append(",isBatchTuple:").append(isBatchTuple);
        sb.append(",taskId:").append(taskId);
        sb.append(",streamId:").append(streamId);
        sb.append(",componentName:").append(componentName);
        sb.append(",streamName:").append(streamName);
        sb.append(",MessageId:").append(id);
        LOG.error("Kryo error!!! {}", sb.toString());
        LOG.error("Exception: ", e);
        throw new RuntimeException(e);
    }
}
 

private PSKmerBloomFilter(final Kryo kryo, final Input input) {
    this.kmerSize = input.readInt();
    this.kmerMask = new SVKmerShort(input.readLong());
    this.kmerSet = kryo.readObject(input, LongBloomFilter.class);
    this.falsePositiveProbability = input.readDouble();
}
 

@Override
public ConstantLongDistribution read (Kryo kryo, Input input, Class<ConstantLongDistribution> type) {
	return new ConstantLongDistribution(input.readLong());
}
 

@Override
public void read(Kryo kryo, Input input) {
    name = input.readString();
    birthDate = new Date(input.readLong());
    age = input.readInt();
}
 

@Override
public MastershipBasedTimestamp read(Kryo kryo, Input input, Class<MastershipBasedTimestamp> type) {
    final long term = input.readLong();
    final long sequence = input.readLong();
    return new MastershipBasedTimestamp(term, sequence);
}
 

private PSKmerSet(final Kryo kryo, final Input input) {
    this.kmerSize = input.readInt();
    this.kmerMask = new SVKmerShort(input.readLong());
    this.kmerSet = kryo.readObject(input, LargeLongHopscotchSet.class);
}
 

private ReadMetadata( final Kryo kryo, final Input input ) {
    final int crossContigIgnoreSetSize = input.readInt();
    this.crossContigIgnoreSet = new HashSet<>(SVUtils.hashMapCapacity(crossContigIgnoreSetSize));
    for ( int idx = 0; idx != crossContigIgnoreSetSize; ++idx ) {
        crossContigIgnoreSet.add(input.readInt());
    }

    final int groupMapSize = input.readInt();
    readGroupToLibrary = new HashMap<>(SVUtils.hashMapCapacity(groupMapSize));
    for ( int idx = 0; idx != groupMapSize; ++idx ) {
        final String groupName = input.readString();
        final String libName = input.readString();
        readGroupToLibrary.put(groupName, libName);
    }

    final int contigMapSize = input.readInt();
    contigNameToID = new HashMap<>(SVUtils.hashMapCapacity(contigMapSize));
    for ( int idx = 0; idx != contigMapSize; ++idx ) {
        final String contigName = input.readString();
        final int contigId = input.readInt();
        contigNameToID.put(contigName, contigId);
    }
    contigIDToName = buildContigIDToNameArray(contigNameToID);

    nReads = input.readLong();
    avgReadLen = input.readInt();
    nRefBases = input.readLong();
    maxReadsInPartition = input.readLong();
    coverage = input.readFloat();
    meanBaseQuality = input.readFloat();

    final int nPartitions = input.readInt();
    partitionBounds = new PartitionBounds[nPartitions];
    final PartitionBounds.Serializer boundsSerializer = new PartitionBounds.Serializer();
    for ( int idx = 0; idx != nPartitions; ++idx ) {
        partitionBounds[idx] = boundsSerializer.read(kryo, input, PartitionBounds.class);
    }

    final int libMapSize = input.readInt();
    final LibraryStatistics.Serializer statsSerializer = new LibraryStatistics.Serializer();
    libraryToFragmentStatistics = new HashMap<>(SVUtils.hashMapCapacity(libMapSize));
    for ( int idx = 0; idx != libMapSize; ++idx ) {
        final String libraryName = input.readString();
        final LibraryStatistics stats = statsSerializer.read(kryo, input, LibraryStatistics.class);
        libraryToFragmentStatistics.put(libraryName, stats);
    }

}
 

private SVKmerShort(final Kryo kryo, final Input input) {
    valLow = input.readLong();
}