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

SmallDuplicationBreakpointComplications(final Kryo kryo, final Input input) {
    super(kryo, input);
    final String ctg = input.readString();
    final int start = input.readInt();
    final int end = input.readInt();
    dupSeqRepeatUnitRefSpan = new SimpleInterval(ctg, start, end);
    dupSeqRepeatNumOnRef = input.readInt();
    dupSeqRepeatNumOnCtg = input.readInt();
    dupSeqStrandOnRef = new ArrayList<>(dupSeqRepeatNumOnRef);
    for (int i=0; i<dupSeqRepeatNumOnRef; ++i) {
        dupSeqStrandOnRef.add(Strand.values()[input.readInt()]);
    }
    dupSeqStrandOnCtg = new ArrayList<>(dupSeqRepeatNumOnCtg);
    for (int i=0; i<dupSeqRepeatNumOnCtg; ++i) {
        dupSeqStrandOnCtg.add(Strand.values()[input.readInt()]);
    }
}
 

@Override
public MapMetaData<Double> read(Kryo kryo, Input input, Class<MapMetaData<Double>> type) {
    try {
        thatMapMetaData = mapMetaData.recv(input);
        int thatMapSegNum = thatMapMetaData.getSegNum();
        List<Map<String, Double>> mapDataList = new ArrayList<>(thatMapSegNum);
        thatMapMetaData.setMapDataList(mapDataList);

        for (int i = 0; i < thatMapSegNum; i++) {
            int dataNum = thatMapMetaData.getDataNum(i);
            Map<String, Double> mapData = new HashMap<>(dataNum);
            mapDataList.add(mapData);
            for (int j = 0; j < dataNum; j++) {
                String key = input.readString();
                Double val = input.readDouble();
                mapData.put(key, val);
            }
        }
    } catch (IOException e) {
        LOG.error("double array read exception", e);
        System.exit(1);
    }
    return thatMapMetaData;
}
 

@Override
public void read(final Object object, final Input in) throws KryoException
{
  final StreamingContainerManager scm = (StreamingContainerManager)object;

  final String operatorName = in.readString();
  final String propertyName = in.readString();
  final String propertyValue = in.readString();

  final OperatorMeta logicalOperator = scm.plan.getLogicalPlan().getOperatorMeta(operatorName);
  if (logicalOperator == null) {
    throw new IllegalArgumentException("Unknown operator " + operatorName);
  }

  scm.setOperatorProperty(logicalOperator, propertyName, propertyValue);
}
 

private Pair(Kryo kryo, Input input){
    super(input.readInt(true), input.readString());

    // Information used to detect optical dupes
    tile = -1;
    x = -1;
    y = -1;
    libraryId = -1;

    score = input.readShort();

    isRead1ReverseStrand = input.readBoolean();

    isRead2ReverseStrand = input.readBoolean();

    readGroupIndex = input.readShort();
    wasFlipped = input.readBoolean();
}
 

@Override
public void read(final Object object, final Input in) throws KryoException
{
  final StreamingContainerManager scm = (StreamingContainerManager)object;

  final String operatorName = in.readString();
  final String propertyName = in.readString();
  final String propertyValue = in.readString();

  final OperatorMeta logicalOperator = scm.plan.getLogicalPlan().getOperatorMeta(operatorName);
  if (logicalOperator == null) {
    throw new IllegalArgumentException("Unknown operator " + operatorName);
  }

  scm.setOperatorProperty(logicalOperator, propertyName, propertyValue);
}
 

@Override
public Event read(Kryo kryo, Input input, Class<Event> eventClass) {
    String uuid = input.readString();
    long timestamp = input.readLong();

    Event event = new BaseEvent(uuid, timestamp);
    int numTuples = input.readInt();
    for(int i = 0; i < numTuples; i++) {

        String key = input.readString();
        String alias = input.readString();
        String val = input.readString();

        event.put(new Tuple(key, registry.decode(alias, val)));
    }

    return event;

}
 

@Override
public void read(Kryo kryo, Input input) {
    readMetadata(kryo, input);
    String ipAddressString = input.readString();
    setValue(ipAddressString);
    setNormalizedValue(ipAddressString);
    validate();
}
 

@Override
protected VideoChunk readObject(Kryo kryo, Input input, Class<VideoChunk> clas, long requestId, String streamId, long sequenceNr) throws Exception {
	long duration = input.readLong();
	int length = input.readInt();
	byte[] video = input.readBytes(length);
	String container = input.readString();
	VideoChunk chunk = new VideoChunk(streamId, sequenceNr, duration, video, container);
	chunk.setRequestId(requestId);
	return chunk;
}
 

