Write out an individual seek point.
@param os    The output stream
@throws IOException  Thrown if error writing data
548514
public void write(BitOutputStream os) throws IOException {

        os.writeRawULong(sampleNumber, SEEKPOINT_SAMPLE_NUMBER_LEN);
        os.writeRawULong(streamOffset, SEEKPOINT_STREAM_OFFSET_LEN);
        os.writeRawUInt(frameSamples, SEEKPOINT_FRAME_SAMPLES_LEN);
    }
1305257
private void tryWriteBytes() throws IOException {
        lock.lock();
        try {
            // Iterate through the outbound ByteBuff queue, pushing as much as possible into the OS' network buffer.
            Iterator<ByteBuffer> bytesIterator = bytesToWrite.iterator();
            while (bytesIterator.hasNext()) {
                ByteBuffer buff = bytesIterator.next();
                bytesToWriteRemaining -= channel.write(buff);
                if (!buff.hasRemaining())
                    bytesIterator.remove();
                else {
                    setWriteOps();
                    break;
                }
            }
            // If we are done writing, clear the OP_WRITE interestOps
            if (bytesToWrite.isEmpty())
                key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
            // Don't bother waking up the selector here, since we're just removing an op, not adding
        } finally {
            lock.unlock();
        }
    }
595380
public void setProcessInputStream(OutputStream os) {
    if (input != null) {
      if (input == System.in) {
        inputThread = createSystemInPump(input, os);
      }
      else {
        inputThread = createPump(input, os, true, true);
      }
    }
    else {
      try {
        os.close();
      }
      catch (IOException e) {
        log.info("Got exception while closing output stream", e);
      }
    }
  }
766054
protected void writeDirectBytes(byte[] b, int off, int len)
			throws IOException {
		ostream.write(b, off, len);
		len += len;
	}
854237
private void writeObject(java.io.ObjectOutputStream out) throws IOException
    {
        out.defaultWriteObject();

        // Write out header information first.
        out.write(EYECATCHER);
        out.writeShort(PLATFORM);
        out.writeShort(ivActualVersion);

        // Now write EJBObject to output stream using HandleDelegate object.
        HandleHelper.lookupHandleDelegate().writeEJBObject(ivEjbObject, out);

        // If actual version is 1, then we need to write HomeHandle and key
        // to output stream as well.
        if (ivActualVersion == Constants.HANDLE_V1)
        {
            out.writeObject(ivHomeHandle);

            //d158086---------------->

            // if this is the IBM IIOP class or we have no IIOP class
            // which means we are not running in an ibm environment
            // we leave the key as is.  this allows older handle versions
            // running on ibm thin client or client containers, to still function

            Boolean orb = HandleHelper.isORBOutputStream(out);
            if (orb != null && orb.booleanValue())
            {

                if (DEBUG_ON)
                    System.out.println("serialize IIOP stream primary key");
                out.writeObject(ivKey);
                if (DEBUG_ON)
                    System.out.println("serialized IIOP stream primary key");
            }
            else
            {
                if (DEBUG_ON)
                    System.out.println("serialize non IIOP stream primary key");
                out.writeObject(KeyHelper.serialize(ivKey));
                if (DEBUG_ON)
                    System.out.println("serialized non IIOP stream primary key");

            }
            //<----------------d158086

        }
    }
412877
public void writeTo(final PacketOutputStream pos) throws IOException {
    if (loadedStream == null) {
      writeObjectToBytes();
    }
    pos.write(BINARY_INTRODUCER);
    pos.writeBytesEscaped(loadedStream, loadedStream.length, noBackSlashEscapes);
    pos.write(QUOTE);

  }
961730
public void writeObject(Object o) throws IOException {
        ObjectOutputStream oos = AnonymousClassWarnings.checkingObjectOutputStream(out);
        oos.writeObject(o);
        // don't close oss, which will close the underlying stream
        // no need to flush either, given the way oos is implemented
    }
377037
private void writeObject(java.io.ObjectOutputStream out) throws IOException {

        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "writeObject: " + this);

        out.defaultWriteObject();

        // Write out header information first.
        out.write(EYECATCHER);
        out.writeShort(PLATFORM);
        out.writeShort(VERSION_ID);

        // Write out the instance data.
        out.writeBoolean(isTimer);
        out.writeLong(taskId);

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "writeObject");
    }
4639
public void writeToStream(OutputStream os) throws IOException
  {
    if (_readLength <= _readOffset) {
      readBuffer();
    }

    while (_readOffset < _readLength) {
      os.write(_readBuffer, _readOffset, _readLength - _readOffset);

      readBuffer();
    }
  }
935747
protected void writeOut(byte[] buf, int offset, int len) throws IOException
	{
		if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {  //306998.15
			logger.logp(Level.FINE, CLASS_NAME,"writeOut", "writeOut len --> "+len);
        }
		out.write(buf, offset, len);
	}
639739
public int write(OutputStreamWithBuffer os, char []cbuf, int off, int len)
    throws IOException
  {
    for (int i = 0; i < len; i++) {
      write(os, cbuf[off + i]);
    }
    
    return len;
  }
1155397
public void write(final Point point) {
        this.influxDb.write(influxDbProperties.getDatabase(), influxDbProperties.getRetentionPolicy(), point);
    }
691791
public void write(DataOutput out) throws IOException {
        t.write(out);
        out.writeInt(position);
    }
921616
public static void write(byte[] data, OutputStream os, boolean closeSink) {
        try {
            os.write(data);
        } catch (IOException e) {
            throw E.ioException(e);
        } finally {
            if (closeSink) {
                close(os);
            }
        }
    }
178166
public static void write(byte b, OutputStream os) {
        try {
            os.write(b);
        } catch (IOException e) {
            throw E.ioException(e);
        }
    }
1208596
public void write(BinaryOWLOutputStream dos) throws IOException {

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        BinaryOWLOutputStream buffer = new BinaryOWLOutputStream(bos, dos.getVersion());
        buffer.writeLong(timestamp);
        writeMetadata(buffer);
        writeChangeRecordData(buffer);

        dos.writeInt(bos.size());
        dos.writeInt(CHUNK_TYPE);
        bos.writeTo(dos);
    }
1130844
private void writeObject(ObjectOutputStream oos) throws IOException
	{

		oos.defaultWriteObject();

		synchronized (bcsListeners)
		{
			serialize(oos, bcsListeners);
		}
	}