[Python-checkins] r67103 - in sandbox/trunk/io-c: io.c io.py

Tue Nov 4 22:37:44 CET 2008

Author: amaury.forgeotdarc
Date: Tue Nov 4 22:37:44 2008
New Revision: 67103
Log:
Implement io.BufferedRWPair
Modified:
 sandbox/trunk/io-c/io.c
 sandbox/trunk/io-c/io.py
Modified: sandbox/trunk/io-c/io.c
==============================================================================

--- sandbox/trunk/io-c/io.c	(original)
+++ sandbox/trunk/io-c/io.c	Tue Nov 4 22:37:44 2008
@@ -726,6 +726,7 @@
 Py_RETURN_FALSE;
 }
 
+/* May be called with any object */
 static int
 IOBase_checkReadable(PyObject *self)
 {
@@ -752,6 +753,7 @@
 Py_RETURN_FALSE;
 }
 
+/* May be called with any object */
 static int
 IOBase_checkWritable(PyObject *self)
 {
@@ -1561,7 +1563,7 @@
 self->raw = raw;
 
 self->buffer_size = buffer_size;
- self->read_buf = NULL;
+ self->read_buf = NULL;
 
 if( _BufferedReader_reset_read_buf(self) < 0)
 return -1;
@@ -2379,6 +2381,227 @@
 };
 
 
+
+/*
+ * BufferedRWPair
+ */
+
+PyDoc_STRVAR(BufferedRWPair_doc,
+ "A buffered reader and writer object together.\n"
+ "\n"
+ "A buffered reader object and buffered writer object put together to\n"
+ "form a sequential IO object that can read and write. This is typically\n"
+ "used with a socket or two-way pipe.\n"
+ "\n"
+ "reader and writer are RawIOBase objects that are readable and\n"
+ "writeable respectively. If the buffer_size is omitted it defaults to\n"
+ "DEFAULT_BUFFER_SIZE. The max_buffer_size (for the buffered writer)\n"
+ "defaults to twice the buffer size.\n"
+ );
+
+/* XXX The usefulness of this (compared to having two separate IO objects) is
+ * questionable.
+ */
+
+typedef struct {
+ PyObject_HEAD
+ BufferedObject *reader;
+ BufferedObject *writer;
+} BufferedRWPairObject;
+
+static int
+BufferedRWPair_init(BufferedRWPairObject *self, PyObject *args,
+ PyObject *kwds)
+{
+ PyObject *reader, *writer;
+ Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
+ Py_ssize_t max_buffer_size = -1;
+
+ if (!PyArg_ParseTuple(args, "OO|nn:BufferedRWPair", &reader, &writer,
+			 &buffer_size, &max_buffer_size)) {
+ return -1;
+ }
+
+ if (IOBase_checkReadable(reader) < 0)
+	return -1;
+ if (IOBase_checkWritable(writer) < 0)
+	return -1;
+
+ args = Py_BuildValue("(n)", buffer_size);
+ if (args == NULL) {
+	Py_CLEAR(self->reader);
+	return -1;
+ }
+ self->reader = (BufferedObject*)PyType_GenericNew(&BufferedReader_Type, args, NULL);
+ Py_DECREF(args);
+ if (self->reader == NULL)
+	return -1;
+
+ args = Py_BuildValue("(nn)", buffer_size, max_buffer_size);
+ if (args == NULL) {
+	Py_CLEAR(self->reader);
+	return -1;
+ }
+ self->writer = (BufferedObject*)PyType_GenericNew(&BufferedWriter_Type, args, NULL);
+ Py_DECREF(args);
+ if (self->writer == NULL) {
+	Py_CLEAR(self->reader);
+	return -1;
+ }
+ return 0;
+}
+
+static void
+BufferedRWPair_dealloc(BufferedRWPairObject *self)
+{
+ Py_CLEAR(self->reader);
+ Py_CLEAR(self->writer);
+}
+
+static PyObject *
+_forward_call(BufferedObject *self, const char* name, PyObject *args)
+{
+ PyObject *func = PyObject_GetAttrString((PyObject*)self, name);
+ PyObject *ret;
+
+ if (func == NULL) {
+	PyErr_SetString(PyExc_AttributeError, name);
+	return NULL;
+ }
+
+ ret = PyObject_CallObject(func, args);
+ Py_DECREF(func);
+ return ret;
+}
+
+static PyObject *
+BufferedRWPair_read(BufferedRWPairObject *self, PyObject *args)
+{
+ return _forward_call(self->reader, "read", args);
+}
+
+static PyObject *
+BufferedRWPair_peek(BufferedRWPairObject *self, PyObject *args)
+{
+ return _forward_call(self->reader, "peek", args);
+}
+
+static PyObject *
+BufferedRWPair_read1(BufferedRWPairObject *self, PyObject *args)
+{
+ return _forward_call(self->reader, "read1", args);
+}
+
+static PyObject *
+BufferedRWPair_write(BufferedRWPairObject *self, PyObject *args)
+{
+ return _forward_call(self->writer, "write", args);
+}
+
+static PyObject *
+BufferedRWPair_flush(BufferedRWPairObject *self, PyObject *args)
+{
+ return _forward_call(self->writer, "flush", args);
+}
+
+static PyObject *
+BufferedRWPair_readable(BufferedRWPairObject *self, PyObject *args)
+{
+ return _forward_call(self->reader, "readable", args);
+}
+
+static PyObject *
+BufferedRWPair_writable(BufferedRWPairObject *self, PyObject *args)
+{
+ return _forward_call(self->writer, "writable", args);
+}
+
+static PyObject *
+BufferedRWPair_close(BufferedRWPairObject *self, PyObject *args)
+{
+ PyObject *ret = _forward_call(self->writer, "close", args);
+ if (ret == NULL)
+	return NULL;
+ Py_DECREF(ret);
+
+ return _forward_call(self->reader, "close", args);
+}
+
+static PyObject *
+BufferedRWPair_isatty(BufferedRWPairObject *self, PyObject *args)
+{
+ PyObject *ret = _forward_call(self->writer, "isatty", args);
+
+ if (ret != Py_False) {
+	/* either True or exception */
+	return ret;
+ }
+ Py_DECREF(ret);
+
+ return _forward_call(self->reader, "isatty", args);
+}
+
+
+static PyMethodDef BufferedRWPair_methods[] = {
+ {"read", (PyCFunction)BufferedRWPair_read, METH_VARARGS},
+ {"peek", (PyCFunction)BufferedRWPair_peek, METH_VARARGS},
+ {"read1", (PyCFunction)BufferedRWPair_read1, METH_VARARGS},
+
+ {"write", (PyCFunction)BufferedRWPair_write, METH_VARARGS},
+ {"flush", (PyCFunction)BufferedRWPair_flush, METH_NOARGS},
+
+ {"readable", (PyCFunction)BufferedRWPair_readable, METH_NOARGS},
+ {"writable", (PyCFunction)BufferedRWPair_writable, METH_NOARGS},
+
+ {"close", (PyCFunction)BufferedRWPair_close, METH_NOARGS},
+ {"isatty", (PyCFunction)BufferedRWPair_isatty, METH_NOARGS},
+
+ {NULL, NULL}
+};
+
+PyTypeObject BufferedRWPair_Type = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "BufferedRWPair", /*tp_name*/
+ sizeof(BufferedObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ (destructor)BufferedRWPair_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare */
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash */
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ BufferedRWPair_doc, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ offsetof(BufferedObject, weakreflist), /*tp_weaklistoffset*/
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ BufferedRWPair_methods, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ offsetof(BufferedObject, dict), /* tp_dictoffset */
+ (initproc)BufferedRWPair_init, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew, /* tp_new */
+};
+
+
+
 /*
 * BufferedRandom
 */
