mercurial/revlog.py
changeset 3453 dba3cadef789
parent 3438 b17f9d3eda74
child 3490 ceaa3fefc10c
equal deleted inserted replaced
3452:fcf14d87e0a4 3453:dba3cadef789
   744                     continue
   744                     continue
   745                 elif pn == nullid:
   745                 elif pn == nullid:
   746                     continue
   746                     continue
   747         return c
   747         return c
   748 
   748 
   749     def lookup(self, id):
   749     def _match(self, id):
   750         """locate a node based on:
       
   751             - revision number or str(revision number)
       
   752             - nodeid or subset of hex nodeid
       
   753         """
       
   754         if isinstance(id, (long, int)):
   750         if isinstance(id, (long, int)):
   755             # rev
   751             # rev
   756             return self.node(id)
   752             return self.node(id)
   757         if len(id) == 20:
   753         if len(id) == 20:
   758             # possibly a binary node
   754             # possibly a binary node
   770             if rev < 0: rev = self.count() + rev
   766             if rev < 0: rev = self.count() + rev
   771             if rev < 0 or rev >= self.count(): raise ValueError
   767             if rev < 0 or rev >= self.count(): raise ValueError
   772             return self.node(rev)
   768             return self.node(rev)
   773         except (ValueError, OverflowError):
   769         except (ValueError, OverflowError):
   774             pass
   770             pass
   775         try:
   771         if len(id) == 40:
   776             if len(id) == 40:
   772             try:
   777                 # a full hex nodeid?
   773                 # a full hex nodeid?
   778                 node = bin(id)
   774                 node = bin(id)
   779                 r = self.rev(node)
   775                 r = self.rev(node)
   780                 return node
   776                 return node
   781             elif len(id) < 40:
   777             except TypeError:
       
   778                 pass
       
   779 
       
   780     def _partialmatch(self, id):
       
   781         if len(id) < 40:
       
   782             try:
   782                 # hex(node)[:...]
   783                 # hex(node)[:...]
   783                 bin_id = bin(id[:len(id) & ~1]) # grab an even number of digits
   784                 bin_id = bin(id[:len(id) & ~1]) # grab an even number of digits
   784                 node = None
   785                 node = None
   785                 for n in self.nodemap:
   786                 for n in self.nodemap:
   786                     if n.startswith(bin_id) and hex(n).startswith(id):
   787                     if n.startswith(bin_id) and hex(n).startswith(id):
   787                         if node is not None:
   788                         if node is not None:
   788                             raise RevlogError(_("Ambiguous identifier"))
   789                             raise RevlogError(_("Ambiguous identifier"))
   789                         node = n
   790                         node = n
   790                 if node is not None:
   791                 if node is not None:
   791                     return node
   792                     return node
   792         except TypeError:
   793             except TypeError:
   793             pass
   794                 pass
       
   795 
       
   796     def lookup(self, id):
       
   797         """locate a node based on:
       
   798             - revision number or str(revision number)
       
   799             - nodeid or subset of hex nodeid
       
   800         """
       
   801 
       
   802         n = self._match(id)
       
   803         if n is not None:
       
   804             return n
       
   805         n = self._partialmatch(id)
       
   806         if n:
       
   807             return n
   794 
   808 
   795         raise RevlogError(_("No match found"))
   809         raise RevlogError(_("No match found"))
   796 
   810 
   797     def cmp(self, node, text):
   811     def cmp(self, node, text):
   798         """compare text with a given file revision"""
   812         """compare text with a given file revision"""