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 create_0(cls, form, setMultimap):
""" generated source for method create_0 """
Preconditions.checkNotNull(setMultimap)
domainsForSlots = Lists.newArrayList()
i = 0
while i < form.getTupleSize():
domainsForSlots.add(setMultimap.get(i))
i += 1
return cls.create(form, domainsForSlots)
def applyAmbiguities(cls, originalRule, ambiguitiesByOriginalForm, model):
""" generated source for method applyAmbiguities """
rules = Lists.newArrayList(originalRule)
# Each literal can potentially multiply the number of rules we have, so
# we apply each literal separately to the entire list of rules so far.
for literal in Iterables.concat(ImmutableSet.of(originalRule.getHead()), originalRule.getBody()):
for rule in rules:
Preconditions.checkArgument(originalRule.arity() == rule.arity())
newRules.addAll(applyAmbiguitiesForLiteral(literal, rule, ambiguitiesByOriginalForm, model))
rules = newRules
return rules
def __init__(self, original, replacementsByOriginalTupleIndex, replacement):
""" generated source for method __init__ """
Preconditions.checkNotNull(original)
Preconditions.checkNotNull(replacementsByOriginalTupleIndex)
Preconditions.checkArgument(not replacementsByOriginalTupleIndex.isEmpty())
Preconditions.checkNotNull(replacement)
for varIndex in replacementsByOriginalTupleIndex.keySet():
Preconditions.checkElementIndex(varIndex, original.getTupleSize())
self.original = original
self.replacementsByOriginalTupleIndex = replacementsByOriginalTupleIndex
self.replacement = replacement
def findAmbiguity(cls, original, replacement):
""" generated source for method findAmbiguity """
Preconditions.checkArgument(original.__name__ == replacement.__name__)
Preconditions.checkArgument(not original == replacement)
ConcurrencyUtils.checkForInterruption()
replacementsByOriginalTupleIndex = Maps.newHashMap()
# Make the arguments ?v0, ?v1, ?v2, ... so we can find the tuple indices easily
originalSentence = original.getSentenceFromTuple(getNumberedTuple(original.getTupleSize()))
replacementSentence = replacement.getSentenceFromTuple(getNumberedTuple(replacement.getTupleSize()))
success = cls.findAmbiguity(originalSentence.getBody(), replacementSentence.getBody(), replacementsByOriginalTupleIndex)
if success:
return Optional.of(cls.Ambiguity.create(original, replacementsByOriginalTupleIndex, replacement))
else:
return Optional.absent()
def getFunctionFromTuple(self, tuple_, curIndex):
""" generated source for method getFunctionFromTuple """
functionBody = Lists.newArrayList()
i = 0
while i < self.arity:
Preconditions.checkArgument(not (isinstance(term, (GdlFunction, ))))
if self.functions.containsKey(i):
functionBody.add(functionForm.getFunctionFromTuple(tuple_, curIndex))
curIndex += functionForm.getTupleSize()
else:
functionBody.add(term)
curIndex += 1
i += 1
return GdlPool.getFunction(self.name, functionBody)
def applyInjection(self, oldName, newName):
""" generated source for method applyInjection """
ConcurrencyUtils.checkForInterruption()
Preconditions.checkArgument(oldName.getArity() == newName.getArity())
changesMade = False
if self.sentencesModel.containsKey(oldName):
if not self.sentencesModel.containsKey(newName):
changesMade = True
self.sentencesModel.put(newName, getNTermModels(newName.arity))
if len(oldModel) != len(newModel):
raise IllegalStateException()
while i < len(oldModel):
ConcurrencyUtils.checkForInterruption()
changesMade |= newModel.get(i).mergeIn(oldModel.get(i))
i += 1
return changesMade
def getSentenceFromTuple(self, tuple_):
""" generated source for method getSentenceFromTuple """
if len(tuple_) != self.tupleSize:
raise IllegalArgumentException("Passed tuple of the wrong size to a sentence form: " + "tuple was " + tuple_ + ", sentence form is " + self)
if len(tuple_) < self.arity:
raise IllegalStateException("Something is very wrong, probably fixable by the GdlCleaner; name: " + self.name + "; arity: " + self.arity + "; tupleSize: " + self.tupleSize)
sentenceBody = Lists.newArrayList()
curIndex = 0
i = 0
while i < self.arity:
Preconditions.checkArgument(not (isinstance(term, (GdlFunction, ))))
if self.functions.containsKey(i):
sentenceBody.add(functionForm.getFunctionFromTuple(tuple_, curIndex))
curIndex += functionForm.getTupleSize()
else:
sentenceBody.add(term)
curIndex += 1
i += 1
if self.arity == 0:
return GdlPool.getProposition(self.name)
else:
return GdlPool.getRelation(self.name, sentenceBody)
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 __init__(self, gameDescription, sentenceForms, constantSentenceForms, independentSentenceForms, dependencyGraph, rulesByForm, trueSentencesByForm):
""" generated source for method __init__ """
super(ImmutableSentenceFormModel, self).__init__()
Preconditions.checkArgument(sentenceForms.containsAll(independentSentenceForms))
Preconditions.checkArgument(independentSentenceForms.containsAll(constantSentenceForms))
Preconditions.checkArgument(sentenceForms.containsAll(dependencyGraph.keySet()))
Preconditions.checkArgument(sentenceForms.containsAll(dependencyGraph.values()))
Preconditions.checkArgument(sentenceForms.containsAll(rulesByForm.keySet()))
Preconditions.checkArgument(sentenceForms.containsAll(trueSentencesByForm.keySet()))
self.gameDescription = gameDescription
self.sentenceForms = sentenceForms
self.constantSentenceForms = constantSentenceForms
self.independentSentenceForms = independentSentenceForms
self.dependencyGraph = dependencyGraph
self.rulesByForm = rulesByForm
self.trueSentencesByForm = trueSentencesByForm
def getDomainForSlot(self, slotIndex):
""" generated source for method getDomainForSlot """
Preconditions.checkElementIndex(slotIndex, self.form.getTupleSize())
return self.domainsForSlots.get(slotIndex)
def __init__(self, sentenceModel, sentencesByForm):
""" generated source for method __init__ """
super(ImmutableConstantChecker, self).__init__()
Preconditions.checkArgument(sentenceModel.getConstantSentenceForms().containsAll(sentencesByForm.keySet()))
self.sentenceModel = sentenceModel
self.sentencesByForm = sentencesByForm
