Source Code for Module concurrent_tree_crawler.standard_node

 1  import threading 
 2   
 3  from collections import OrderedDict 
 4  from concurrent_tree_crawler.abstract_node import AbstractNode, NodeState 
 5   
 6 -class StandardNode(AbstractNode): 
 7          """A simple in-memory implementation of the L{AbstractNode}.""" 
 8           
 9 -        def __init__(self, parent=None, name="sentinel", state=NodeState.OPEN): 
10                  """ 
11                  @type parent: L{StandardNode}, equals C{None} if node is  
12                          the     sentinel node 
13                  @type name: string 
14                  @type state: L{NodeState} 
15                  """ 
16                  self.__parent = parent 
17                   
18                  self.__name = name 
19                   
20                  self.__state = state 
21                   
22                  self._children = \ 
23                          [OrderedDict() for _ in xrange(NodeState.MAX_ENUM_INDEX+1)] 
24                  """Array indexed by the L{NodeState} enumeration index""" 
25                   
26                  self.__cond = threading.Condition() 
27   
28 -        def get_children_cond(self): 
29                  return self.__cond 
30   
31 -        def get_name(self): 
32                  return self.__name 
33   
34 -        def get_state(self): 
35                  return self.__state 
36           
37 -        def set_state(self, new_state): 
38                  if self.__parent is not None: 
39                          child_found = False 
40                          for state in xrange(NodeState.MAX_ENUM_INDEX+1): 
41                                  if self.__name in self.__parent._children[state]: 
42                                          del self.__parent._children[state][self.__name] 
43                                          child_found = True 
44                                          break 
45                          assert child_found, "This node not found among parent's children" 
46                          self.__parent._children[new_state][self.__name] = self 
47                  self.__state = new_state 
48           
49 -        def get_parent(self): 
50                  return self.__parent 
51   
52 -        def has_child(self, name): 
53                  for state in xrange(NodeState.MAX_ENUM_INDEX+1): 
54                          if name in self._children[state]: 
55                                  return True 
56                  return False 
57   
58 -        def get_child(self, name): 
59                  for state in xrange(NodeState.MAX_ENUM_INDEX+1): 
60                          if name in self._children[state]: 
61                                  return self._children[state][name] 
62                  assert False, "Child with given name not found" 
63           
64 -        def get_children(self): 
65                  children = [] 
66                  for state in xrange(NodeState.MAX_ENUM_INDEX+1): 
67                          for (_, node) in self._children[state].iteritems(): 
68                                  children.append(node) 
69                  return children 
70           
71 -        def add_child(self, name, state): 
72                  assert name not in self._children[state] 
73                  new_child = StandardNode(self, name, state) 
74                  self._children[state][name] = new_child 
75                  return new_child 
76           
77 -        def _has_children(self, state): 
78                  return len(self._children[state]) > 0 
79