Java Code Examples for com.esotericsoftware.kryo.io.Output#writeBoolean()

protected void serialize(final Kryo kryo, final Output output) {
    output.writeString(leftJustifiedLeftRefLoc.getContig());
    output.writeInt(leftJustifiedLeftRefLoc.getStart());
    output.writeInt(leftJustifiedLeftRefLoc.getEnd());
    output.writeString(leftJustifiedRightRefLoc.getContig());
    output.writeInt(leftJustifiedRightRefLoc.getStart());
    output.writeInt(leftJustifiedRightRefLoc.getEnd());
    output.writeInt(strandSwitch.ordinal());

    kryo.writeClassAndObject(output, complication);

    output.writeInt(type.ordinal());

    if (altHaplotypeSequence==null) {
        output.writeBoolean(true);
    } else {
        output.writeBoolean(false);
        output.writeInt(altHaplotypeSequence.length);
        for (final byte b : altHaplotypeSequence) {
            output.writeByte(b);
        }
    }
}
 

@Override
public void write(Kryo kryo, Output output, DefaultLink object) {
    kryo.writeClassAndObject(output, object.providerId());
    kryo.writeClassAndObject(output, object.src());
    kryo.writeClassAndObject(output, object.dst());
    kryo.writeClassAndObject(output, object.type());
    kryo.writeClassAndObject(output, object.state());
    output.writeBoolean(object.isExpected());
}
 

@Override
public void write(Kryo kryo, Output output) {
    // Write out the number of entries;
    output.writeInt(map.size(), true);
    
    for (Entry<String,FieldValue> entry : map.entries()) {
        // Write the key
        output.writeString(entry.getKey());
        
        // Write the fields in the value
        byte[] vis = entry.getValue().getVisibility().getExpression();
        
        if (vis == null) {
            vis = new byte[0];
        }
        
        output.writeInt(vis.length, true);
        output.write(vis);
        
        output.writeInt(entry.getValue().getValue().length, true);
        output.write(entry.getValue().getValue());
        
        if (null != entry.getValue().getContext()) {
            output.writeBoolean(true);
            output.writeString(entry.getValue().getContext());
        } else {
            output.writeBoolean(false);
        }
        
        if (null != entry.getValue().isHit()) {
            output.writeBoolean(true);
            output.writeBoolean(entry.getValue().isHit());
        } else {
            output.writeBoolean(false);
        }
    }
}
 

@Override
protected void serialize( final Kryo kryo, final Output output ) {
    super.serialize(kryo, output);
    output.writeString(templateName);
    output.writeByte(fragmentOrdinal.ordinal());
    output.writeBoolean(forwardStrand);
    output.writeString(cigarString);
    output.writeInt(mappingQuality);
    output.writeInt(templateSize);
    output.writeString(readGroup);
}
 

@Override
public void write(Kryo kryo, Output output, Boolean reducedResponse) {
    output.writeInt(this._count, true);
    output.writeBoolean(this.trackSizes);
    // Write out the number of Attributes we're going to store
    output.writeInt(this.attributes.size(), true);
    
    for (Attribute<? extends Comparable<?>> attr : this.attributes) {
        // Write out the concrete Attribute class
        output.writeString(attr.getClass().getName());
        
        // Defer to the concrete instance to write() itself
        attr.write(kryo, output, reducedResponse);
    }
}
 

private static void writeConnection( final Connection connection,
                                     final Map<Contig, Integer> contigMap,
                                     final Output output ) {
    output.writeInt(contigMap.get(connection.getTarget()));
    output.writeInt(connection.getOverlapLen());
    output.writeBoolean(connection.isRC());
    output.writeBoolean(connection.isTargetRC());
}
 

@Override
public void write(Kryo kryo, Output output, Summary object) {
    output.writeInt(object.value.length);
    for (int i = 0; i < object.value.length; i++) {
        output.writeFloat(object.value[i]);
    }

    output.writeInt(object.rmin.length);
    for (int i = 0; i < object.rmin.length; i++) {
        output.writeDouble(object.rmin[i]);
    }

    output.writeInt(object.rmax.length);
    for (int i = 0; i < object.rmax.length; i++) {
        output.writeDouble(object.rmax[i]);
    }

    output.writeInt(object.w.length);
    for (int i = 0; i < object.w.length; i++) {
        output.writeFloat(object.w[i]);
    }

    output.writeInt(object.capacity);
    output.writeInt(object.cursor);
    output.writeDouble(object.B);
    output.writeBoolean(object.exact);
    output.writeDouble(object.eps);
}
 

