def getBestVariable(self, functionalSentence, functionInfo):
""" generated source for method getBestVariable """
# If all the variables that can be set by the functional sentence are in
# the varOrdering, we return null. Otherwise, we return one of
# those with the largest domain.
# The FunctionInfo is sentence-independent, so we need the context
# of the sentence (which has variables in it).
tuple_ = GdlUtils.getTupleFromSentence(functionalSentence)
dependentSlots = functionInfo.getDependentSlots()
if len(tuple_) != len(dependentSlots):
raise RuntimeException("Mismatched sentence " + functionalSentence + " and constant form " + functionInfo)
candidateVars = HashSet()
i = 0
while i < len(tuple_):
if isinstance(term, (GdlVariable, )) and dependentSlots.get(i) and not self.varOrdering.contains(term) and self.varsToAssign.contains(term):
candidateVars.add(term)
i += 1
# Now we look at the domains, trying to find the largest
bestVar = None
bestDomainSize = 0
for var in candidateVars:
if domainSize > bestDomainSize:
bestVar = var
bestDomainSize = domainSize
return bestVar
def getReplacementAssignment(self, sentence, varGen):
""" generated source for method getReplacementAssignment """
Preconditions.checkArgument(self.applies(sentence))
assignment = Maps.newHashMap()
tuple_ = GdlUtils.getTupleFromSentence(sentence)
for varIndex in replacementsByOriginalTupleIndex.keySet():
assignment.put(tuple_.get(varIndex), replacementFunction)
return assignment
def applies(self, sentence):
""" generated source for method applies """
if not self.original.matches(sentence):
return False
tuple_ = GdlUtils.getTupleFromSentence(sentence)
for varIndex in replacementsByOriginalTupleIndex.keySet():
if not (isinstance(, (GdlVariable, ))):
return False
return True
def getNewFormDomain(cls, condensingRule, oldModel, newForm):
""" generated source for method getNewFormDomain """
varDomains = SentenceDomainModels.getVarDomains(condensingRule, oldModel, VarDomainOpts.BODY_ONLY)
domainsForSlots = Lists.newArrayList()
for term in GdlUtils.getTupleFromSentence(condensingRule.getHead()):
if not (isinstance(term, (GdlVariable, ))):
raise RuntimeException("Expected all slots in the head of a condensing rule to be variables, but the rule was: " + condensingRule)
domainsForSlots.add(varDomains.get(term))
return CartesianSentenceFormDomain.create(newForm, domainsForSlots)
def getVarDomainInSentence(cls, var, conjunct, newPossibleConstantsByForm, curDomain, model):
""" generated source for method getVarDomainInSentence """
form = model.getSentenceForm(conjunct)
tuple_ = GdlUtils.getTupleFromSentence(conjunct)
domains = Lists.newArrayList()
i = 0
while i < len(tuple_):
if tuple_.get(i) == var:
domains.add(newPossibleConstantsByForm.get(form).get(i))
domains.add(curDomain.get(form).get(i))
i += 1
return getIntersection(domains)
def addConstantsFromSentenceIfInOldDomain(cls, newConstantsByForm, oldDomain, model, sentence):
""" generated source for method addConstantsFromSentenceIfInOldDomain """
form = model.getSentenceForm(sentence)
tuple_ = GdlUtils.getTupleFromSentence(sentence)
if len(tuple_) != form.getTupleSize():
raise IllegalStateException()
i = 0
while i < form.getTupleSize():
ConcurrencyUtils.checkForInterruption()
if isinstance(term, (GdlConstant, )):
if oldDomainForTerm.contains(term):
newConstantsByForm.get(form).put(i, term)
i += 1
def addPossibleValuesToSentence(cls, neededAndPossibleConstants, sentence, curVar, neededConstantsByForm, model):
""" generated source for method addPossibleValuesToSentence """
ConcurrencyUtils.checkForInterruption()
somethingChanged = False
form = model.getSentenceForm(sentence)
tuple_ = GdlUtils.getTupleFromSentence(sentence)
Preconditions.checkArgument(form.getTupleSize() == len(tuple_))
i = 0
while i < len(tuple_):
if tuple_.get(i) == curVar:
Preconditions.checkNotNull(neededConstantsByForm.get(form))
Preconditions.checkNotNull(neededAndPossibleConstants)
somethingChanged |= neededConstantsByForm.get(form).putAll(i, neededAndPossibleConstants)
i += 1
return somethingChanged
def getProducibleVars(self, sentence):
""" generated source for method getProducibleVars """
if not self.form.matches(sentence):
raise RuntimeException("Sentence " + sentence + " does not match constant form")
tuple_ = GdlUtils.getTupleFromSentence(sentence)
candidateVars = HashSet()
# Variables that appear multiple times go into multipleVars
multipleVars = HashSet()
# ...which, of course, means we have to spot non-candidate vars
nonCandidateVars = HashSet()
i = 0
while i < len(tuple_):
if isinstance(term, (GdlVariable,)) and not multipleVars.contains(term):
if candidateVars.contains(var) or nonCandidateVars.contains(var):
multipleVars.add(var)
candidateVars.remove(var)
elif self.dependentSlots.get(i):
candidateVars.add(var)
else:
nonCandidateVars.add(var)
i += 1
return candidateVars
