def parseField_new(self, parsingPath, fields, i_current_field): self._logger.debug("parseField_new executed for field {} with path : {}".format(i_current_field, parsingPath)) currentField = fields[i_current_field] fp = FieldParser(currentField, (i_current_field == len(fields) - 1)) value_before_parsing = parsingPath.getDataAssignedToField(currentField).copy() for newParsingPath in fp.parse(parsingPath): try: value_after_parsing = newParsingPath.getDataAssignedToField(currentField) remainingValue = value_before_parsing[len(value_after_parsing):].copy() if i_current_field < len(fields) - 1 : newParsingPath.assignDataToField(remainingValue, fields[i_current_field+1]) return self.parseField_new(newParsingPath, fields, i_current_field + 1) elif len(remainingValue) == 0: # valid parsing path must consume everything return newParsingPath except InvalidParsingPathException, e: pass
def parseRaw(self, dataToParse, fields): """This method parses the specified raw against the specification of the provided symbol.""" if dataToParse is None or len(dataToParse) <= 0: raise Exception("Specified data to parse is empty (or None)") if fields is None: raise Exception("Specified fields is None") if len(fields) == 0: raise Exception("No field specified") # self._logger.debug("Parse content '{0}' according to symbol {1}".format(dataToParse, symbol.name)) # this variable host the result of the parsing parsingResult = None # we convert the raw into bitarray bitArrayToParse = TypeConverter.convert(dataToParse, Raw, BitArray) # initiates the parsing process by creating a first parsing path parsingPaths = [ParsingPath(bitArrayToParse.copy(), self.memory)] # assign to the first field of the symbol all the data to parse parsingPaths[0].assignDataToField(bitArrayToParse.copy(), fields[0]) # we successively apply each fields of the symbol to parse the specified data for i_field in xrange(len(fields)): current_field = fields[i_field] # identify next field if i_field < len(fields) - 1: next_field = fields[i_field + 1] else: next_field = None # build a field parser fp = FieldParser(current_field, lastField=(i_field == len(fields) - 1)) newParsingPaths = [] for parsingPath in parsingPaths: # we remove erroneous paths value_before_parsing = parsingPath.getDataAssignedToField(current_field).copy() resultParsingPaths = fp.parse(parsingPath) for resultParsingPath in resultParsingPaths: value_after_parsing = resultParsingPath.getDataAssignedToField(current_field) remainingValue = value_before_parsing[len(value_after_parsing):].copy() if next_field is not None: resultParsingPath.assignDataToField(remainingValue, next_field) if resultParsingPath.isDataAvailableForField(current_field): newParsingPaths.append(resultParsingPath) # lets filter parsingPaths = newParsingPaths[:100] finalParsingPaths = [] for parsingPath in parsingPaths: if parsingPath.validForMessage(fields, bitArrayToParse): finalParsingPaths.append(parsingPath) if len(finalParsingPaths) == 0: raise Exception("No parsing path returned while parsing message {0}".format(dataToParse)) parsingResult = finalParsingPaths[len(finalParsingPaths) - 1] result = [] for field in fields: result.append(parsingResult.getDataAssignedToField(field)) test = result[0].copy() for res in result[1:]: test += res.copy() # if test != bitArrayToParse: # raise Exception("OUPS") self.memory = parsingResult.memory return result