This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11118

dirstate-item: add a `from_v1_data` constructor
ClosedPublic

Authored by marmoute on Jul 19 2021, 6:38 AM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHGa4443f66be6a: dirstate-item: add a `from_v1_data` constructor
Summary

This class method is dedicated to building a DirstateItem from the data
available in the "dirstate-v1" format. Since that format is frozen, this
constructor will never change (unlike the __init__ one).

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.Jul 19 2021, 6:38 AM
Alphare accepted this revision.Jul 19 2021, 12:27 PM
This revision is now accepted and ready to land.Jul 19 2021, 12:27 PM
pulkit accepted this revision.Jul 19 2021, 8:03 PM
baymax updated this revision to Diff 29537.Jul 20 2021, 3:20 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute added a commit: rHGa4443f66be6a: dirstate-item: add a `from_v1_data` constructor.Jul 20 2021, 7:17 AM
Closed by commit rHGa4443f66be6a: dirstate-item: add a `from_v1_data` constructor (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/parsers.c (48 lines)
Mmercurial/pure/parsers.py (16 lines)

Diff 29595

mercurial/cext/parsers.c

} }
if (self->state == 'n' && self->mtime == now) { if (self->state == 'n' && self->mtime == now) {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
/* This will never change since it's bound to V1, unlike `make_dirstate_item`
*/
static inline dirstateItemObject *
dirstate_item_from_v1_data(char state, int mode, int size, int mtime)
{
dirstateItemObject *t =
PyObject_New(dirstateItemObject, &dirstateItemType);
if (!t) {
return NULL;
}
t->state = state;
t->mode = mode;
t->size = size;
t->mtime = mtime;
return t;
}
/* This will never change since it's bound to V1, unlike `dirstate_item_new` */
static PyObject *dirstate_item_from_v1_meth(PyTypeObject *subtype,
PyObject *args)
{
/* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */
dirstateItemObject *t;
char state;
int size, mode, mtime;
if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime)) {
return NULL;
}
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) {
return NULL;
}
t->state = state;
t->mode = mode;
t->size = size;
t->mtime = mtime;
return (PyObject *)t;
};
static PyMethodDef dirstate_item_methods[] = { static PyMethodDef dirstate_item_methods[] = {
{"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS, {"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS,
"return a \"state\" suitable for v1 serialization"}, "return a \"state\" suitable for v1 serialization"},
{"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS, {"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS,
"return a \"mode\" suitable for v1 serialization"}, "return a \"mode\" suitable for v1 serialization"},
{"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS, {"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS,
"return a \"size\" suitable for v1 serialization"}, "return a \"size\" suitable for v1 serialization"},
{"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS, {"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS,
"return a \"mtime\" suitable for v1 serialization"}, "return a \"mtime\" suitable for v1 serialization"},
{"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O, {"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O,
"True if the stored mtime would be ambiguous with the current time"}, "True if the stored mtime would be ambiguous with the current time"},
{"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth, METH_O,
"build a new DirstateItem object from V1 data"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyObject *dirstate_item_get_mode(dirstateItemObject *self) static PyObject *dirstate_item_get_mode(dirstateItemObject *self)
{ {
return PyInt_FromLong(self->mode); return PyInt_FromLong(self->mode);
}; };
pos += 17; pos += 17;
cur += 17; cur += 17;
if (flen > len - pos) { if (flen > len - pos) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"overflow in dirstate"); "overflow in dirstate");
goto quit; goto quit;
} }
entry = entry = (PyObject *)dirstate_item_from_v1_data(state, mode,
(PyObject *)make_dirstate_item(state, mode, size, mtime); size, mtime);
cpos = memchr(cur, 0, flen); cpos = memchr(cur, 0, flen);
if (cpos) { if (cpos) {
fname = PyBytes_FromStringAndSize(cur, cpos - cur); fname = PyBytes_FromStringAndSize(cur, cpos - cur);
cname = PyBytes_FromStringAndSize( cname = PyBytes_FromStringAndSize(
cpos + 1, flen - (cpos - cur) - 1); cpos + 1, flen - (cpos - cur) - 1);
if (!fname || !cname || if (!fname || !cname ||
PyDict_SetItem(cmap, fname, cname) == -1 || PyDict_SetItem(cmap, fname, cname) == -1 ||
PyDict_SetItem(dmap, fname, entry) == -1) { PyDict_SetItem(dmap, fname, entry) == -1) {

mercurial/pure/parsers.py

_mtime = attr.ib() _mtime = attr.ib()
def __init__(self, state, mode, size, mtime): def __init__(self, state, mode, size, mtime):
self._state = state self._state = state
self._mode = mode self._mode = mode
self._size = size self._size = size
self._mtime = mtime self._mtime = mtime
@classmethod
def from_v1_data(cls, state, mode, size, mtime):
"""Build a new DirstateItem object from V1 data
Since the dirstate-v1 format is frozen, the signature of this function
is not expected to change, unlike the __init__ one.
"""
return cls(
state=state,
mode=mode,
size=size,
mtime=mtime,
)
def __getitem__(self, idx): def __getitem__(self, idx):
if idx == 0 or idx == -4: if idx == 0 or idx == -4:
msg = b"do not use item[x], use item.state" msg = b"do not use item[x], use item.state"
util.nouideprecwarn(msg, b'6.0', stacklevel=2) util.nouideprecwarn(msg, b'6.0', stacklevel=2)
return self._state return self._state
elif idx == 1 or idx == -3: elif idx == 1 or idx == -3:
msg = b"do not use item[x], use item.mode" msg = b"do not use item[x], use item.mode"
util.nouideprecwarn(msg, b'6.0', stacklevel=2) util.nouideprecwarn(msg, b'6.0', stacklevel=2)
while pos1 < l: while pos1 < l:
pos2 = pos1 + e_size pos2 = pos1 + e_size
e = _unpack(b">cllll", st[pos1:pos2]) # a literal here is faster e = _unpack(b">cllll", st[pos1:pos2]) # a literal here is faster
pos1 = pos2 + e[4] pos1 = pos2 + e[4]
f = st[pos2:pos1] f = st[pos2:pos1]
if b'\0' in f: if b'\0' in f:
f, c = f.split(b'\0') f, c = f.split(b'\0')
copymap[f] = c copymap[f] = c
dmap[f] = DirstateItem(*e[:4]) dmap[f] = DirstateItem.from_v1_data(*e[:4])
return parents return parents
def pack_dirstate(dmap, copymap, pl, now): def pack_dirstate(dmap, copymap, pl, now):
now = int(now) now = int(now)
cs = stringio() cs = stringio()
write = cs.write write = cs.write
write(b"".join(pl)) write(b"".join(pl))