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.

Download Raw Diff

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

Herald added a reviewer: indygreg. · View Herald TranscriptAug 1 2018, 2:47 PM

Herald added a reviewer: hg-reviewers. · View Herald Transcript

Herald added a subscriber: mercurial-devel. · View Herald Transcript

martinvonz added a child revision: D4022: index: don't include nullid in len().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

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

			Path	Packages
M			mercurial/bundlerepo.py (2 lines)
M			mercurial/cext/parsers.c (2 lines)
M			mercurial/cext/revlog.c (22 lines)
M			mercurial/policy.py (2 lines)
M			mercurial/pure/parsers.py (3 lines)
M			mercurial/revlog.py (2 lines)
M			mercurial/unionrepo.py (2 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	9721		Aug 1 2018, 2:47 PM	★	★
Diff 2	9780		Aug 2 2018, 12:40 AM	★	★
Diff 3	9884		Aug 4 2018, 12:20 AM	★	★
Diff 4	9891	rHG6104b203bec89f1fa7fd1c0ab00a1a65e66d2627	Aug 1 2018, 1:57 PM	★	★

Status	Author	Revision
Closed	martinvonz	D4023 index: don't allow index[len(index)] to mean nullid
Closed	martinvonz	D4022 index: don't include nullid in len()
Closed	martinvonz	D4021 index: replace insert(-1, e) method by append(e) method
Closed	martinvonz	D4020 pure: create type for revlog v0 index
Closed	martinvonz	D4019 index: drop support for negative indexes into the index
Closed	martinvonz	D4018 index: handle index[-1] as nullid more explicitly
Closed	martinvonz	D4017 perfmoonwalk: make work with filtered repo
Closed	martinvonz	D4016 revlog: remove some knowledge of sentinel nullid in index
Closed	martinvonz	D4015 revlog: don't include trailing nullrev in revlog.revs(stop=len(revlog))

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))