254     def __len__(self):

   254     def __len__(self):

   255         return len(self.index) - 1

   255         return len(self.index) - 1

   256     def __iter__(self):

   256     def __iter__(self):

   257         for i in xrange(len(self)):

   257         for i in xrange(len(self)):

   258             yield i

   258             yield i

   259 

   266 

   260     @util.propertycache

   267     @util.propertycache

   261     def nodemap(self):

   268     def nodemap(self):

   262         self.rev(self.node(0))

   269         self.rev(self.node(0))

   263         return self._nodecache

   270         return self._nodecache

   372             for i in self:

   379             for i in self:

   373                 yield i

   380                 yield i

   374             return

   381             return

   375 

   382 

   376         seen = set(revs)

   383         seen = set(revs)

   378             for x in self.parentrevs(i):

   385             for x in self.parentrevs(i):

   379                 if x != nullrev and x in seen:

   386                 if x != nullrev and x in seen:

   380                     seen.add(i)

   387                     seen.add(i)

   381                     yield i

   388                     yield i

   382                     break

   389                     break

   547         # Our topologically sorted list of output nodes.

   554         # Our topologically sorted list of output nodes.

   548         orderedout = []

   555         orderedout = []

   549         # Don't start at nullid since we don't want nullid in our output list,

   556         # Don't start at nullid since we don't want nullid in our output list,

   550         # and if nullid shows up in descendants, empty parents will look like

   557         # and if nullid shows up in descendants, empty parents will look like

   551         # they're descendants.

   558         # they're descendants.

   553             n = self.node(r)

   560             n = self.node(r)

   554             isdescendant = False

   561             isdescendant = False

   555             if lowestrev == nullrev:  # Everybody is a descendant of nullid

   562             if lowestrev == nullrev:  # Everybody is a descendant of nullid

   556                 isdescendant = True

   563                 isdescendant = True

   557             elif n in descendants:

   564             elif n in descendants:

   604         count = len(self)

   611         count = len(self)

   605         if not count:

   612         if not count:

   606             return [nullrev]

   613             return [nullrev]

   607         ishead = [1] * (count + 1)

   614         ishead = [1] * (count + 1)

   608         index = self.index

   615         index = self.index

   610             e = index[r]

   617             e = index[r]

   611             ishead[e[5]] = ishead[e[6]] = 0

   618             ishead[e[5]] = ishead[e[6]] = 0

   612         return [r for r in xrange(count) if ishead[r]]

   619         return [r for r in xrange(count) if ishead[r]]

   613 

   620 

   614     def heads(self, start=None, stop=None):

   621     def heads(self, start=None, stop=None):

   632         startrev = self.rev(start)

   639         startrev = self.rev(start)

   633         reachable = set((startrev,))

   640         reachable = set((startrev,))

   634         heads = set((startrev,))

   641         heads = set((startrev,))

   635 

   642 

   636         parentrevs = self.parentrevs

   643         parentrevs = self.parentrevs

   638             for p in parentrevs(r):

   645             for p in parentrevs(r):

   639                 if p in reachable:

   646                 if p in reachable:

   640                     if r not in stoprevs:

   647                     if r not in stoprevs:

   641                         reachable.add(r)

   648                         reachable.add(r)

   642                     heads.add(r)

   649                     heads.add(r)

   647 

   654 

   648     def children(self, node):

   655     def children(self, node):

   649         """find the children of a given node"""

   656         """find the children of a given node"""

   650         c = []

   657         c = []

   651         p = self.rev(node)

   658         p = self.rev(node)

   653             prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]

   660             prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]

   654             if prevs:

   661             if prevs:

   655                 for pr in prevs:

   662                 for pr in prevs:

   656                     if pr == p:

   663                     if pr == p:

   657                         c.append(self.node(r))

   664                         c.append(self.node(r))