home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / site-packages / dbus / matchrules.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  7.0 KB  |  261 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. from exceptions import DBusException
  5.  
  6. class SignalMatchNode:
  7.     
  8.     def __init__(self):
  9.         self.wildcard = None
  10.         self.finite = { }
  11.         self.rules = []
  12.  
  13.     
  14.     def add(self, key, leaf = None):
  15.         node = None
  16.         if key:
  17.             if self.finite.has_key(key):
  18.                 node = self.finite[key]
  19.             else:
  20.                 node = SignalMatchNode()
  21.                 self.finite[key] = node
  22.         elif self.wildcard:
  23.             node = self.wildcard
  24.         else:
  25.             node = SignalMatchNode()
  26.             self.wildcard = node
  27.         node.rules.append(leaf)
  28.         return node
  29.  
  30.     
  31.     def get_matches(self, key):
  32.         result = []
  33.         if self.wildcard:
  34.             result.append(self.wildcard)
  35.         
  36.         if self.finite.has_key(key):
  37.             result.append(self.finite[key])
  38.         
  39.         return result
  40.  
  41.     
  42.     def get_match(self, key):
  43.         if key:
  44.             if self.finite.has_key(key):
  45.                 return self.finite[key]
  46.             else:
  47.                 return None
  48.         
  49.         return self.wildcard
  50.  
  51.     
  52.     def has_children(self):
  53.         if self.wildcard or len(self.finite.iterkeys()) > 0:
  54.             return True
  55.         
  56.         return False
  57.  
  58.     
  59.     def remove_child(self, child, key = None):
  60.         if self.wildcard == child:
  61.             self.wildcard = None
  62.         elif self.finite.has_key(key):
  63.             del self.finite[key]
  64.         
  65.  
  66.  
  67.  
  68. class SignalMatchTree:
  69.     '''This class creates an ordered tree of SignalMatchRules
  70.         to speed searchs.  Left branches are wildcard elements
  71.         and all other branches are concreet elements.
  72.     '''
  73.     
  74.     def __init__(self):
  75.         self._tree = SignalMatchNode()
  76.  
  77.     
  78.     def add(self, rule):
  79.         interface = self._tree.add(rule.sender)
  80.         signal = interface.add(rule.dbus_interface)
  81.         path = signal.add(rule.signal_name)
  82.         path.add(rule.path, leaf = rule)
  83.  
  84.     
  85.     def exec_matches(self, match_rule, message):
  86.         args = message.get_args_list()
  87.         sender_matches = self._tree.get_matches(match_rule.sender)
  88.         for sender_node in sender_matches:
  89.             interface_matches = sender_node.get_matches(match_rule.dbus_interface)
  90.             for interface_node in interface_matches:
  91.                 signal_matches = interface_node.get_matches(match_rule.signal_name)
  92.                 for signal_node in signal_matches:
  93.                     path_matches = signal_node.get_matches(match_rule.path)
  94.                     for path_node in path_matches:
  95.                         if path_node.rules:
  96.                             for rule in path_node.rules:
  97.                                 if rule.match_args_from_list(args):
  98.                                     rule.execute(message, args)
  99.                                     continue
  100.                             
  101.                     
  102.                 
  103.             
  104.         
  105.  
  106.     
  107.     def remove(self, rule):
  108.         
  109.         try:
  110.             sender = self._tree.get_match(rule.sender)
  111.             interface = sender.get_match(rule.dbus_interface)
  112.             signal = interface.get_match(rule.signal_name)
  113.             path = signal.get_match(rule.path)
  114.             rule_matches = []
  115.             for _rule in path.rules:
  116.                 if _rule.is_match(rule):
  117.                     rule_matches.append(_rule)
  118.                     continue
  119.             
  120.             for _rule in rule_matches:
  121.                 path.rules.remove(_rule)
  122.             
  123.             if len(path.rules) == 0:
  124.                 signal.remove_child(path, key = rule.path)
  125.                 if not signal.has_children():
  126.                     interface.remove_child(signal, key = rule.signal_name)
  127.                     if not interface.has_children():
  128.                         sender.remove_child(interface, key = rule.dbus_interface)
  129.                         if not sender.has_children():
  130.                             self._tree.remove_child(sender, key = rule.sender)
  131.                         
  132.                     
  133.                 
  134.         except:
  135.             raise DBusException('Trying to remove unkown rule: %s' % str(rule))
  136.  
  137.  
  138.  
  139.  
  140. class SignalMatchRule:
  141.     '''This class represents a dbus rule used to filter signals.
  142.         When a rule matches a filter, the signal is propagated to the handler_funtions
  143.     '''
  144.     
  145.     def __init__(self, signal_name, dbus_interface, sender, path):
  146.         self.handler_functions = []
  147.         self.signal_name = signal_name
  148.         self.dbus_interface = dbus_interface
  149.         self.sender = sender
  150.         self.path = path
  151.         self.args = None
  152.  
  153.     
  154.     def add_args_match(self, args):
  155.         self.args = args
  156.  
  157.     
  158.     def execute(self, message, args = None):
  159.         keywords = { }
  160.         if self.sender_keyword is not None:
  161.             keywords[self.sender_keyword] = message.get_sender()
  162.         
  163.         if self.path_keyword is not None:
  164.             keywords[self.path_keyword] = message.get_path()
  165.         
  166.         if not args:
  167.             args = message.get_args_list()
  168.         
  169.         for handler in self.handler_functions:
  170.             if getattr(handler, '_dbus_pass_message', False):
  171.                 keywords['dbus_message'] = message
  172.             
  173.             if len(keywords) == 0:
  174.                 handler(*args)
  175.                 continue
  176.             handler(*args, **keywords)
  177.         
  178.  
  179.     
  180.     def add_handler(self, handler):
  181.         self.handler_functions.append(handler)
  182.  
  183.     
  184.     def match_args_from_list(self, args_list):
  185.         if not self.args:
  186.             return True
  187.         
  188.         last_index = len(args_list) - 1
  189.         for index, value in self.args.iteritems():
  190.             if index > last_index:
  191.                 return False
  192.             
  193.             if not args_list[index] == value:
  194.                 return False
  195.                 continue
  196.         
  197.         return True
  198.  
  199.     
  200.     def match_args_from_rule(self, rule):
  201.         if self.args == rule.args:
  202.             return True
  203.         
  204.         if self.args == None or rule.args == None:
  205.             return False
  206.         
  207.         my_args_list = self.args.items()
  208.         match_args_list = rule.args.iterms()
  209.         if len(my_args_list) != len(match_args_list):
  210.             return False
  211.         
  212.         for key, value in my_args_list:
  213.             if rule.args.get(key) != value:
  214.                 return False
  215.                 continue
  216.         
  217.         return True
  218.  
  219.     
  220.     def is_match(self, rule):
  221.         if self.signal_name == rule.signal_name and self.dbus_interface == rule.dbus_interface and self.sender == rule.sender and self.path == rule.path and self.match_args_from_rule(rule):
  222.             if rule.handler_functions == []:
  223.                 return True
  224.             
  225.             _funcs_copy_a = self.handler_functions[0:]
  226.             _funcs_copy_b = rule.handler_functions[0:]
  227.             _funcs_copy_a.sort()
  228.             _funcs_copy_b.sort()
  229.             return _funcs_copy_a == _funcs_copy_b
  230.         
  231.         return False
  232.  
  233.     
  234.     def __repr__(self):
  235.         '''Returns a custom representation of this DBusMatchRule that can
  236.             be used with dbus_bindings
  237.         '''
  238.         repr = "type='signal'"
  239.         if self.dbus_interface:
  240.             repr = repr + ",interface='%s'" % self.dbus_interface
  241.         
  242.         if self.sender:
  243.             repr = repr + ",sender='%s'" % self.sender
  244.         
  245.         if self.path:
  246.             repr = repr + ",path='%s'" % self.path
  247.         
  248.         if self.signal_name:
  249.             repr = repr + ",member='%s'" % self.signal_name
  250.         
  251.         if self.args:
  252.             my_args_list = self.args.items()
  253.             my_args_list.sort()
  254.             for index, value in my_args_list:
  255.                 repr = repr + ",arg%i='%s'" % (index, value)
  256.             
  257.         
  258.         return repr
  259.  
  260.  
  261.