Write array header only without body. Use this if you want to write arrays as streaming.
553027
private void writeArrayHeader(ByteBufAllocator allocator, ArrayHeaderRedisMessage msg, List<Object> out) {
        writeArrayHeader(allocator, msg.isNull(), msg.length(), out);
    }
950144
private static void arrayToWriter(Object array, JsonWriter writer) throws IOException {
    writer.beginArray();
    for (int i = 0, size = Array.getLength(array); i < size; i++) {
      writeValue(Array.get(array, i), writer);
    }
    writer.endArray();
  }
432189
static void writeHeader(DataOutputStream out, DataChecksum checksum)
                         throws IOException {
    writeHeader(out, new BlockMetadataHeader(METADATA_VERSION, checksum));
  }
1366270
function writeHeader(buffer, offset, size, opCode) {
    offset = binary.writeInt(buffer, offset, size)
    offset = binary.writeInt(buffer, offset, 0)
    offset = binary.writeInt(buffer, offset, 0)
    offset = binary.writeInt(buffer, offset, opCode)
    return offset
}
893801
def write(self, out):
        """"""

        if not self.rawtagtable:
            self.rawtagtable = self.rawtagdict.items()
        tags = tagblock(self.rawtagtable)
        self.writeHeader(out, 128 + len(tags))
        out.write(tags)
        out.flush()

        return self
425999
public void
writeByteArray(byte [] b, int off, int len) {
	need(len);
	System.arraycopy(b, off, array, pos, len);
	pos += len;
}
446293
public void write(DataOutput out) throws IOException {
        if (array == null) {
            out.write(NDARRAY_SER_VERSION_HEADER_NULL);
            return;
        }

        INDArray toWrite;
        if (array.isView()) {
            toWrite = array.dup();
        } else {
            toWrite = array;
        }

        //Write version header: this allows us to maintain backward compatibility in the future,
        // with features such as compression, sparse arrays or changes on the DataVec side
        out.write(NDARRAY_SER_VERSION_HEADER);
        Nd4j.write(toWrite, new DataOutputStream(new DataOutputWrapperStream(out)));
    }
665781
def write_array(self, data):
        """"""
        try:
            data.tofile(self._fh)
        except Exception:
            # BytesIO
            self._fh.write(data.tostring())
427365
void writeArrayItemStart() throws IOException {
        if (commaState.get(commaDepth)) {
            output.append(',');
            if (newLine.length() > 0) {
                output.append(' ');
            }
        } else {
            commaState.set(commaDepth);
        }
    }
1337067
public void writeHeader(List<String> header) throws IOException
	{
		StringBuilder text = new StringBuilder();

		for (int i = 0; i < header.size(); i++)
		{
			if (i != 0)
				text.append(SEPARATOR);

			text.append("\"").append(format(header.get(i))).append("\"");

		}

		writeHeader(text.toString(), IO.CHARSET);

	}
221050
def write_to(io)
      deduplicate

      io.write(@header_entry.to_s)

      @entries.each do |entry|
        io.write("\n")
        io.write(entry.to_s)
      end
    end
620184
def start
      write_header(@socket, build_header)
      read_header(@socket)
      @thread = Thread.start do
        while @is_running
          data = read_all(@socket)
          msg = @topic_type.new
          msg.deserialize(data)
          @byte_received += data.length
          @msg_queue.push(msg)
        end
      end
    end
373302
private void sendRequest(String header, byte[] body) throws IOException {
        // Send entire message in one write, else suffer the fate of weird TCP/IP stacks.
        byte[] headerBytes = Utils.toBytes(header);
        byte[] requestBytes = headerBytes;
        if (body != null && body.length > 0) {
            requestBytes = new byte[headerBytes.length + body.length];
            System.arraycopy(headerBytes, 0, requestBytes, 0, headerBytes.length);
            System.arraycopy(body, 0, requestBytes, headerBytes.length, body.length);
        }
        
        // Send the header and body (if any) and flush the result.
        m_outStream.write(requestBytes);
        m_outStream.flush();
    }
450817
public void write(OutputStream out) throws IOException {
		for(HttpHeader header: this) {
			header.write(out);
		}
		out.write(CR);
		out.write(LF);
	}
808170
public void writeEmptyPacket() throws IOException {
    buf[0] = (byte) 4;
    buf[1] = (byte) 0x00;
    buf[2] = (byte) 0x00;
    buf[3] = (byte) this.compressSeqNo++;
    buf[4] = (byte) 0x00;
    buf[5] = (byte) 0x00;
    buf[6] = (byte) 0x00;
    buf[7] = (byte) 0x00;
    buf[8] = (byte) 0x00;
    buf[9] = (byte) 0x00;
    buf[10] = (byte) this.seqNo++;
    out.write(buf, 0, 11);

    if (traceCache != null) {
      traceCache.put(new TraceObject(true, COMPRESSED_PROTOCOL_NOT_COMPRESSED_PACKET,
          Arrays.copyOfRange(buf, 0, 11)));
    }

    if (logger.isTraceEnabled()) {
      logger.trace("send uncompress:{}{}",
          serverThreadLog,
          Utils.hexdump(maxQuerySizeToLog, 0, 11, buf));
    }
  }
836840
public void write(byte b[], int off, int len) {
    expandIfNecessary(count + len);
    System.arraycopy(b, off, bytes, count, len);
    count += len;
  }
65710
@Override
	public void write(byte data[], int offset, int len) throws IOException
    {
        if ((capacity - size) < len)
            flush();
        
        // Do we have enough space ?
        if (capacity >= len)
        {
            System.arraycopy(data, offset, buffer, size, len);
            size += len;
        }
        else
        {
            // Too big, write it directly ...
            out.write(data, offset, len);
        }
    }