internal static void WriteInternal( byte[] @object, DataOutput output) { output.WriteInt(@object.Length); output.Write(@object); }
/// <summary> /// Writes a byte array. /// <p> /// The length is written as a <code>short</code>, followed /// by the bytes. /// </summary> public virtual void Write(byte[] bytes, int off, int len) { Debug.Assert(bytes != null); Debug.Assert(off >= 0 && off + len <= bytes.Length); Debug.Assert(len >= 0); Os.WriteShort((short)len); Os.Write(bytes, off, len); }
private static void WriteBytes( DataOutput output, ByteBuffer value) { var bytes = value.Array; output.WriteInt(bytes.Length); output.Write(bytes); }
/// <summary> /// Serialize object /// </summary> /// <param name="value">value to serialize</param> /// <param name="output">output stream</param> /// <throws>IOException when a problem occurs</throws> public static void SerializeTo( object value, DataOutput output) { var result = ObjectToByteArr(value); output.WriteInt(result.Length); output.Write(result); }
public void Write( object @object, DataOutput output, byte[] pageFullKey, EventBeanCollatedWriter writer) { byte[] objectBytes = ObjectToByteArr(@object); output.WriteInt(objectBytes.Length); output.Write(objectBytes); }
private void WriteInternal( byte[] @object, DataOutput output) { if (@object == null) { output.WriteInt(-1); return; } output.WriteInt(@object.Length); output.Write(@object); }
/// <summary> /// Serialize /// <see cref="#created"/> /// /// </summary> /// <exception cref="System.IO.IOException"/> private void WriteCreated(DataOutput @out) { IList <INode> created = GetList(Diff.ListType.Created); @out.WriteInt(created.Count); foreach (INode node in created) { // For INode in created list, we only need to record its local name byte[] name = node.GetLocalNameBytes(); @out.WriteShort(name.Length); @out.Write(name); } }
/// <exception cref="System.IO.IOException"/> public virtual void Write(DataOutput @out) { if (0 == len) { return; } int written = 0; if (!disableRead) { WritableUtils.WriteVInt(@out, len); written -= WritableUtils.GetVIntSize(len); } if (len > 1024) { if (null == b || b.Length < len) { b = new byte[2 * len]; } Arrays.Fill(b, fillChar); do { int write = Math.Min(len - written, r.Next(len)); @out.Write(b, 0, write); written += write; }while (written < len); NUnit.Framework.Assert.AreEqual(len, written); } else { for (int i = written; i < len; ++i) { @out.Write(fillChar); } } }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="bigInteger">value</param> /// <param name="stream">output</param> /// <throws>IOException io error</throws> public static void WriteBigInt( BigInteger bigInteger, DataOutput stream) { var byteArray = bigInteger.ToByteArray(); if (byteArray.Length > Int16.MaxValue) { throw new ArgumentException("BigInteger byte array is larger than 0x7fff bytes"); } var length = (short)byteArray.Length; stream.WriteShort(length); stream.Write(byteArray, 0, byteArray.Length); }
private void WriteInternal( object[] @object, DataOutput output) { if (@object == null) { output.WriteInt(-1); return; } output.WriteInt(@object.Length); foreach (var obj in @object) { byte[] data = DIOSerializableObjectSerde.ObjectToByteArr(obj); output.WriteInt(data.Length); output.Write(data); } }
/// <exception cref="System.IO.IOException"/> public override void Write(DataOutput @out) { @out.Write(proto.ToByteArray()); }
/// <exception cref="System.IO.IOException"/> public override void Write(DataOutput @out) { Log.Debug("Writing NMTokenIdentifier to RPC layer: " + this); @out.Write(proto.ToByteArray()); }
/// <summary>Write to out</summary> /// <exception cref="System.IO.IOException"/> public void Write(DataOutput @out) { @out.Write(OP.code); }
/// <summary> /// Writes a string to the specified DataOutput using /// <a href="DataInput.html#modified-utf-8">modified UTF-8</a> /// encoding in a machine-independent manner. /// </summary> /// <remarks> /// Writes a string to the specified DataOutput using /// <a href="DataInput.html#modified-utf-8">modified UTF-8</a> /// encoding in a machine-independent manner. /// <p> /// First, two bytes are written to out as if by the <code>writeShort</code> /// method giving the number of bytes to follow. This value is the number of /// bytes actually written out, not the length of the string. Following the /// length, each character of the string is output, in sequence, using the /// modified UTF-8 encoding for the character. If no exception is thrown, the /// counter <code>written</code> is incremented by the total number of /// bytes written to the output stream. This will be at least two /// plus the length of <code>str</code>, and at most two plus /// thrice the length of <code>str</code>. /// </remarks> /// <param name="str">a string to be written.</param> /// <param name="out">destination to write to</param> /// <returns>The number of bytes written out.</returns> /// <exception> /// IOException /// if an I/O error occurs. /// </exception> /// <exception cref="System.IO.IOException" /> internal static int WriteUTF(string str, DataOutput @out) { var strlen = str.Length; var utflen = 0; int c; var count = 0; /* use charAt instead of copying String to char array */ for (var i = 0; i < strlen; i++) { c = str[i]; if (c >= 0x0001 && c <= 0x007F) { utflen++; } else if (c > 0x07FF) { utflen += 3; } else { utflen += 2; } } if (utflen > 65535) { throw new UTFDataFormatException("encoded string too long: " + utflen + " bytes"); } byte[] bytearr = null; if (@out is DataOutputStream) { var dos = (DataOutputStream)@out; if (dos.bytearr == null || dos.bytearr.Length < utflen + 2) { dos.bytearr = new byte[utflen * 2 + 2]; } bytearr = dos.bytearr; } else { bytearr = new byte[utflen + 2]; } bytearr[count++] = unchecked ((byte)((int)((uint)utflen >> 8) & 0xFF)); bytearr[count++] = unchecked ((byte)((int)((uint)utflen >> 0) & 0xFF)); var i_1 = 0; for (i_1 = 0; i_1 < strlen; i_1++) { c = str[i_1]; if (!(c >= 0x0001 && c <= 0x007F)) { break; } bytearr[count++] = unchecked ((byte)c); } for (; i_1 < strlen; i_1++) { c = str[i_1]; if (c >= 0x0001 && c <= 0x007F) { bytearr[count++] = unchecked ((byte)c); } else if (c > 0x07FF) { bytearr[count++] = unchecked ((byte)(0xE0 | ((c >> 12) & 0x0F))); bytearr[count++] = unchecked ((byte)(0x80 | ((c >> 6) & 0x3F))); bytearr[count++] = unchecked ((byte)(0x80 | ((c >> 0) & 0x3F))); } else { bytearr[count++] = unchecked ((byte)(0xC0 | ((c >> 6) & 0x1F))); bytearr[count++] = unchecked ((byte)(0x80 | ((c >> 0) & 0x3F))); } } @out.Write(bytearr, 0, utflen + 2); return(utflen + 2); }
/// <summary> /// Writes a string to the specified DataOutput using /// <a href="DataInput.html#modified-utf-8">modified UTF-8</a> /// encoding in a machine-independent manner. /// <para> /// First, two bytes are written to out as if by the <code>writeShort</code> /// method giving the number of bytes to follow. This value is the number of /// bytes actually written out, not the length of the string. Following the /// length, each character of the string is output, in sequence, using the /// modified UTF-8 encoding for the character. If no exception is thrown, the /// counter <code>written</code> is incremented by the total number of /// bytes written to the output stream. This will be at least two /// plus the length of <code>str</code>, and at most two plus /// thrice the length of <code>str</code>. /// /// </para> /// </summary> /// <param name="str"> a string to be written. </param> /// <param name="out"> destination to write to </param> /// <returns> The number of bytes written out. </returns> /// <exception cref="IOException"> if an I/O error occurs. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: static int writeUTF(String str, DataOutput out) throws IOException internal static int WriteUTF(String str, DataOutput @out) { int strlen = str.Length(); int utflen = 0; int c, count = 0; /* use charAt instead of copying String to char array */ for (int i = 0; i < strlen; i++) { c = str.CharAt(i); if ((c >= 0x0001) && (c <= 0x007F)) { utflen++; } else if (c > 0x07FF) { utflen += 3; } else { utflen += 2; } } if (utflen > 65535) { throw new UTFDataFormatException("encoded string too long: " + utflen + " bytes"); } sbyte[] bytearr = null; if (@out is DataOutputStream) { DataOutputStream dos = (DataOutputStream)@out; if (dos.Bytearr == null || (dos.Bytearr.Length < (utflen + 2))) { dos.Bytearr = new sbyte[(utflen * 2) + 2]; } bytearr = dos.Bytearr; } else { bytearr = new sbyte[utflen + 2]; } bytearr[count++] = unchecked ((sbyte)(((int)((uint)utflen >> 8)) & 0xFF)); bytearr[count++] = unchecked ((sbyte)(((int)((uint)utflen >> 0)) & 0xFF)); int i = 0; for (i = 0; i < strlen; i++) { c = str.CharAt(i); if (!((c >= 0x0001) && (c <= 0x007F))) { break; } bytearr[count++] = (sbyte)c; } for (; i < strlen; i++) { c = str.CharAt(i); if ((c >= 0x0001) && (c <= 0x007F)) { bytearr[count++] = (sbyte)c; } else if (c > 0x07FF) { bytearr[count++] = unchecked ((sbyte)(0xE0 | ((c >> 12) & 0x0F))); bytearr[count++] = unchecked ((sbyte)(0x80 | ((c >> 6) & 0x3F))); bytearr[count++] = unchecked ((sbyte)(0x80 | ((c >> 0) & 0x3F))); } else { bytearr[count++] = unchecked ((sbyte)(0xC0 | ((c >> 6) & 0x1F))); bytearr[count++] = unchecked ((sbyte)(0x80 | ((c >> 0) & 0x3F))); } } @out.Write(bytearr, 0, utflen + 2); return(utflen + 2); }
/// <exception cref="System.IO.IOException"/> public static void WriteBytes(byte[] data, DataOutput @out) { @out.WriteShort(data.Length); @out.Write(data); }