Source Code for Module node_manager_fkie.history'

  1  # Software License Agreement (BSD License) 
  2  # 
  3  # Copyright (c) 2012, Fraunhofer FKIE/US, Alexander Tiderko 
  4  # All rights reserved. 
  5  # 
  6  # Redistribution and use in source and binary forms, with or without 
  7  # modification, are permitted provided that the following conditions 
  8  # are met: 
  9  # 
 10  #  * Redistributions of source code must retain the above copyright 
 11  #    notice, this list of conditions and the following disclaimer. 
 12  #  * Redistributions in binary form must reproduce the above 
 13  #    copyright notice, this list of conditions and the following 
 14  #    disclaimer in the documentation and/or other materials provided 
 15  #    with the distribution. 
 16  #  * Neither the name of Fraunhofer nor the names of its 
 17  #    contributors may be used to endorse or promote products derived 
 18  #    from this software without specific prior written permission. 
 19  # 
 20  # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 21  # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 22  # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
 23  # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
 24  # COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
 25  # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
 26  # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
 27  # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
 28  # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
 29  # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
 30  # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 31  # POSSIBILITY OF SUCH DAMAGE. 
 32  from python_qt_binding.QtCore import QObject 
 33  import os 
 34   
 35  import rospy 
 36   
 37  import node_manager_fkie as nm 
 38   
 39   
 40 -class History(QObject): 
 41   
 42      PARAM_CACHE = dict() 
 43      ''' 
 44    the cache is used to store and recover the value for last entered parameter in parameter dialog. 
 45    ''' 
 46   
 47 -    def __init__(self): 
 48          QObject.__init__(self) 
 49          self.PARAM_CACHE = self.loadCache(nm.settings().PARAM_HISTORY_FILE) 
 50   
 51 -    def storeAll(self): 
 52          self.storeCache(nm.settings().PARAM_HISTORY_FILE, self.PARAM_CACHE, nm.settings().param_history_length) 
 53   
 54 -    def cachedParamValues(self, key): 
 55          try: 
 56              return list(self.PARAM_CACHE[key]) 
 57          except: 
 58              result = [] 
 59              return result 
 60   
 61 -    def addParamCache(self, key, value): 
 62          self._add2Cache(self.PARAM_CACHE, key, value) 
 63   
 64 -    def removeParamCache(self, key, value): 
 65          self._removeFromCache(self.PARAM_CACHE, key, value) 
 66   
 67 -    def loadCache(self, history_file): 
 68          ''' 
 69          Loads the content of the given file and return it as cache. 
 70          @param history_file: the name of the history file 
 71          @type history_file: C{str} 
 72          @return: the dictionary with arguments 
 73          @rtype: C{dict(str(name):[str(value), ...], ...)} 
 74          ''' 
 75          result = {} 
 76          historyFile = os.path.join(nm.settings().cfg_path, history_file) 
 77          if os.path.isfile(historyFile): 
 78              with open(historyFile, 'r') as f: 
 79                  line = f.readline() 
 80                  while line: 
 81                      if line: 
 82                          line = line.strip() 
 83                          if line: 
 84                              key, sep, value = line.partition(':=') 
 85                              if sep: 
 86                                  if key not in result.keys(): 
 87                                      result[key] = [value] 
 88                                  elif len(result[key]) <= nm.settings().param_history_length: 
 89                                      result[key].append(value) 
 90                      line = f.readline() 
 91          return result 
 92   
 93 -    def storeCache(self, history_file, cache, history_len): 
 94          ''' 
 95          Stores the cache to a file. 
 96          @param history_file: the name of the history file 
 97          @type history_file: C{str} 
 98          @param cache: the dictionary with values 
 99          @type cache: C{dict} 
100          @param history_len: the maximal count of value for a key 
101          @type history_len: C{int} 
102          ''' 
103          ignored = dict() 
104          with open(os.path.join(nm.settings().cfg_path, history_file), 'w') as f: 
105              for key in cache.keys(): 
106                  count = 0 
107                  for value in cache[key]: 
108                      if count < history_len: 
109                          try: 
110                              f.write(''.join([key, ':=', value, '\n'])) 
111                          except UnicodeEncodeError, e: 
112                              ignored[key] = (value, str(e)) 
113                          except: 
114                              import traceback 
115                              rospy.logwarn("Storing history aborted: %s", traceback.format_exc(1)) 
116                          count += 1 
117                      else: 
118                          break 
119          if ignored: 
120              rospy.logwarn("Error while storing follow keys: %s", str(ignored)) 
121   
122 -    def _add2Cache(self, cache, key, value): 
123          uvalue = unicode(value) 
124          if key and uvalue: 
125              if key not in cache: 
126                  cache[key] = [uvalue] 
127              elif uvalue not in cache[key]: 
128                  cache[key].insert(0, uvalue) 
129                  if len(cache[key]) >= nm.settings().param_history_length: 
130                      cache[key].pop() 
131              else: 
132                  cache[key].remove(uvalue) 
133                  cache[key].insert(0, uvalue) 
134   
135 -    def _removeFromCache(self, cache, key, value): 
136          uvalue = unicode(value) 
137          if key and uvalue: 
138              if key in cache: 
139                  value_list = cache[key] 
140                  try: 
141                      value_list.remove(uvalue) 
142                  except: 
143                      pass 
144                  if len(value_list) == 0: 
145                      del cache[key] 
146