@Override
public Schema read(Kryo kryo, Input input, Class<Schema> type) {
	String schemaAsString = input.readString();
	// the parser seems to be stateful, to we need a new one for every type.
	Schema.Parser sParser = new Schema.Parser();
	return sParser.parse(schemaAsString);
}
 

public MapMetaData<Byte> read(Kryo kryo, Input input, Class<MapMetaData<Byte>> type) {
    try {
        thatMapMetaData = mapMetaData.recv(input);
        int thatMapSegNum = thatMapMetaData.getSegNum();
        List<Map<String, Byte>> thatMapListData = new ArrayList<>(thatMapSegNum);
        List<Integer> thatDataNums = new ArrayList<>(thatMapSegNum);
        for (int i = 0; i < thatMapSegNum; i++) {
            Map<String, Byte> thisMapData = mapMetaData.getMapDataList().get(i);
            int dataNum = thatMapMetaData.getDataNum(i);
            for (int j = 0; j < dataNum; j++) {
                String key = input.readString();
                Byte val = input.readByte();

                Byte thisVal = thisMapData.get(key);
                if (thisVal == null) {
                    thisMapData.put(key, val);
                } else {
                    thisMapData.put(key, operator.apply(thisVal, val));
                }
            }
            thatMapListData.add(thisMapData);
            thatDataNums.add(thisMapData.size());
        }

        thatMapMetaData.setMapDataList(thatMapListData);
        thatMapMetaData.setDataNums(thatDataNums);

    } catch (IOException e) {
        LOG.error("double array read exception", e);
        System.exit(1);
    }
    return thatMapMetaData;
}
 

protected NovelAdjacencyAndAltHaplotype(final Kryo kryo, final Input input) {
    final String contig1 = input.readString();
    final int start1 = input.readInt();
    final int end1 = input.readInt();
    this.leftJustifiedLeftRefLoc = new SimpleInterval(contig1, start1, end1);
    final String contig2 = input.readString();
    final int start2 = input.readInt();
    final int end2 = input.readInt();
    this.leftJustifiedRightRefLoc = new SimpleInterval(contig2, start2, end2);

    this.strandSwitch = StrandSwitch.values()[input.readInt()];

    this.complication = (BreakpointComplications) kryo.readClassAndObject(input);

    this.type = TypeInferredFromSimpleChimera.values()[ input.readInt() ];

    final boolean altSeqIsNull = input.readBoolean();
    if (altSeqIsNull) {
        altHaplotypeSequence = null;
    } else {
        final int arraySize = input.readInt();
        altHaplotypeSequence = new byte[arraySize];
        for (int i = 0 ; i < arraySize; ++i) {
            altHaplotypeSequence[i] = input.readByte();
        }
    }
}
 

@Override
public Schema read(Kryo kryo, Input input, Class<Schema> type) {
	String schemaAsString = input.readString();
	// the parser seems to be stateful, to we need a new one for every type.
	Schema.Parser sParser = new Schema.Parser();
	return sParser.parse(schemaAsString);
}
 

@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;
}
 

AlignmentInterval(final Kryo kryo, final Input input) {
    final String chr = input.readString();
    final int refStart = input.readInt(),
            refEnd = input.readInt();
    referenceSpan = new SimpleInterval(chr, refStart, refEnd);
    startInAssembledContig = input.readInt();
    endInAssembledContig = input.readInt();
    cigarAlong5to3DirectionOfContig = TextCigarCodec.decode(input.readString());
    forwardStrand = input.readBoolean();
    mapQual = input.readInt();
    mismatches = input.readInt();
    alnScore = input.readInt();
    alnModType = ContigAlignmentsModifier.AlnModType.values()[input.readInt()];
}
 

@Override
public ProviderId read(Kryo kryo, Input input, Class<ProviderId> type) {
    String scheme = input.readString();
    String id = input.readString();
    boolean isAncillary = input.readBoolean();
    return new ProviderId(scheme, id, isAncillary);
}
 

@Override
public void read(Kryo kryo, Input input) {
    readMetadata(kryo, input);
    
    this.point = input.readString();
    validate();
}
 

@Override
public void read(final Object object, final Input in) throws KryoException
{
  final StreamingContainerManager scm = (StreamingContainerManager)object;

  final int operatorId = in.readInt();
  final String propertyName = in.readString();
  final String propertyValue = in.readString();

  final PTOperator o = scm.plan.getAllOperators().get(operatorId);
  if (o == null) {
    throw new IllegalArgumentException("Unknown physical operator " + operatorId);
  }
  scm.setPhysicalOperatorProperty(o, propertyName, propertyValue);
}
 

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

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

@Override
public Address read(Kryo kryo, Input input, Class<Address> type) {
  String host = input.readString();
  int port = input.readInt();
  return Address.from(host, port);
}