This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4021

index: replace insert(-1, e) method by append(e) method
ClosedPublic

Authored by martinvonz on Aug 1 2018, 2:47 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG6104b203bec8: index: replace insert(-1, e) method by append(e) method
Summary

I want to make index[len(index) - 1] be the tip revision, not null
revision as it is today. insert(-1, e) will then make little
sense. Since insert() currently requires the first argument to be -1,
it seems simpler to replace it by a method that allows insertion only
at the end.

Note that revlogoldindex already has this method (by virtue of
extending list).

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

martinvonz created this revision.Aug 1 2018, 2:47 PM
martinvonz updated this revision to Diff 9780.Aug 2 2018, 12:40 AM
martinvonz updated this revision to Diff 9884.Aug 4 2018, 12:20 AM
yuja added a subscriber: yuja.Aug 4 2018, 2:41 AM

Bumped cext version and queued, thanks.

Closed by commit rHG6104b203bec8: index: replace insert(-1, e) method by append(e) method (authored by martinvonz). · Explain WhyAug 4 2018, 2:43 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 9891

mercurial/bundlerepo.py

if deltabase not in self.nodemap: if deltabase not in self.nodemap:
raise LookupError(deltabase, self.indexfile, raise LookupError(deltabase, self.indexfile,
_('unknown delta base')) _('unknown delta base'))
baserev = self.rev(deltabase) baserev = self.rev(deltabase)
# start, size, full unc. size, base (unused), link, p1, p2, node # start, size, full unc. size, base (unused), link, p1, p2, node
e = (revlog.offset_type(start, flags), size, -1, baserev, link, e = (revlog.offset_type(start, flags), size, -1, baserev, link,
self.rev(p1), self.rev(p2), node) self.rev(p1), self.rev(p2), node)
self.index.insert(-1, e) self.index.append(e)
self.nodemap[node] = n self.nodemap[node] = n
self.bundlerevs.add(n) self.bundlerevs.add(n)
n += 1 n += 1
def _chunk(self, rev, df=None): def _chunk(self, rev, df=None):
# Warning: in case of bundle, the diff is against what we stored as # Warning: in case of bundle, the diff is against what we stored as
# delta base, not against rev - 1 # delta base, not against rev - 1
# XXX: could use some caching # XXX: could use some caching

mercurial/cext/parsers.c

