send the given Particle to system Particle fifo

 @param [Particle] p the Particle to send
767978
def send_sys_p p
            puts " * send_sys_p #{(p.next_dst.nil? ? 'no dst' : p.next_dst)} ..." if @spin.debug_routing
            _send p, true
            puts "   -> #{p.dst.path}#{Edoors::ACT_SEP}#{p.action}" if @spin.debug_routing
            @spin.post_sys_p p
        end
1162483
def _send_packet(self, sid, pkt):
        """"""
        encoded_packet = pkt.encode()
        if isinstance(encoded_packet, list):
            binary = False
            for ep in encoded_packet:
                self.eio.send(sid, ep, binary=binary)
                binary = True
        else:
            self.eio.send(sid, encoded_packet, binary=False)
673217
def send(self_p, dest):
        
        return lib.zmsg_send(byref(zmsg_p.from_param(self_p)), dest)
726817
def sendto(self, data, addr):
        
        asyncio.ensure_future(self.__inner_protocol.send_data(data, addr))
299725
def send_frame(self, frame):
        

        self._sendbuf += self._send_streamify(frame)
        self._sendbuf_event.set()
147970
function send(){
  this.forEach(function(worker){
    worker.send.apply(worker, [].slice.apply(arguments));
  });
}
615344
def send(self_p, dest, flags):
        
        return lib.zframe_send(byref(zframe_p.from_param(self_p)), dest, flags)
56749
def sendintr(self):
        ''' '''

        n, byte = self.ptyproc.sendintr()
        self._log_control(byte)
1187909
def send_position_setpoint(self, x, y, z, yaw):
        
        pk = CRTPPacket()
        pk.port = CRTPPort.COMMANDER_GENERIC
        pk.data = struct.pack('<Bffff', TYPE_POSITION,
                              x, y, z, yaw)
        self._cf.send_packet(pk)
299195
def send(self, p):
        """"""
        with self.send_mutex:
            self.begin_send(p)

            # Wait until the tx callback is called
            self.tx_done.wait()
            if self.tx_exception is not None:
                raise Scapy_Exception(self.tx_exception)
            return
331850
async def _send_packet(self, pkt):
        """"""
        if self.state != 'connected':
            return
        await self.queue.put(pkt)
        self.logger.info(
            'Sending packet %s data %s',
            packet.packet_names[pkt.packet_type],
            pkt.data if not isinstance(pkt.data, bytes) else '<binary>')
1237150
def send(self, data):
        """"""
        self._send_data(int_to_hex(len(data)))

        self._send_data(data)
850898
def send_message(self, output):
        

        file_system_event = None
        if self.my_action_input:
            file_system_event = self.my_action_input.file_system_event or None

        output_action = ActionInput(file_system_event,
                                    output,
                                    self.name,
                                    "*")

        Global.MESSAGE_DISPATCHER.send_message(output_action)
1020125
def _send_chunk(self, index, chunk):
        
        self._pending_chunks += 1
        self.outbox.put((index, chunk))
1260112
def _sendReply(self, destination, fid, *args):
        """"""
        # Try to send the result directly to its parent
        self.addPeer(destination)

        try:
            self.direct_socket.send_multipart([
                destination,
                REPLY,
            ] + list(args),
                flags=zmq.NOBLOCK)
        except zmq.error.ZMQError as e:
            # Fallback on Broker routing if no direct connection possible
            scoop.logger.debug(
                "{0}: Could not send result directly to peer {1}, routing through "
                "broker.".format(scoop.worker, destination)
            )
            self.socket.send_multipart([
                REPLY, 
                ] + list(args) + [
                destination,
            ])

        self.socket.send_multipart([
            STATUS_DONE,
            fid,
        ])
1329578
def send_one_packet(old_packet = nil)
      pf = packet_format
      raise(Errors::NotImplemented, "Unimplemented packet format: #{pf}") unless IMPLEMENTED_FORMATS.include?(pf)

      write('APISPK')

      case pf
      when :list
        read(:expect => /^.*<EOP>$/, :wait => true)
      when :bin48_net_time
        packet = read(:length => 625, :wait => true)
        Packet::Bin48NetTime.read(StringIO.new(packet), old_packet)
      when :bin48_net
        packet = read(:length => 619, :wait => true)
        Packet::Bin48Net.read(StringIO.new(packet), old_packet)
      when :bin48_abs
        packet = read(:length => 379, :wait => true)
        Packet::Bin48Abs.read(StringIO.new(packet), old_packet)
      when :bin32_net
        packet = read(:length => 429, :wait => true)
        Packet::Bin32Net.read(StringIO.new(packet), old_packet)
      when :bin32_abs
        packet = read(:length => 269, :wait => true)
        Packet::Bin32Abs.read(StringIO.new(packet), old_packet)
      end
    end
145087
def process_sys_p p
            if p.action==Edoors::SYS_ACT_ADD_LINK
                add_link Edoors::Link.from_particle p
            elsif p.action==Edoors::SYS_ACT_ADD_ROOM
                Edoors::Room.from_particle p, self
            end
            @spin.release_p p
        end