! @brief Write data on the OUT endpoint.
491104
def write(self, data):
        """"""

        report_size = self.packet_size
        if self.ep_out:
            report_size = self.ep_out.wMaxPacketSize

        for _ in range(report_size - len(data)):
            data.append(0)

        self.read_sem.release()

        self.ep_out.write(data)
90648
def write!
      writer = Snapshotify::Writer.new(self)
      writer.emitter = emitter
      writer.write
    end
1339711
public void write(DataOutput out) throws IOException {
    Text.writeString(out, trackerName);
    Text.writeString(out, host);
    out.writeInt(httpPort);
    out.writeInt(failures);
    out.writeInt(maxMapTasks);
    out.writeInt(maxReduceTasks);
    resStatus.write(out);
    out.writeInt(taskReports.size());

    for (TaskStatus taskStatus : taskReports) {
      TaskStatus.writeTaskStatus(out, taskStatus);
    }
    getHealthStatus().write(out);
  }
317847
private void writeFields(JsonWriterImpl out, Object value)
  {
    for (JsonField field : _fields) {
      field.write(out, value);
    }
  }
766619
def dump
      out  = ""
      out << "Page #{current}\n"
      out << "  type:            #{MiqBdbPage.type2string(ptype)}\n"
      out << "  prev:            #{prev}\n"
      out << "  next:            #{@header['next_pgno']}\n"
      out << "  log seq num:     file=#{@header['lsn_file']}  offset=#{@header['lsn_offset']}\n"
      out << "  level:           #{level}\n"

      if @header['p_type'] == P_OVERFLOW
        out << "  ref cnt:         #{nentries}\n"
        out << "  len:             #{offset}\n"
      else
        out << "  entries:         #{nentries}\n"
        out << "  offset:          #{offset}\n"
      end
      out << "  data size:       #{@data.size}\n"
      out << "  data:            "

      @data.bytes.take(20).each do |c|
        out << sprintf("%.2x ", c)
      end
      out << "..." if @data.size > 20

      out << "\n\n"
      out
    end
61435
public void write(DataOutput out) throws IOException {
    out.writeInt(appId.length);
    out.write(appId);
    out.writeInt(maxCount);
  }
504914
def out io ,level
      io.write "&#{@referenced} " if @referenced
      if( is_simple? )
        short_out(io,level)
      else
        long_out(io,level)
      end
    end
728635
def write(self, data):
        """"""
        # I don't want to add a separate 'Client disconnected' logic for sending.
        # Therefore I just ignore any writes after the first error - the server
        # won't send that much data anyway. Afterwards the read will detect the
        # broken connection and we quit.
        if self._ignore_write_operations:
            return
        assert self.is_connected()
        try:
            self._connection.send(data.encode('ascii'))
        except socket.error:
            self.close()
            self._ignore_write_operations = True
1295115
private void writeObject(java.io.ObjectOutputStream out) throws IOException {
        if (svLogger.isLoggable(Level.FINER))
            svLogger.logp(Level.FINER, CLASS_NAME, "writeObject", toString());

        // if ivServer object is null throw and exception because there is no server side
        // Future object to communicate with.
        if (ivServer == null) {
            throw new EJBException("No Server side Future object exists.");
        }
        out.defaultWriteObject();
        // write out the header information
        out.write(Constants.CLIENT_ASYNC_RESULT_EYE_CATCHER);
        out.writeShort(Constants.PLATFORM_DISTRIBUTED);
        out.writeShort(Constants.CLIENT_ASYNC_RESULT_V1);

        // write out the data
        out.writeObject(ivServer);
        out.writeBoolean(ivBusinessRmiRemote);
    }
1185647
public void write(DataOutput out) throws IOException {
    taskid.write(out);
    out.writeFloat(progress);
    Text.writeString(out, state);
    out.writeLong(startTime);
    out.writeLong(finishTime);
    WritableUtils.writeStringArray(out, diagnostics);
    counters.write(out);
    WritableUtils.writeEnum(out, currentStatus);
    if (currentStatus == TIPStatus.RUNNING) {
      WritableUtils.writeVInt(out, runningAttempts.size());
      TaskAttemptID t[] = new TaskAttemptID[0];
      t = runningAttempts.toArray(t);
      for (int i = 0; i < t.length; i++) {
        t[i].write(out);
      }
    } else if (currentStatus == TIPStatus.COMPLETE) {
      successfulAttempt.write(out);
    }
  }
424384
def write(data)
      log_node(data, :out)
      if data.respond_to?(:to_xml)
        data = data.to_xml(:indent => 0)
      end
      send_data(data)
    end
1302078
def write(self, data):
        

        if self.is_closing():
            return

        self._write_buffer += data

        if len(self._write_buffer) >= self._output_buffer_limit_high:
            self._protocol.pause_writing()

        if self._write_buffer:
            self._can_write.set()
356572
def write out, indent=-1
      out << '<!ENTITY '
      out << '% ' if @reference
      out << @name
      out << ' '
      if @external
        out << @external << ' '
        if @pubid
          q = @pubid.include?('"')?"'":'"'
          out << q << @pubid << q << ' '
        end
        q = @ref.include?('"')?"'":'"'
        out << q << @ref << q
        out << ' NDATA ' << @ndata if @ndata
      else
        q = @value.include?('"')?"'":'"'
        out << q << @value << q
      end
      out << '>'
    end
666973
public void write(DataOutput out) throws IOException {
    jobid.write(out);
    Text.writeString(out, jobFile);
    Text.writeString(out, url);
    Text.writeString(out, user);
    Text.writeString(out, name);
    Text.writeString(out, queueName);
  }
1155397
public void write(final Point point) {
        this.influxDb.write(influxDbProperties.getDatabase(), influxDbProperties.getRetentionPolicy(), point);
    }
554955
def write(self, output_io):
        ''''''
        for name, tax in self.taxonomy.items():
            output_io.write("%s\t%s\n" % (name, '; '.join(tax)))
650003
def post(self, endpoint: str, **kwargs) -> dict:
        """"""

        return self._request('POST', endpoint, **kwargs)