{"fm1readmarkers", fm1readmarkers, METH_VARARGS, {"fm1readmarkers", fm1readmarkers, METH_VARARGS,
"parse v1 obsolete markers\n"}, "parse v1 obsolete markers\n"},
{NULL, NULL}}; {NULL, NULL}};
void dirs_module_init(PyObject *mod); void dirs_module_init(PyObject *mod);
void manifest_module_init(PyObject *mod); void manifest_module_init(PyObject *mod);
void revlog_module_init(PyObject *mod); void revlog_module_init(PyObject *mod);
static const int version = 5; static const int version = 6;
static void module_init(PyObject *mod) static void module_init(PyObject *mod)
{ {
PyModule_AddIntConstant(mod, "version", version); PyModule_AddIntConstant(mod, "version", version);
/* This module constant has two purposes. First, it lets us unit test /* This module constant has two purposes. First, it lets us unit test
* the ImportError raised without hard-coding any error text. This * the ImportError raised without hard-coding any error text. This
* means we can change the text in the future without breaking tests, * means we can change the text in the future without breaking tests,

mercurial/cext/revlog.c

if (PyBytes_AsStringAndSize(obj, node, &nodelen) == -1) if (PyBytes_AsStringAndSize(obj, node, &nodelen) == -1)
return -1; return -1;
if (nodelen == 20) if (nodelen == 20)
return 0; return 0;
PyErr_SetString(PyExc_ValueError, "20-byte hash required"); PyErr_SetString(PyExc_ValueError, "20-byte hash required");
return -1; return -1;
} }
static PyObject *index_insert(indexObject *self, PyObject *args) static PyObject *index_append(indexObject *self, PyObject *obj)
{ {
PyObject *obj;
char *node; char *node;
int index;
Py_ssize_t len; Py_ssize_t len;
if (!PyArg_ParseTuple(args, "iO", &index, &obj))
return NULL;
if (!PyTuple_Check(obj) || PyTuple_GET_SIZE(obj) != 8) { if (!PyTuple_Check(obj) || PyTuple_GET_SIZE(obj) != 8) {
PyErr_SetString(PyExc_TypeError, "8-tuple required"); PyErr_SetString(PyExc_TypeError, "8-tuple required");
return NULL; return NULL;
} }
if (node_check(PyTuple_GET_ITEM(obj, 7), &node) == -1) if (node_check(PyTuple_GET_ITEM(obj, 7), &node) == -1)
return NULL; return NULL;
len = index_length(self); len = index_length(self);
if (index < 0)
index += len;
if (index != len - 1) {
PyErr_SetString(PyExc_IndexError,
"insert only supported at index -1");
return NULL;
}
if (self->added == NULL) { if (self->added == NULL) {
self->added = PyList_New(0); self->added = PyList_New(0);
if (self->added == NULL) if (self->added == NULL)
return NULL; return NULL;
} }
if (PyList_Append(self->added, obj) == -1) if (PyList_Append(self->added, obj) == -1)
return NULL; return NULL;
if (self->nt) if (self->nt)
nt_insert(self, node, index); nt_insert(self, node, len - 1);
Py_CLEAR(self->headrevs); Py_CLEAR(self->headrevs);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static void _index_clearcaches(indexObject *self) static void _index_clearcaches(indexObject *self)
{ {
if (self->cache) { if (self->cache) {
{"reachableroots2", (PyCFunction)reachableroots2, METH_VARARGS, {"reachableroots2", (PyCFunction)reachableroots2, METH_VARARGS,
"reachableroots"}, "reachableroots"},
{"headrevs", (PyCFunction)index_headrevs, METH_VARARGS, {"headrevs", (PyCFunction)index_headrevs, METH_VARARGS,
"get head revisions"}, /* Can do filtering since 3.2 */ "get head revisions"}, /* Can do filtering since 3.2 */
{"headrevsfiltered", (PyCFunction)index_headrevs, METH_VARARGS, {"headrevsfiltered", (PyCFunction)index_headrevs, METH_VARARGS,
"get filtered head revisions"}, /* Can always do filtering */ "get filtered head revisions"}, /* Can always do filtering */
{"deltachain", (PyCFunction)index_deltachain, METH_VARARGS, {"deltachain", (PyCFunction)index_deltachain, METH_VARARGS,
"determine revisions with deltas to reconstruct fulltext"}, "determine revisions with deltas to reconstruct fulltext"},
{"insert", (PyCFunction)index_insert, METH_VARARGS, {"append", (PyCFunction)index_append, METH_O,
"insert an index entry"}, "append an index entry"},
{"partialmatch", (PyCFunction)index_partialmatch, METH_VARARGS, {"partialmatch", (PyCFunction)index_partialmatch, METH_VARARGS,
"match a potentially ambiguous node ID"}, "match a potentially ambiguous node ID"},
{"shortest", (PyCFunction)index_shortest, METH_VARARGS, {"shortest", (PyCFunction)index_shortest, METH_VARARGS,
"find length of shortest hex nodeid of a binary ID"}, "find length of shortest hex nodeid of a binary ID"},
{"stats", (PyCFunction)index_stats, METH_NOARGS, {"stats", (PyCFunction)index_stats, METH_NOARGS,
"stats for the index"}, "stats for the index"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };

mercurial/policy.py

return fakelocals[modname] return fakelocals[modname]
# keep in sync with "version" in C modules # keep in sync with "version" in C modules
_cextversions = { _cextversions = {
(r'cext', r'base85'): 1, (r'cext', r'base85'): 1,
(r'cext', r'bdiff'): 3, (r'cext', r'bdiff'): 3,
(r'cext', r'mpatch'): 1, (r'cext', r'mpatch'): 1,
(r'cext', r'osutil'): 4, (r'cext', r'osutil'): 4,
(r'cext', r'parsers'): 5, (r'cext', r'parsers'): 6,
} }
# map import request to other package or module # map import request to other package or module
_modredirects = { _modredirects = {
(r'cext', r'charencode'): (r'cext', r'parsers'), (r'cext', r'charencode'): (r'cext', r'parsers'),
(r'cffi', r'base85'): (r'pure', r'base85'), (r'cffi', r'base85'): (r'pure', r'base85'),
(r'cffi', r'charencode'): (r'pure', r'charencode'), (r'cffi', r'charencode'): (r'pure', r'charencode'),
(r'cffi', r'parsers'): (r'pure', r'parsers'), (r'cffi', r'parsers'): (r'pure', r'parsers'),

mercurial/pure/parsers.py

def offset_type(offset, type): def offset_type(offset, type):
return int(int(offset) << 16 | type) return int(int(offset) << 16 | type)
class BaseIndexObject(object): class BaseIndexObject(object):
def __len__(self): def __len__(self):
return self._lgt + len(self._extra) + 1 return self._lgt + len(self._extra) + 1
def insert(self, i, tup): def append(self, tup):
assert i == -1
self._extra.append(tup) self._extra.append(tup)
def _fix_index(self, i): def _fix_index(self, i):
if not isinstance(i, int): if not isinstance(i, int):
raise TypeError("expecting int indexes") raise TypeError("expecting int indexes")
if i < 0 or i >= len(self): if i < 0 or i >= len(self):
raise IndexError raise IndexError
return i return i

mercurial/revlog.py

else: else:
rawtext = deltacomputer.buildtext(revinfo, fh) rawtext = deltacomputer.buildtext(revinfo, fh)
data = self.compress(rawtext) data = self.compress(rawtext)
l = len(data[1]) + len(data[0]) l = len(data[1]) + len(data[0])
base = chainbase = curr base = chainbase = curr
e = (offset_type(offset, flags), l, textlen, e = (offset_type(offset, flags), l, textlen,
base, link, p1r, p2r, node) base, link, p1r, p2r, node)
self.index.insert(-1, e) self.index.append(e)
self.nodemap[node] = curr self.nodemap[node] = curr
entry = self._io.packentry(e, self.node, self.version, curr) entry = self._io.packentry(e, self.node, self.version, curr)
self._writeentry(transaction, ifh, dfh, entry, data, link, offset) self._writeentry(transaction, ifh, dfh, entry, data, link, offset)
if alwayscache and rawtext is None: if alwayscache and rawtext is None:
rawtext = deltacomputer._buildtext(revinfo, fh) rawtext = deltacomputer._buildtext(revinfo, fh)

mercurial/unionrepo.py

p1node = self.revlog2.node(p1rev) p1node = self.revlog2.node(p1rev)
p2node = self.revlog2.node(p2rev) p2node = self.revlog2.node(p2rev)
# TODO: it's probably wrong to set compressed length to None, but # TODO: it's probably wrong to set compressed length to None, but
# I have no idea if csize is valid in the base revlog context. # I have no idea if csize is valid in the base revlog context.
e = (flags, None, rsize, base, e = (flags, None, rsize, base,
link, self.rev(p1node), self.rev(p2node), node) link, self.rev(p1node), self.rev(p2node), node)
self.index.insert(-1, e) self.index.append(e)
self.nodemap[node] = n self.nodemap[node] = n
self.bundlerevs.add(n) self.bundlerevs.add(n)
n += 1 n += 1
def _chunk(self, rev): def _chunk(self, rev):
if rev <= self.repotiprev: if rev <= self.repotiprev:
return revlog.revlog._chunk(self, rev) return revlog.revlog._chunk(self, rev)
return self.revlog2._chunk(self.node(rev)) return self.revlog2._chunk(self.node(rev))