/** * Method for directly inserting specified bytes in output at current * position. * <p> * NOTE: only use this method if you really know what you are doing. */ public void writeBytes(byte[] data, int offset, int len) throws IOException { _writeBytes(data, offset, len); }
/** * Method for directly inserting specified bytes in output at * current position. *<p> * NOTE: only use this method if you really know what you are doing. */ public void writeBytes(byte[] data, int offset, int len) throws IOException { _writeBytes(data, offset, len); }
/** * Method for directly inserting specified bytes in output at * current position. *<p> * NOTE: only use this method if you really know what you are doing. */ public void writeBytes(byte[] data, int offset, int len) throws IOException { _writeBytes(data, offset, len); }
protected void _write(BigInteger v) throws IOException { /* * Supported by using type tags, as per spec: major type for tag '6'; 5 * LSB either 2 for positive bignum or 3 for negative bignum. And then * byte sequence that encode variable length integer. */ if (v.signum() < 0) { _writeByte(BYTE_TAG_BIGNUM_NEG); v = v.negate(); } else { _writeByte(BYTE_TAG_BIGNUM_POS); } byte[] data = v.toByteArray(); final int len = data.length; _writeLengthMarker(PREFIX_TYPE_BYTES, len); _writeBytes(data, 0, len); }
@Override public void writeRawUTF8String(byte[] raw, int offset, int len) throws IOException { _verifyValueWrite("write String value"); if (len == 0) { _writeByte(BYTE_EMPTY_STRING); return; } _writeLengthMarker(PREFIX_TYPE_TEXT, len); _writeBytes(raw, 0, len); }
@Override public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) throws IOException { if (data == null) { writeNull(); return; } _verifyValueWrite("write Binary value"); _writeLengthMarker(PREFIX_TYPE_BYTES, len); _writeBytes(data, offset, len); }
@Override public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) throws IOException { if (data == null) { writeNull(); return; } _verifyValueWrite("write Binary value"); _writeLengthMarker(PREFIX_TYPE_BYTES, len); _writeBytes(data, offset, len); }
@Override public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) throws IOException { if (data == null) { writeNull(); return; } _verifyValueWrite("write Binary value"); _writeLengthMarker(PREFIX_TYPE_BYTES, len); _writeBytes(data, offset, len); }
@Override public void writeRawUTF8String(byte[] raw, int offset, int len) throws IOException { _verifyValueWrite("write String value"); if (len == 0) { _writeByte(BYTE_EMPTY_STRING); return; } _writeLengthMarker(PREFIX_TYPE_TEXT, len); _writeBytes(raw, 0, len); }
@Override public void writeRawUTF8String(byte[] raw, int offset, int len) throws IOException { _verifyValueWrite("write String value"); if (len == 0) { _writeByte(BYTE_EMPTY_STRING); return; } _writeLengthMarker(PREFIX_TYPE_TEXT, len); _writeBytes(raw, 0, len); }
@Override public int writeBinary(InputStream data, int dataLength) throws IOException { /* * 28-Mar-2014, tatu: Theoretically we could implement encoder that uses * chunking to output binary content of unknown (a priori) length. But * for no let's require knowledge of length, for simplicity: may be * revisited in future. */ if (dataLength < 0) { throw new UnsupportedOperationException( "Must pass actual length for CBOR encoded data"); } _verifyValueWrite("write Binary value"); int missing; _writeLengthMarker(PREFIX_TYPE_BYTES, dataLength); missing = _writeBytes(data, dataLength); if (missing > 0) { _reportError("Too few bytes available: missing " + missing + " bytes (out of " + dataLength + ")"); } return dataLength; }
@Override public int writeBinary(InputStream data, int dataLength) throws IOException { /* 28-Mar-2014, tatu: Theoretically we could implement encoder that uses * chunking to output binary content of unknown (a priori) length. * But for no let's require knowledge of length, for simplicity: may be * revisited in future. */ if (dataLength < 0) { throw new UnsupportedOperationException("Must pass actual length for CBOR encoded data"); } _verifyValueWrite("write Binary value"); int missing; _writeLengthMarker(PREFIX_TYPE_BYTES, dataLength); missing = _writeBytes(data, dataLength); if (missing > 0) { _reportError("Too few bytes available: missing "+missing+" bytes (out of "+dataLength+")"); } return dataLength; }
@Override public int writeBinary(InputStream data, int dataLength) throws IOException { /* 28-Mar-2014, tatu: Theoretically we could implement encoder that uses * chunking to output binary content of unknown (a priori) length. * But for no let's require knowledge of length, for simplicity: may be * revisited in future. */ if (dataLength < 0) { throw new UnsupportedOperationException("Must pass actual length for CBOR encoded data"); } _verifyValueWrite("write Binary value"); int missing; _writeLengthMarker(PREFIX_TYPE_BYTES, dataLength); missing = _writeBytes(data, dataLength); if (missing > 0) { _reportError("Too few bytes available: missing "+missing+" bytes (out of "+dataLength+")"); } return dataLength; }
@Override public final void writeString(SerializableString sstr) throws IOException { _verifyValueWrite("write String value"); byte[] raw = sstr.asUnquotedUTF8(); final int len = raw.length; if (len == 0) { _writeByte(BYTE_EMPTY_STRING); return; } _writeLengthMarker(PREFIX_TYPE_TEXT, len); _writeBytes(raw, 0, len); }
@Override public void writeNumber(BigInteger v) throws IOException { if (v == null) { writeNull(); return; } _verifyValueWrite("write number"); /* Supported by using type tags, as per spec: major type for tag '6'; * 5 LSB either 2 for positive bignum or 3 for negative bignum. * And then byte sequence that encode variable length integer. */ if (v.signum() < 0) { _writeByte(BYTE_TAG_BIGNUM_NEG); v = v.negate(); } else { _writeByte(BYTE_TAG_BIGNUM_POS); } byte[] data = v.toByteArray(); final int len = data.length; _writeLengthMarker(PREFIX_TYPE_BYTES, len); _writeBytes(data, 0, len); }
@Override public final void writeString(SerializableString sstr) throws IOException { _verifyValueWrite("write String value"); byte[] raw = sstr.asUnquotedUTF8(); final int len = raw.length; if (len == 0) { _writeByte(BYTE_EMPTY_STRING); return; } _writeLengthMarker(PREFIX_TYPE_TEXT, len); _writeBytes(raw, 0, len); }
@Override public final void writeString(SerializableString sstr) throws IOException { _verifyValueWrite("write String value"); byte[] raw = sstr.asUnquotedUTF8(); final int len = raw.length; if (len == 0) { _writeByte(BYTE_EMPTY_STRING); return; } _writeLengthMarker(PREFIX_TYPE_TEXT, len); _writeBytes(raw, 0, len); }
@Override public final void writeFieldName(SerializableString name) throws IOException { // Object is a value, need to verify it's allowed if (_writeContext.writeFieldName(name.getValue()) == JsonWriteContext.STATUS_EXPECT_VALUE) { _reportError("Can not write a field name, expecting a value"); } byte[] raw = name.asUnquotedUTF8(); final int len = raw.length; if (len == 0) { _writeByte(BYTE_EMPTY_STRING); return; } _writeLengthMarker(PREFIX_TYPE_TEXT, len); _writeBytes(raw, 0, len); }
@Override public final void writeFieldName(SerializableString name) throws IOException { // Object is a value, need to verify it's allowed if (_writeContext.writeFieldName(name.getValue()) == JsonWriteContext.STATUS_EXPECT_VALUE) { _reportError("Can not write a field name, expecting a value"); } byte[] raw = name.asUnquotedUTF8(); final int len = raw.length; if (len == 0) { _writeByte(BYTE_EMPTY_STRING); return; } _writeLengthMarker(PREFIX_TYPE_TEXT, len); _writeBytes(raw, 0, len); }
@Override public final void writeFieldName(SerializableString name) throws IOException { // Object is a value, need to verify it's allowed if (_writeContext.writeFieldName(name.getValue()) == JsonWriteContext.STATUS_EXPECT_VALUE) { _reportError("Can not write a field name, expecting a value"); } byte[] raw = name.asUnquotedUTF8(); final int len = raw.length; if (len == 0) { _writeByte(BYTE_EMPTY_STRING); return; } _writeLengthMarker(PREFIX_TYPE_TEXT, len); _writeBytes(raw, 0, len); }