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
