def testPrimary(self):
fsm = FSM()
fsm.add('start', None, 'final', self.primary_start)
fsm.add('final', None, 'start', self.primary_stop)
fsm.start('start')
fsm.execute(self.START_TEST_OUTPUT)
fsm.execute(self.VALID_TEST_OUTPUT)
self.assertEqual(self._primaryout, self.VALID_TEST_OUTPUT)
def __fsm_init(self):
'''Helper initialize FSM'''
self._fsm = FSM()
tagiter = iter(self._filter)
init_tag = current_tag = tagiter.next()
while True:
try:
# Create distinct state transitions
acq_tag = '%s%s' % (current_tag, '_acq')
# Don't do anything before being signaled
self._fsm.add(current_tag, None, current_tag, None)
self._fsm.add(current_tag, self.__ACQ_SIGNAL, acq_tag, None)
try:
# Next user-/tag-defined state
current_tag = tagiter.next()
self._fsm.add(acq_tag, None, current_tag, self.acquire)
except StopIteration:
# Or close the loop
self._fsm.add(acq_tag, None, init_tag, self.last_action)
break
except StopIteration:
# TODO: Log: this should never happen
break
self._fsm.start(init_tag)
def create(cls, server_address, robot_name):
robot_fsm = FSM()
communication_queue = Queue()
node_manager = NodeManager()
pose_listener = PoseListenerFactory()
pose_streamer = ServerPoseStreamerFactory(communication_queue,
pose_listener)
gps_calibrator = gps_cal.GPSCallibrtor()
map_streamer = MapStreamer(communication_queue, gps_calibrator)
motion_controller = MotionController()
map_publisher = MapPublisher.create(server_address, robot_name)
nav_controller = NavigationController(map_publisher)
initial_pose_publisher = InitialPosePublisher(server_address,
robot_name)
state_streamer = ServerStateStreamer.create(robot_name, robot_fsm,
communication_queue)
return RobotStateManager(robot_fsm=robot_fsm,
com_queue=communication_queue,
node_manager=node_manager,
map_streamer=map_streamer,
pose_streamer=pose_streamer,
motion_controller=motion_controller,
gps_calibrator=gps_calibrator,
map_publisher=map_publisher,
nav_controller=nav_controller,
initial_pose_publisher=initial_pose_publisher,
state_streamer=state_streamer)
class AttributeFilter:
'''Filter Expat processing'''
__ACQ_SIGNAL = 'start'
def __init__(self, filter, complete_cb):
'''Initialize with tag list and proc'''
# Parameterize Expat
self.__parser_init()
# (tag:value) mapping returned via callback/proc
self._filter = filter
self._acquire = dict.fromkeys(filter)
self._current_tag = iter(filter)
self.__fsm_init()
self.__callback = complete_cb
def __parser_init(self):
'''Help initialize Expat'''
self._parser = xml.parsers.expat.ParserCreate('utf-8')
self._parser.buffer_text = True
self._parser.StartElementHandler = self.start_element
self._parser.EndElementHandler = self.end_element
self._parser.CharacterDataHandler = self.char_data
def __fsm_init(self):
'''Helper initialize FSM'''
self._fsm = FSM()
tagiter = iter(self._filter)
init_tag = current_tag = tagiter.next()
while True:
try:
# Create distinct state transitions
acq_tag = '%s%s' % (current_tag, '_acq')
# Don't do anything before being signaled
self._fsm.add(current_tag, None, current_tag, None)
self._fsm.add(current_tag, self.__ACQ_SIGNAL, acq_tag, None)
try:
# Next user-/tag-defined state
current_tag = tagiter.next()
self._fsm.add(acq_tag, None, current_tag, self.acquire)
except StopIteration:
# Or close the loop
self._fsm.add(acq_tag, None, init_tag, self.last_action)
break
except StopIteration:
# TODO: Log: this should never happen
break
self._fsm.start(init_tag)
def parse(self, raw_xml):
'''Direct call on Expat instance'''
try:
self._parser.Parse(raw_xml, 1)
except xml.parsers.expat.ExpatError, err:
# TODO: Error path/Exceptions
message = 'Expat Error: %s (%i, %i)' % (xml.parsers.expat.ErrorString(err.code),\
err.lineno,\
err.offset)
def init(self):
self.history.clear()
return FSM.init(self)
def __init__(self, memory=0):
FSM.__init__(self)
self.history = deque(maxlen=memory)
self.name_to_state = {}
def exit(self):
if self.history.maxlen > 0 and self.state is not None:
self.history.append(self.state)
return FSM.exit(self)