@@ -2769,6 +2992,13 @@
 Py_INCREF(&BufferedWriter_Type);
 PyModule_AddObject(m, "BufferedWriter", (PyObject *) &BufferedWriter_Type);
 
+ /* BufferedRWPair */
+ BufferedRWPair_Type.tp_base = &_BufferedIOBase_Type;
+ if (PyType_Ready(&BufferedRWPair_Type) < 0)
+ goto fail;
+ Py_INCREF(&BufferedRWPair_Type);
+ PyModule_AddObject(m, "BufferedRWPair", (PyObject *) &BufferedRWPair_Type);
+
 /* BufferedRandom */
 BufferedRandom_Type.tp_base = &_BufferedIOBase_Type;
 if (PyType_Ready(&BufferedRandom_Type) < 0)
Modified: sandbox/trunk/io-c/io.py
==============================================================================
--- sandbox/trunk/io-c/io.py	(original)
+++ sandbox/trunk/io-c/io.py	Tue Nov 4 22:37:44 2008
@@ -1106,7 +1106,7 @@
 BufferedWriter = _io.BufferedWriter
 
 
-class BufferedRWPair(BufferedIOBase):
+class unused_BufferedRWPair(BufferedIOBase):
 
 """A buffered reader and writer object together.
 
@@ -1170,6 +1170,7 @@
 @property
 def closed(self):
 return self.writer.closed()
+BufferedRWPair = _io.BufferedRWPair
 
 class unused_BufferedRandom(unused_BufferedWriter, unused_BufferedReader):
 
