2245         readdelta is called if the delta is against the p1, and therefore can be

  2245         readdelta is called if the delta is against the p1, and therefore can be

  2246         read quickly.

  2246         read quickly.

  2247 

  2247 

  2248         If `shallow` is True, nothing changes since this is a flat manifest.

  2248         If `shallow` is True, nothing changes since this is a flat manifest.

  2249         """

  2249         """

  2250         store = self._storage()

  2255         store = self._storage()

  2251         r = store.rev(self._node)

  2256         r = store.rev(self._node)

  2252         deltaparent = store.deltaparent(r)

  2257         deltaparent = store.deltaparent(r)

  2253         if deltaparent != nullrev and deltaparent in store.parentrevs(r):

  2258         if deltaparent != nullrev and deltaparent in store.parentrevs(r):

  2254             return self.readdelta()

  2259             return self.readdelta()

  2259         in this manifest, but not in its p1 manifest. This is efficient to read

  2264         in this manifest, but not in its p1 manifest. This is efficient to read

  2260         if the revlog delta is already p1.

  2265         if the revlog delta is already p1.

  2261 

  2266 

  2262         Changing the value of `shallow` has no effect on flat manifests.

  2267         Changing the value of `shallow` has no effect on flat manifests.

  2263         """

  2268         """

  2264         store = self._storage()

  2274         store = self._storage()

  2265         r = store.rev(self._node)

  2275         r = store.rev(self._node)

  2266         d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))

  2276         d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))

  2267         return manifestdict(store.nodeconstants.nodelen, d)

  2277         return manifestdict(store.nodeconstants.nodelen, d)

  2268 

  2278 

  2452     def parents(self) -> Tuple[bytes, bytes]:

  2462     def parents(self) -> Tuple[bytes, bytes]:

  2453         return self._storage().parents(self._node)

  2463         return self._storage().parents(self._node)

  2454 

  2464 

  2455     def readdelta(self, shallow: bool = False) -> AnyManifestDict:

  2465     def readdelta(self, shallow: bool = False) -> AnyManifestDict:

  2456         """see `imanifestrevisionstored` documentation"""

  2466         """see `imanifestrevisionstored` documentation"""

  2457         store = self._storage()

  2472         store = self._storage()

  2458         if shallow:

  2473         if shallow:

  2459             r = store.rev(self._node)

  2474             r = store.rev(self._node)

  2460             d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))

  2475             d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))

  2461             return manifestdict(store.nodeconstants.nodelen, d)

  2476             return manifestdict(store.nodeconstants.nodelen, d)

  2617         read quickly.

  2632         read quickly.

  2618 

  2633 

  2619         If `shallow` is True, it only returns the entries from this manifest,

  2634         If `shallow` is True, it only returns the entries from this manifest,

  2620         and not any submanifests.

  2635         and not any submanifests.

  2621         """

  2636         """

  2622         store = self._storage()

  2642         store = self._storage()

  2623         r = store.rev(self._node)

  2643         r = store.rev(self._node)

  2624         deltaparent = store.deltaparent(r)

  2644         deltaparent = store.deltaparent(r)

  2625         if deltaparent != nullrev and deltaparent in store.parentrevs(r):

  2645         if deltaparent != nullrev and deltaparent in store.parentrevs(r):

  2626             return self.readdelta(shallow=shallow)

  2646             return self.readdelta(shallow=shallow)