Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 1 | # -*- Mode: Python; tab-width: 4 -*- |
Tim Peters | 658cba6 | 2001-02-09 20:06:00 +0000 | [diff] [blame] | 2 | # Id: asynchat.py,v 2.26 2000/09/07 22:29:26 rushing Exp |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 3 | # Author: Sam Rushing <rushing@nightmare.com> |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 4 | |
| 5 | # ====================================================================== |
| 6 | # Copyright 1996 by Sam Rushing |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 7 | # |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 8 | # All Rights Reserved |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 9 | # |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 10 | # Permission to use, copy, modify, and distribute this software and |
| 11 | # its documentation for any purpose and without fee is hereby |
| 12 | # granted, provided that the above copyright notice appear in all |
| 13 | # copies and that both that copyright notice and this permission |
| 14 | # notice appear in supporting documentation, and that the name of Sam |
| 15 | # Rushing not be used in advertising or publicity pertaining to |
| 16 | # distribution of the software without specific, written prior |
| 17 | # permission. |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 18 | # |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 19 | # SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, |
| 20 | # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN |
| 21 | # NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR |
| 22 | # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS |
| 23 | # OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, |
| 24 | # NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 25 | # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| 26 | # ====================================================================== |
| 27 | |
Guido van Rossum | e4a1b6d | 2001-04-06 15:30:33 +0000 | [diff] [blame] | 28 | r"""A class supporting chat-style (command/response) protocols. |
Guido van Rossum | 4b8c6ea | 2000-02-04 15:39:30 +0000 | [diff] [blame] | 29 | |
| 30 | This class adds support for 'chat' style protocols - where one side |
| 31 | sends a 'command', and the other sends a response (examples would be |
| 32 | the common internet protocols - smtp, nntp, ftp, etc..). |
| 33 | |
| 34 | The handle_read() method looks at the input stream for the current |
| 35 | 'terminator' (usually '\r\n' for single-line responses, '\r\n.\r\n' |
| 36 | for multi-line output), calling self.found_terminator() on its |
| 37 | receipt. |
| 38 | |
| 39 | for example: |
| 40 | Say you build an async nntp client using this class. At the start |
| 41 | of the connection, you'll have self.terminator set to '\r\n', in |
| 42 | order to process the single-line greeting. Just before issuing a |
| 43 | 'LIST' command you'll set it to '\r\n.\r\n'. The output of the LIST |
| 44 | command will be accumulated (using your own 'collect_incoming_data' |
| 45 | method) up to the terminator, and then control will be returned to |
| 46 | you - by calling your self.found_terminator() method. |
| 47 | """ |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 48 | import socket |
| 49 | import asyncore |
Raymond Hettinger | ac093c6 | 2004-02-07 03:19:10 +0000 | [diff] [blame] | 50 | from collections import deque |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 51 | |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 52 | |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 53 | class async_chat (asyncore.dispatcher): |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 54 | """This is an abstract class. You must derive from this class, and add |
| 55 | the two methods collect_incoming_data() and found_terminator()""" |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 56 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 57 | # these are overridable defaults |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 58 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 59 | ac_in_buffer_size = 4096 |
| 60 | ac_out_buffer_size = 4096 |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 61 | |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 62 | # we don't want to enable the use of encoding by default, because that is a |
| 63 | # sign of an application bug that we don't want to pass silently |
| 64 | |
| 65 | use_encoding = 0 |
Marc-André Lemburg | 8f36af7 | 2011-02-25 15:42:01 +0000 | [diff] [blame] | 66 | encoding = 'latin-1' |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 67 | |
Josiah Carlson | 9f2f833 | 2008-07-07 05:04:12 +0000 | [diff] [blame] | 68 | def __init__ (self, sock=None, map=None): |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 69 | # for string terminator matching |
Guido van Rossum | 076da09 | 2007-07-12 07:58:54 +0000 | [diff] [blame] | 70 | self.ac_in_buffer = b'' |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 71 | |
| 72 | # we use a list here rather than cStringIO for a few reasons... |
| 73 | # del lst[:] is faster than sio.truncate(0) |
| 74 | # lst = [] is faster than sio.truncate(0) |
| 75 | # cStringIO will be gaining unicode support in py3k, which |
| 76 | # will negatively affect the performance of bytes compared to |
| 77 | # a ''.join() equivalent |
| 78 | self.incoming = [] |
| 79 | |
| 80 | # we toss the use of the "simple producer" and replace it with |
| 81 | # a pure deque, which the original fifo was a wrapping of |
| 82 | self.producer_fifo = deque() |
Josiah Carlson | 9f2f833 | 2008-07-07 05:04:12 +0000 | [diff] [blame] | 83 | asyncore.dispatcher.__init__ (self, sock, map) |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 84 | |
Andrew M. Kuchling | 7dd5f3c | 2002-03-08 18:27:11 +0000 | [diff] [blame] | 85 | def collect_incoming_data(self, data): |
Collin Winter | ce36ad8 | 2007-08-30 01:19:48 +0000 | [diff] [blame] | 86 | raise NotImplementedError("must be implemented in subclass") |
Tim Peters | 863ac44 | 2002-04-16 01:38:40 +0000 | [diff] [blame] | 87 | |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 88 | def _collect_incoming_data(self, data): |
| 89 | self.incoming.append(data) |
| 90 | |
| 91 | def _get_data(self): |
| 92 | d = b''.join(self.incoming) |
| 93 | del self.incoming[:] |
| 94 | return d |
| 95 | |
Andrew M. Kuchling | 7dd5f3c | 2002-03-08 18:27:11 +0000 | [diff] [blame] | 96 | def found_terminator(self): |
Collin Winter | ce36ad8 | 2007-08-30 01:19:48 +0000 | [diff] [blame] | 97 | raise NotImplementedError("must be implemented in subclass") |
Tim Peters | 863ac44 | 2002-04-16 01:38:40 +0000 | [diff] [blame] | 98 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 99 | def set_terminator (self, term): |
| 100 | "Set the input delimiter. Can be a fixed string of any length, an integer, or None" |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 101 | if isinstance(term, str) and self.use_encoding: |
| 102 | term = bytes(term, self.encoding) |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 103 | self.terminator = term |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 104 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 105 | def get_terminator (self): |
| 106 | return self.terminator |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 107 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 108 | # grab some more data from the socket, |
| 109 | # throw it to the collector method, |
| 110 | # check for the terminator, |
| 111 | # if found, transition to the next state. |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 112 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 113 | def handle_read (self): |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 114 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 115 | try: |
| 116 | data = self.recv (self.ac_in_buffer_size) |
Guido van Rossum | b940e11 | 2007-01-10 16:19:56 +0000 | [diff] [blame] | 117 | except socket.error as why: |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 118 | self.handle_error() |
| 119 | return |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 120 | |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 121 | if isinstance(data, str) and self.use_encoding: |
| 122 | data = bytes(str, self.encoding) |
| 123 | self.ac_in_buffer = self.ac_in_buffer + data |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 124 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 125 | # Continue to search for self.terminator in self.ac_in_buffer, |
| 126 | # while calling self.collect_incoming_data. The while loop |
| 127 | # is necessary because we might read several data+terminator |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 128 | # combos with a single recv(4096). |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 129 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 130 | while self.ac_in_buffer: |
| 131 | lb = len(self.ac_in_buffer) |
| 132 | terminator = self.get_terminator() |
Andrew M. Kuchling | ca69f02 | 2005-06-09 14:59:45 +0000 | [diff] [blame] | 133 | if not terminator: |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 134 | # no terminator, collect it all |
| 135 | self.collect_incoming_data (self.ac_in_buffer) |
Guido van Rossum | 806c246 | 2007-08-06 23:33:07 +0000 | [diff] [blame] | 136 | self.ac_in_buffer = b'' |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 137 | elif isinstance(terminator, int): |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 138 | # numeric terminator |
| 139 | n = terminator |
| 140 | if lb < n: |
| 141 | self.collect_incoming_data (self.ac_in_buffer) |
Guido van Rossum | 076da09 | 2007-07-12 07:58:54 +0000 | [diff] [blame] | 142 | self.ac_in_buffer = b'' |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 143 | self.terminator = self.terminator - lb |
| 144 | else: |
| 145 | self.collect_incoming_data (self.ac_in_buffer[:n]) |
| 146 | self.ac_in_buffer = self.ac_in_buffer[n:] |
| 147 | self.terminator = 0 |
| 148 | self.found_terminator() |
| 149 | else: |
| 150 | # 3 cases: |
| 151 | # 1) end of buffer matches terminator exactly: |
| 152 | # collect data, transition |
| 153 | # 2) end of buffer matches some prefix: |
| 154 | # collect data to the prefix |
| 155 | # 3) end of buffer does not match any prefix: |
| 156 | # collect data |
| 157 | terminator_len = len(terminator) |
Tim Peters | b5d1392 | 2001-04-05 22:38:32 +0000 | [diff] [blame] | 158 | index = self.ac_in_buffer.find(terminator) |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 159 | if index != -1: |
| 160 | # we found the terminator |
| 161 | if index > 0: |
| 162 | # don't bother reporting the empty string (source of subtle bugs) |
| 163 | self.collect_incoming_data (self.ac_in_buffer[:index]) |
| 164 | self.ac_in_buffer = self.ac_in_buffer[index+terminator_len:] |
| 165 | # This does the Right Thing if the terminator is changed here. |
| 166 | self.found_terminator() |
| 167 | else: |
| 168 | # check for a prefix of the terminator |
| 169 | index = find_prefix_at_end (self.ac_in_buffer, terminator) |
| 170 | if index: |
| 171 | if index != lb: |
| 172 | # we found a prefix, collect up to the prefix |
| 173 | self.collect_incoming_data (self.ac_in_buffer[:-index]) |
| 174 | self.ac_in_buffer = self.ac_in_buffer[-index:] |
| 175 | break |
| 176 | else: |
| 177 | # no prefix, collect it all |
| 178 | self.collect_incoming_data (self.ac_in_buffer) |
Guido van Rossum | 076da09 | 2007-07-12 07:58:54 +0000 | [diff] [blame] | 179 | self.ac_in_buffer = b'' |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 180 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 181 | def handle_write (self): |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 182 | self.initiate_send() |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 183 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 184 | def handle_close (self): |
| 185 | self.close() |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 186 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 187 | def push (self, data): |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 188 | sabs = self.ac_out_buffer_size |
| 189 | if len(data) > sabs: |
| 190 | for i in range(0, len(data), sabs): |
| 191 | self.producer_fifo.append(data[i:i+sabs]) |
| 192 | else: |
| 193 | self.producer_fifo.append(data) |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 194 | self.initiate_send() |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 195 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 196 | def push_with_producer (self, producer): |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 197 | self.producer_fifo.append(producer) |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 198 | self.initiate_send() |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 199 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 200 | def readable (self): |
| 201 | "predicate for inclusion in the readable for select()" |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 202 | # cannot use the old predicate, it violates the claim of the |
| 203 | # set_terminator method. |
| 204 | |
| 205 | # return (len(self.ac_in_buffer) <= self.ac_in_buffer_size) |
| 206 | return 1 |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 207 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 208 | def writable (self): |
| 209 | "predicate for inclusion in the writable for select()" |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 210 | return self.producer_fifo or (not self.connected) |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 211 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 212 | def close_when_done (self): |
| 213 | "automatically close this channel once the outgoing queue is empty" |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 214 | self.producer_fifo.append(None) |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 215 | |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 216 | def initiate_send(self): |
| 217 | while self.producer_fifo and self.connected: |
| 218 | first = self.producer_fifo[0] |
| 219 | # handle empty string/buffer or None entry |
| 220 | if not first: |
| 221 | del self.producer_fifo[0] |
| 222 | if first is None: |
| 223 | ## print("first is None") |
| 224 | self.handle_close() |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 225 | return |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 226 | ## print("first is not None") |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 227 | |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 228 | # handle classic producer behavior |
| 229 | obs = self.ac_out_buffer_size |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 230 | try: |
Giampaolo Rodola' | d9f38bc | 2012-08-04 14:38:16 +0200 | [diff] [blame] | 231 | data = first[:obs] |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 232 | except TypeError: |
| 233 | data = first.more() |
| 234 | if data: |
| 235 | self.producer_fifo.appendleft(data) |
| 236 | else: |
| 237 | del self.producer_fifo[0] |
| 238 | continue |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 239 | |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 240 | if isinstance(data, str) and self.use_encoding: |
| 241 | data = bytes(data, self.encoding) |
| 242 | |
| 243 | # send the data |
| 244 | try: |
| 245 | num_sent = self.send(data) |
| 246 | except socket.error: |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 247 | self.handle_error() |
| 248 | return |
| 249 | |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 250 | if num_sent: |
| 251 | if num_sent < len(data) or obs < len(first): |
| 252 | self.producer_fifo[0] = first[num_sent:] |
| 253 | else: |
| 254 | del self.producer_fifo[0] |
| 255 | # we tried to send some actual data |
| 256 | return |
| 257 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 258 | def discard_buffers (self): |
| 259 | # Emergencies only! |
Guido van Rossum | 076da09 | 2007-07-12 07:58:54 +0000 | [diff] [blame] | 260 | self.ac_in_buffer = b'' |
Josiah Carlson | d74900e | 2008-07-07 04:15:08 +0000 | [diff] [blame] | 261 | del self.incoming[:] |
| 262 | self.producer_fifo.clear() |
Andrew M. Kuchling | da85a27 | 2000-09-08 20:30:39 +0000 | [diff] [blame] | 263 | |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 264 | class simple_producer: |
Guido van Rossum | a8d0f4f | 1999-06-08 13:20:05 +0000 | [diff] [blame] | 265 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 266 | def __init__ (self, data, buffer_size=512): |
| 267 | self.data = data |
| 268 | self.buffer_size = buffer_size |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 269 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 270 | def more (self): |
| 271 | if len (self.data) > self.buffer_size: |
| 272 | result = self.data[:self.buffer_size] |
| 273 | self.data = self.data[self.buffer_size:] |
| 274 | return result |
| 275 | else: |
| 276 | result = self.data |
Guido van Rossum | 076da09 | 2007-07-12 07:58:54 +0000 | [diff] [blame] | 277 | self.data = b'' |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 278 | return result |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 279 | |
| 280 | class fifo: |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 281 | def __init__ (self, list=None): |
| 282 | if not list: |
Raymond Hettinger | ac093c6 | 2004-02-07 03:19:10 +0000 | [diff] [blame] | 283 | self.list = deque() |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 284 | else: |
Raymond Hettinger | ac093c6 | 2004-02-07 03:19:10 +0000 | [diff] [blame] | 285 | self.list = deque(list) |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 286 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 287 | def __len__ (self): |
| 288 | return len(self.list) |
Guido van Rossum | a8d0f4f | 1999-06-08 13:20:05 +0000 | [diff] [blame] | 289 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 290 | def is_empty (self): |
Armin Rigo | b562bc6 | 2004-09-27 17:49:00 +0000 | [diff] [blame] | 291 | return not self.list |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 292 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 293 | def first (self): |
Raymond Hettinger | 0a4977c | 2004-03-01 23:16:22 +0000 | [diff] [blame] | 294 | return self.list[0] |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 295 | |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 296 | def push (self, data): |
Raymond Hettinger | ac093c6 | 2004-02-07 03:19:10 +0000 | [diff] [blame] | 297 | self.list.append(data) |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 298 | |
| 299 | def pop (self): |
| 300 | if self.list: |
Raymond Hettinger | ac093c6 | 2004-02-07 03:19:10 +0000 | [diff] [blame] | 301 | return (1, self.list.popleft()) |
Tim Peters | 146965a | 2001-01-14 18:09:23 +0000 | [diff] [blame] | 302 | else: |
| 303 | return (0, None) |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 304 | |
| 305 | # Given 'haystack', see if any prefix of 'needle' is at its end. This |
| 306 | # assumes an exact match has already been checked. Return the number of |
| 307 | # characters matched. |
| 308 | # for example: |
| 309 | # f_p_a_e ("qwerty\r", "\r\n") => 1 |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 310 | # f_p_a_e ("qwertydkjf", "\r\n") => 0 |
Andrew M. Kuchling | c63a396 | 2002-03-20 02:22:58 +0000 | [diff] [blame] | 311 | # f_p_a_e ("qwerty\r\n", "\r\n") => <undefined> |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 312 | |
| 313 | # this could maybe be made faster with a computed regex? |
Andrew M. Kuchling | d305f51 | 2001-01-24 21:10:55 +0000 | [diff] [blame] | 314 | # [answer: no; circa Python-2.0, Jan 2001] |
Andrew M. Kuchling | c63a396 | 2002-03-20 02:22:58 +0000 | [diff] [blame] | 315 | # new python: 28961/s |
| 316 | # old python: 18307/s |
Andrew M. Kuchling | d305f51 | 2001-01-24 21:10:55 +0000 | [diff] [blame] | 317 | # re: 12820/s |
| 318 | # regex: 14035/s |
Guido van Rossum | 0039d7b | 1999-01-12 20:19:27 +0000 | [diff] [blame] | 319 | |
| 320 | def find_prefix_at_end (haystack, needle): |
Tim Peters | 863ac44 | 2002-04-16 01:38:40 +0000 | [diff] [blame] | 321 | l = len(needle) - 1 |
| 322 | while l and not haystack.endswith(needle[:l]): |
| 323 | l -= 1 |
| 324 | return l |