def _specializeField(self, specializingPath=None): if specializingPath is None: specializingPath = SpecializingPath(memory=Memory()) # we retrieve the field definition domain domain = self.field.domain # and check it exists if domain is None: raise Exception( "No definition domain specified for field '{0}', cannnot parse the content against it." .format(self.field.name)) # we create a first VariableParser and uses it to parse the domain variableSpecializer = VariableSpecializer(domain) resultSpecializingPaths = variableSpecializer.specialize( specializingPath) for resultSpecializingPath in resultSpecializingPaths: assignedData = bitarray('') if resultSpecializingPath.isDataAvailableForVariable( self.field.domain): assignedData = resultSpecializingPath.getDataAssignedToVariable( self.field.domain) else: resultSpecializingPath.addResult(self.field.domain, assignedData) self._logger.debug( "FieldSpecializer Result: {0}".format(assignedData)) resultSpecializingPath.addResultToField(self.field, assignedData) return resultSpecializingPaths
def _specializeFieldWithChildren(self, specializingPath=None): if specializingPath is None: specializingPath = SpecializingPath(memory=Memory()) resultPaths = [specializingPath] for child in self.field.fields: fs = FieldSpecializer(child, presets=self.presets) tmpResultPaths = [] for path in resultPaths: tmpResultPaths.extend(fs.specialize(path)) resultPaths = tmpResultPaths for resultPath in resultPaths: value = None for child in self.field.fields: childResult = resultPath.getDataAssignedToVariable( child.domain) if value is None: value = childResult.copy() else: value += childResult.copy() resultPath.addResult(self.field.domain, value) resultPath.addResultToField(self.field, value) return resultPaths
def specializeSymbol(self, symbol): """This method generates a message based on the provided symbol definition.""" if symbol is None: raise Exception("Specified symbol is None") self._logger.debug("Specifies symbol '{0}'.".format(symbol.name)) # this variable host all the specialization path specializingPaths = [SpecializingPath(memory=self.memory)] for field in symbol.fields: self._logger.debug("Specializing field {0}".format(field.name)) fieldDomain = field.domain if fieldDomain is None: raise Exception("Cannot specialize field '{0}' since it defines no domain".format(fieldDomain)) fs = FieldSpecializer(field, presets = self.presets) newSpecializingPaths = [] for specializingPath in specializingPaths: newSpecializingPaths.extend(fs.specialize(specializingPath)) specializingPaths = newSpecializingPaths if len(specializingPaths) > 1: self._logger.info("TODO: multiple valid paths found when specializing this message.") if len(specializingPaths) == 0: raise Exception("Cannot specialize this symbol.") retainedPath = specializingPaths[0] generatedContent = None # let's configure the generated content for field in symbol.fields: # TODO: only support one level of children... must be improved if len(field.fields) > 0: d = None for child in field.fields: if d is None: d = retainedPath.getDataAssignedToVariable(child.domain).copy() else: d += retainedPath.getDataAssignedToVariable(child.domain).copy() else: d = retainedPath.getDataAssignedToVariable(field.domain) if generatedContent is None: generatedContent = d.copy() else: generatedContent += d.copy() retainedPath.generatedContent = generatedContent self._logger.debug("Specialized message: {0}".format(TypeConverter.convert(retainedPath.generatedContent, BitArray, ASCII))) self.memory = retainedPath.memory return retainedPath
def specialize(self, specializingPath=None): """Execute the specialize operation""" if specializingPath is None: specializingPath = SpecializingPath(memory=Memory()) self._logger.debug("Specialize field {0}".format(self.field.name)) # does an arbitrary value is specified ? if self.arbitraryValue is not None: specializingPath.addResult(self.field.domain, self.arbitraryValue) specializingPath.addResultToField(self.field, self.arbitraryValue) return [specializingPath] # does current field has children if len(self.field.fields) > 0: return self._specializeFieldWithChildren(specializingPath) else: return self._specializeField(specializingPath)
def specialize(self, specializingPath=None): """Execute the specialize operation""" if specializingPath is None: specializingPath = SpecializingPath(memory=Memory()) self._logger.debug("Specialize field {0}".format(self.field.name)) # does an arbitrary value is specified ? if self.arbitraryValue is not None: specializingPath.addResult(self.field.domain, self.arbitraryValue) specializingPath.addResultToField(self.field, self.arbitraryValue) return [specializingPath] # does current field has children if len(self.field.fields) > 0: return self._specializeFieldWithChildren(specializingPath) else: return self._specializeField(specializingPath)