WIP on sq_ass_item

Author: paulross

doc/sphinx/source/new_types.rst

@@ -913,6 +913,112 @@ Tests are in ``tests/unit/test_c_seqobject.py`` which includes failure modes:
  assert err.value.args[0] == expected
 
 
+---------------
+``sq_ass_item``
+---------------
+
+`sq_ass_item`_ gives write and delete access to an indexed member.
+
+.. list-table:: Sequence Methods: ``sq_ass_item``
+ :widths: 20 80
+ :header-rows: 0
+
+ * - Member
+ - `sq_ass_item`_
+ * - Function type
+ - `ssizeobjargproc`_
+ * - Function signature
+ - ``int (*ssizeobjargproc)(PyObject*, Py_ssize_t, PyObject*)``
+ * - Description
+ - Sets the the n'th item in the sequence.
+ If the value is NULL the item is deleted and the sequence concatenated (thus called by `PyObject_DelItem()`_).
+ Negative indexes are handled appropriately.
+ Used by `PyObject_SetItem()`_.
+
+Implementation
+--------------
+
+In ``src/cpy/Object/cSeqObject.c``:
+
+.. code-block:: c
+
+ /** Returns a new reference to an indexed item in a sequence. */
+ static PyObject *
+ SequenceLongObject_sq_item(PyObject *self, Py_ssize_t index) {
+ Py_ssize_t my_index = index;
+ if (my_index < 0) {
+ my_index += SequenceLongObject_sq_length(self);
+ }
+ // Corner case example: len(self) == 0 and index < 0
+ if (my_index < 0 || my_index >= SequenceLongObject_sq_length(self)) {
+ PyErr_Format(
+ PyExc_IndexError,
+ "Index %ld is out of range for length %ld",
+ index,
+ SequenceLongObject_sq_length(self)
+ );
+ return NULL;
+ }
+ return PyLong_FromLong(((SequenceLongObject *) self)->array_long[my_index]);
+ }
+
+Tests
+--------------
+
+Tests are in ``tests/unit/test_c_seqobject.py`` which includes failure modes:
+
+.. code-block:: python
+
+ from cPyExtPatt import cSeqObject
+
+ @pytest.mark.parametrize(
+ 'initial_sequence, index, expected',
+ (
+ (
+ [7, 4, 1, ], 0, 7,
+ ),
+ (
+ [7, 4, 1, ], 1, 4,
+ ),
+ (
+ [7, 4, 1, ], 2, 1,
+ ),
+ (
+ [7, 4, 1, ], -1, 1,
+ ),
+ (
+ [7, 4, 1, ], -2, 4,
+ ),
+ (
+ [7, 4, 1, ], -3, 7,
+ ),
+ )
+ )
+ def test_SequenceLongObject_item(initial_sequence, index, expected):
+ obj = cSeqObject.SequenceLongObject(initial_sequence)
+ assert obj[index] == expected
+
+ @pytest.mark.parametrize(
+ 'initial_sequence, index, expected',
+ (
+ (
+ [], 0, 'Index 0 is out of range for length 0',
+ ),
+ (
+ [], -1, 'Index -1 is out of range for length 0',
+ ),
+ (
+ [1, ], 2, 'Index 2 is out of range for length 1',
+ ),
+ )
+ )
+ def test_SequenceLongObject_item_raises(initial_sequence, index, expected):
+ obj = cSeqObject.SequenceLongObject(initial_sequence)
+ with pytest.raises(IndexError) as err:
+ obj[index]
+ assert err.value.args[0] == expected
+
+
 
 
 

src/cpy/Object/cSeqObject.c

@@ -215,13 +215,96 @@ SequenceLongObject_sq_item(PyObject *self, Py_ssize_t index) {
  }
  return PyLong_FromLong(((SequenceLongObject *) self)->array_long[my_index]);
 }