@Override
public void write(Kryo kryo, Output output, Collection collection) {
    boolean isNotInstantiated = collection instanceof IndirectContainer
            && !((IndirectContainer) collection).isInstantiated();
    output.writeBoolean(isNotInstantiated);
    if (!isNotInstantiated) {
        super.write(kryo, output, collection);
    }
}
 

void serialize(final Kryo kryo, final Output output) {
    contigSerializer.write(kryo, output, sourceTig);
    output.writeInt(insertionMappings.size());
    for (final String mapping : insertionMappings) {
        output.writeString(mapping);
    }
    output.writeBoolean(hasEquallyGoodAlnConfigurations);
   output.writeString(saTAGForGoodMappingToNonCanonicalChromosome);
}
 

void serialize(final Kryo kryo, final Output output) {
    output.writeString(referenceSpan.getContig());
    output.writeInt(referenceSpan.getStart());
    output.writeInt(referenceSpan.getEnd());
    output.writeInt(startInAssembledContig);
    output.writeInt(endInAssembledContig);
    output.writeString(TextCigarCodec.encode(cigarAlong5to3DirectionOfContig));
    output.writeBoolean(forwardStrand);
    output.writeInt(mapQual);
    output.writeInt(mismatches);
    output.writeInt(alnScore);
    output.writeInt(alnModType.ordinal());
}
 

private static void writeContig( final Contig contig, final Output output ) {
    output.writeInt(contig.getSequence().length);
    output.writeBytes(contig.getSequence());
    final boolean hasCoverage = contig.getPerBaseCoverage() != null;
    output.writeBoolean(hasCoverage);
    if ( hasCoverage ) output.writeBytes(contig.getPerBaseCoverage());
    output.writeInt(contig.getNSupportingReads());
}
 

@Override
public void write(Kryo kryo, Output output, AttributeContentEvent event) {
  output.writeLong(event.learningNodeId, true);
  output.writeInt(event.obsIndex, true);
  output.writeDouble(event.attrVal, PRECISION, true);
  output.writeInt(event.classVal, true);
  output.writeDouble(event.weight, PRECISION, true);
  output.writeBoolean(event.isNominal);
}
 

@Override
public void write(Kryo kryo, Output output, T object) {
    output.writeBoolean(object.isNull());
    if(!object.isNull()){
        try{
            writeValue(kryo, output, object);
        }catch(StandardException se){
            throw new RuntimeException(se);
        }
    }
}
 

@Override
public void write(final Kryo kryo, final Output output, final BitSet bitSet) {
    final int len = bitSet.length();

    output.writeInt(len, true);

    for (int i = 0; i < len; i++) {
        output.writeBoolean(bitSet.get(i));
    }
}
 

@Override
public void write(Kryo kryo, Output output, PortNumber object) {
    output.writeBoolean(object.hasName());
    output.writeLong(object.toLong());
    if (object.hasName()) {
        output.writeString(object.name());
    }
}
 

protected void serialize( final Kryo kryo, final Output output ) {
    intervalSerializer.write(kryo, output, interval);
    output.writeBoolean(containsMaxCoveragePeak);
}
 

@Override
public void write (Kryo kryo, Output out) {
    out.writeBoolean(data);
}
 

@Override
public void write(Kryo kryo, Output output, PyBoolean object) {
	output.writeBoolean(object.getBooleanValue());
}
 

@Override
protected void serialize( final Kryo kryo, final Output output ) {
    super.serialize(kryo, output);
    output.writeInt(mateStartPosition);
    output.writeBoolean(mateReverseStrand);
}
 

@Override
protected void serialize( final Kryo kryo, final Output output ) {
    super.serialize(kryo, output);
    output.writeString(tagSA);
    output.writeBoolean(primaryAlignmentClippedAtStart);
}