docs: def list_events(self, cond, cols, fields):
          """
          Return the list of events, with a specific order and filtered by a condition.
          An element of the list is a tuple with three component. The first is the main
          attribute (first field). The second the second field/label, usually a string
          that identify the service. The third is a dictionary with a key-tuple composed
          by all other fields and values indicating the number of events associated.
          """
  
          def insert_row():
              """
              Internal function to flush results for a single tabkey to result list.
              """
              row = list(row_template)
              j = 0
              for n in range(cols):
                  if row[n] is None:
                      if j == keylen:
                          row[n] = tabvalues
                      else:
                          row[n] = tabkey[j]
                      j += 1
              reslist.append(row)
  
          if not self.results:
              return []
  
          # Set local variables
          results = self.results
          pos = [self.key_gids.index(gid) for gid in fields if gid[0] != '"']
          has_cond = cond != "*"
  
          # If a condition is passed then compile a pattern matching object
          if has_cond:
              match = re.search("(\w+)(!=|==)\"([^\"]*)\"", cond)
              condpos = self.key_gids.index(match.group(1))
              invert = (match.group(2) == '!=')
              recond = re.compile(match.group(3))
          else:
              recond = condpos = None
  
          # Define the row template with places for values and fixed strings
          row_template = []
          for i in range(cols):
              if fields[i][0] == '"':
                  row_template.append(fields[i].strip('"'))
              else:
                  row_template.append(None)
  
          # Set the processing table and reduced key length
          keylen = len(pos) - (len(fields) - cols) - 1
          tabvalues = dict()
          tabkey = None
  
          reslist = []
          for key in sorted(results, key=lambda x: x[pos[0]]):
              # Skip results that don't satisfy the condition
              if has_cond:
                  try:
                      match = recond.search(key[condpos])
                  except TypeError:
                      continue
                  if ((match is None) and not invert) or ((match is not None) and invert):
                      continue
  
              new_tabkey = [key[pos[i]] for i in range(keylen)]
              if tabkey is None:
                  tabkey = new_tabkey
              elif tabkey != new_tabkey:
                  insert_row()
                  tabvalues = dict()
                  tabkey = [key[pos[i]] for i in range(keylen)]
  
              value = tuple([key[k] for k in pos[keylen:]])
              if value in tabvalues:
                  tabvalues[value] += results[key]
              else:
                  tabvalues[value] = results[key]
  
          if tabvalues:
              insert_row()
          return reslist