+static int
+SequenceLongObject_sq_ass_item(PyObject *self, Py_ssize_t index, PyObject *value) {
+ Py_ssize_t my_index = index;
+ if (my_index < 0) {
+ my_index += SequenceLongObject_sq_length(self);
+ }
+ // Corner case example: len(self) == 0 and index < 0
+ if (my_index < 0 || my_index >= SequenceLongObject_sq_length(self)) {
+ PyErr_Format(
+ PyExc_IndexError,
+ "Index %ld is out of range for length %ld",
+ index,
+ SequenceLongObject_sq_length(self)
+ );
+ return -1;
+ }
+ if (value != NULL) {
+ /* Just set the value. */
+ if (!PyLong_Check(value)) {
+ PyErr_Format(
+ PyExc_TypeError,
+ "sq_ass_item value needs to be an int, not type %s",
+ Py_TYPE(value)->tp_name
+ );
+ return -1;
+ }
+ ((SequenceLongObject *) self)->array_long[my_index] = PyLong_AsLong(value);
+ } else {
+ /* Delete the value. */
+ /* For convenience. */
+ SequenceLongObject *self_as_slo = (SequenceLongObject *) self;
+ /* Special case: deleting the only item in the array. */
+ if (self_as_slo->size == 1) {
+ free(self_as_slo->array_long);
+ self_as_slo->array_long = NULL;
+ self_as_slo->size = 0;
+ } else {
+ /* Delete the value and re-compose the array. */
+ long *new_array = malloc((self_as_slo->size - 1) * sizeof(long));
+ if (!new_array) {
+ PyErr_Format(
+ PyExc_MemoryError,
+ "sq_ass_item can not allocate new array. %s#%d",
+ __FILE__, __LINE__
+ );
+ return -1;
+ }
+ /* memcpy across to the new array, firstly up to the index. */
+ void *dest = NULL;
+ void *src = NULL;
+ size_t count = 0;
+
+ dest = new_array;
+ src = self_as_slo->array_long;
+ count = my_index * sizeof(long);
+ if (memcpy(dest, src, count) != dest) {
+ PyErr_Format(
+ PyExc_MemoryError,
+ "sq_ass_item can not memcpy into new array. %s#%d",
+ __FILE__, __LINE__
+ );
+ return -1;
+ }
+ /* memcpy across to the new array, from the index to the end. */
+ dest = new_array + count;
+ src = self_as_slo->array_long + (count - sizeof(long));
+ /* Example size=4, index=2 copy one value */
+ count = (self_as_slo->size - my_index - 1) * sizeof(long);
+ if (memcpy(dest, src, count) != dest) {
+ PyErr_Format(
+ PyExc_MemoryError,
+ "sq_ass_item can not memcpy into new array. %s#%d",
+ __FILE__, __LINE__
+ );
+ return -1;
+ }
+ free(self_as_slo->array_long);
+ self_as_slo->array_long = new_array;
+ --self_as_slo->size;
+ }
+ }
+ return 0;
+}
 
 PySequenceMethods SequenceLongObject_sequence_methods = {
  .sq_length = &SequenceLongObject_sq_length,
  .sq_concat = &SequenceLongObject_sq_concat,
  .sq_repeat = &SequenceLongObject_sq_repeat,
  .sq_item = &SequenceLongObject_sq_item,
- .sq_ass_item = NULL,
+ .sq_ass_item = &SequenceLongObject_sq_ass_item,
  .sq_contains = NULL,
  .sq_inplace_concat = NULL,
  .sq_inplace_repeat = NULL,

tests/unit/test_c_seqobject.py

@@ -16,6 +16,7 @@ def test_SequenceLongObject_dir():
  '__add__',
  '__class__',
  '__delattr__',
+ '__delitem__',
  '__dir__',
  '__doc__',
  '__eq__',
@@ -39,6 +40,7 @@ def test_SequenceLongObject_dir():
  '__repr__',
  '__rmul__',
  '__setattr__',
+ '__setitem__',
  '__sizeof__',
  '__str__',
  '__subclasshook__',
@@ -144,6 +146,36 @@ def test_SequenceLongObject_item_raises(initial_sequence, index, expected):
  obj[index]
  assert err.value.args[0] == expected
 
+
+@pytest.mark.parametrize(
+ 'initial_sequence, index, value, expected',
+ (
+ (
+ [7, 4, 1, ], 0, 14, [14, 4, 1, ],
+ ),
+ (
+ [7, 4, 1, ], -1, 14, [7, 4, 14, ],
+ ),
+ (
+ [7,], 0, None, [],
+ ),
+ (
+ [7,], -1, None, [],
+ ),
+ (
+ [7, 4, 1, ], 0, None, [4, 14, ],
+ ),
+ )
+)
+def test_SequenceLongObject_setitem(initial_sequence, index, value, expected):
+ obj = cSeqObject.SequenceLongObject(initial_sequence)
+ if value is not None:
+ obj[index] = value
+ else:
+ del obj[index]
+ assert list(obj) == expected
+
+
 # @pytest.mark.skipif(not (sys.version_info.minor < 7), reason='Python < 3.7')
 # def test_str_dir_pre_37():
 # s = cObject.Str()