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