def main(cls, args): """ generated source for method main """ GamerLogger.setSpilloverLogfile("spilloverLog") GamerLogger.log("Proxy", "Starting the ProxyGamePlayerClient program.") if not (len(args)): GamerLogger.logError("Proxy", "Usage is: \n\tProxyGamePlayerClient gamer port") return port = 9147 gamer = None try: port = Integer.valueOf(args[1]) except Exception as e: GamerLogger.logError("Proxy", args[1] + " is not a valid port.") return gamers = Lists.newArrayList(ProjectSearcher.GAMERS.getConcreteClasses()) gamerNames = ArrayList() if len(gamerNames) != len(gamers): for c in gamers: gamerNames.add(c.__name__.replaceAll("^.*\\.", "")) idx = gamerNames.indexOf(args[0]) if idx == -1: GamerLogger.logError("Proxy", args[0] + " is not a subclass of gamer. Valid options are:") for s in gamerNames: GamerLogger.logError("Proxy", "\t" + s) return try: gamer = (gamers.get(idx).newInstance()) except Exception as ex: GamerLogger.logError("Proxy", "Cannot create instance of " + args[0]) return try: theClient.start() except IOException as e: GamerLogger.logStackTrace("Proxy", e)
def graph(cls, srcpath, inclpaths, symOut, refOut, docOut): """ generated source for method graph """ parentDirs = Lists.newArrayList(inclpaths) parentDirs.add(cls.dirname(srcpath)) def compare(a,b): return a - b parentDirs = sorted(parentDirs, compare) idx = cls.newAnalyzer(srcpath, inclpaths) idx.multilineFunType = True jsonFactory = JsonFactory() symJson = jsonFactory.createGenerator(symOut) refJson = jsonFactory.createGenerator(refOut) docJson = jsonFactory.createGenerator(docOut) allJson = [symJson, refJson, docJson] for json in allJson: json.writeStartArray() for b in idx.getAllBindings(): if b.getFile() is not None: if cls.shouldEmit(b.getFile(), srcpath): cls.writeSymJson(b, symJson) cls.writeDocJson(b, idx, docJson) for ref in b.getRefs(): if ref.getFile() is not None: if not cls.seenRef.contains(key) and cls.shouldEmit(ref.getFile(), srcpath): cls.writeRefJson(ref, b, refJson) cls.seenRef.add(key) for json in allJson: json.writeEndArray() json.close()
def toposortSafe(cls, allElements, dependencyGraph): """ generated source for method toposortSafe """ strataToAdd = createAllStrata(allElements) strataDependencyGraph = createStrataDependencyGraph(dependencyGraph) ordering = Lists.newArrayList() while not strataToAdd.isEmpty(): addOrMergeStratumAndAncestors(curStratum, ordering, strataToAdd, strataDependencyGraph, Lists.newArrayList()) return ordering
def getNTermModels(cls, arity): """ generated source for method getNTermModels """ result = Lists.newArrayListWithCapacity(arity) i = 0 while i < arity: result.add(TermModel()) i += 1 return result
def getVariablesTuple(cls, tupleSize): """ generated source for method getVariablesTuple """ varsTuple = Lists.newArrayList() i = 0 while i < tupleSize: varsTuple.add(GdlPool.getVariable("?" + i)) i += 1 return varsTuple
def getNumberedTuple(cls, tupleSize): """ generated source for method getNumberedTuple """ result = Lists.newArrayList() i = 0 while i < tupleSize: result.add(GdlPool.getVariable("?v" + Integer.toString(i))) i += 1 return result
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 getNUnderscores(cls, numTerms): """ generated source for method getNUnderscores """ underscore = GdlPool.UNDERSCORE terms = Lists.newArrayListWithCapacity(numTerms) i = 0 while i < numTerms: terms.add(underscore) i += 1 return terms
def getAmbiguities(cls, original, forms): """ generated source for method getAmbiguities """ result = Lists.newArrayList() for form in forms: if form == original: continue if ambiguity.isPresent(): result.add(ambiguity.get()) return result
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 run(cls, oldRules): """ generated source for method run """ oldRules = DeORer.run(oldRules) newRules = Lists.newArrayListWithCapacity(len(oldRules)) for gdl in oldRules: if isinstance(gdl, (GdlRule, )): newRules.add(reorderRule(rule)) else: newRules.add(gdl) return newRules
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 readFileToStructure(self, path, structure): header = PdbHeader() header.setTitle(Paths.get(path).getFileName().toString()) structure.setPDBHeader(header) model = ReadFile.getModelFromFile(self, path) structure.setChains(Lists.newArrayList(model)) info = PdbCryst() info.setSpaceGroup(SpaceGroup(0, 1, 1, "P 1", "P 1", BravaisL.CUBIC)) info.setCrystalCell(ReadFile.getBox(self, info.getSpaceGroup().getBravLattice().getExampleUnitCell())) header.setCrystallographicInfo(info) return structure
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 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 applyAmbiguitiesForLiteral(cls, literal, rule, ambiguitiesByOriginalForm, model): """ generated source for method applyAmbiguitiesForLiteral """ ConcurrencyUtils.checkForInterruption() results = Lists.newArrayList(rule) varGen = getVariableGenerator(rule) if isinstance(literal, (GdlSentence, )): for ambiguity in ambiguitiesByOriginalForm.get(form): ConcurrencyUtils.checkForInterruption() if ambiguity.applies(sentence): results.add(newRule) elif isinstance(literal, (GdlNot, )): # Do nothing. Variables must appear in a positive literal in the # rule, and will be handled there. elif isinstance(literal, (GdlOr, )): raise RuntimeException("ORs should have been removed") elif isinstance(literal, (GdlDistinct, )): # Do nothing return results class UnusedVariableGenerator(object): """ generated source for class UnusedVariableGenerator """ def replaceVariablesAndConstants(self, function_): """ generated source for method replaceVariablesAndConstants """ assignment = Maps.newHashMap() termsToReplace = Sets.newHashSet() GdlVisitors.visitAll(function_, GdlVisitor()) for var in GdlUtils.getVariables(function_): assignment.put(var, getUnusedVariable()) return CommonTransforms.replaceVariables(function_, assignment) def getUnusedVariable(self): """ generated source for method getUnusedVariable """ @classmethod def getVariableGenerator(cls, rule): """ generated source for method getVariableGenerator """ # Not thread-safe return cls.UnusedVariableGenerator() # # * Removes rules with sentences with empty domains. These simply won't have # * sentence forms in the generated sentence model, so this is fairly easy. # * @throws InterruptedException # @classmethod def cleanUpIrrelevantRules(cls, expandedRules): """ generated source for method cleanUpIrrelevantRules """ model = SentenceFormModelFactory.create(expandedRules) return ImmutableList.copyOf(Collections2.filter(expandedRules, Predicate()))
def create(cls, form, domain): """ generated source for method create """ domainsForSlotsBuilder = Lists.newArrayList() i = 0 while i < form.getTupleSize(): domainsForSlotsBuilder.add(ImmutableSet.builder()) i += 1 for sentence in domain: assert form.matches(sentence) if len(tuple_) != form.getTupleSize(): raise IllegalArgumentException() while i < len(tuple_): domainsForSlotsBuilder.get(i).add(constant) i += 1 domainsForSlots = ImmutableList.builder() for builder in domainsForSlotsBuilder: domainsForSlots.add(builder.build()) return FullSentenceFormDomain(form, ImmutableList.copyOf(domain), domainsForSlots.build())
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 reorderRule(cls, oldRule): """ generated source for method reorderRule """ newBody = Lists.newArrayList(oldRule.getBody()) rearrangeDistinctsAndNots(newBody) return GdlPool.getRule(oldRule.getHead(), newBody)
def run(cls, description): """ generated source for method run """ # This class is not put together in any "optimal" way, so it's left in # an unpolished state for now. A better version would use estimates of # the impact of breaking apart rules. (It also needs to stop itself from # making multiple new relations with the same meaning.) # This version will be rather advanced. # In particular, it will try to incorporate # 1) More thorough scanning for condensations; # 2) Condensations that are only safe to perform because of mutexes. # TODO: Don't perform condensations on stuff like (add _ _ _)... # In general, don't perform condensations where the headroom is huge? # Better yet... DON'T perform condensations on recursive functions! # As for headroom... maybe make sure that # of vars eliminated > # "kept" # Or make sure none are kept? Use directional connected components? description = GdlCleaner.run(description) description = DeORer.run(description) description = VariableConstrainer.replaceFunctionValuedVariables(description) # How do we define a condensation, and what needs to be true in it? # Definition: A condensation set is a set of conjuncts of a # sentence. # Restrictions: # 1) There must be some variable not in the head of the sentence that # appears exclusively in the condensation set. (This means we can # easily find sets one of which must be a condensation set.) # 2) For any variable appearing in a distinct or not conjunct in the set, # there must be a positive conjunct in the set also containing that # variable. This does apply to variables found in the head. # 3) There must be at least one non-distinct literal outside the # condensation set. # How mutexes work: # Say we have a rule # (<= (r1 ?b) # (r2 ?a ?b ?c) # (r3 ?b ?c) # (r4 ?a) # (r5 ?c)) # If we wanted to factor out ?a, we'd normally have to do # (<= (r6 ?b ?c) # * (r2 ?a ?b ?c) # * (r4 ?a)) # * (<= (r1 ?b) # * (r6 ?b ?c) # * (r3 ?b ?c) # * (r5 ?c)) # * But if we know r2 is a mutex, instead we can do (notice r2 splitting): # * (<= (r6 ?b) # * (r2 ?a ?b ?c) # * (r4 ?a)) # * (<= (r1 ?b) # * (r2 ?a ?b ?c) # * (r6 ?b) # * (r3 ?b ?c) # * (r5 ?c)) # * Which in turn becomes: # * (<= (r6 ?b) # * (r2 ?a ?b ?c) # * (r4 ?a)) # * (<= (r7 ?b) # * (r2 ?a ?b ?c) # * (r3 ?b ?c) # * (r5 ?c)) # * (<= (r1 ?b) # * (r6 ?b) # * (r7 ?b)) # * Both r6 and r7 can be further condensed to ignore ?c and ?a, # * respectively. What just happened? # * 1) The condensation set for ?a included the mutex r2. # * 2) r2 (by itself) would have required ?c to be included as an # * argument passed back to the original rule, which is undesirable. # * Instead, as it's a mutex, we leave a copy in the original rule # * and don't include the ?c. # * # * So, what kind of algorithm can we find to solve this task? # newDescription = ArrayList() rulesToAdd = LinkedList() for gdl in description: if isinstance(gdl, (GdlRule, )): rulesToAdd.add(gdl) else: newDescription.add(gdl) # Don't use the model indiscriminately; it reflects the old description, # not necessarily the new one model = SentenceDomainModelFactory.createWithCartesianDomains(description) model = SentenceDomainModelOptimizer.restrictDomainsToUsefulValues(model) sentenceNameSource = UnusedSentenceNameSource.create(model) constantChecker = ConstantCheckerFactory.createWithForwardChaining(model) constantForms = model.getConstantSentenceForms() ConcurrencyUtils.checkForInterruption() curDescription = Lists.newArrayList(description) while not rulesToAdd.isEmpty(): if isRecursive(curRule): # Don't mess with it! newDescription.add(curRule) continue if SentenceModelUtils.inSentenceFormGroup(curRuleHead, constantForms): newDescription.add(curRule) continue ConcurrencyUtils.checkForInterruption() if condensationSet != None: rulesToAdd.addAll(newRules) # Since we're making only small changes, we can readjust # the model as we go, instead of recomputing it replacementDescription.removeAll(oldRules) replacementDescription.addAll(newRules) curDescription = replacementDescription model = augmentModelWithNewForm(model, newRules) else: newDescription.add(curRule) return newDescription
def __init__(self, headAssignment, rule, varDomains, functionInfoMap, completedSentenceFormValues): """ generated source for method __init__ """ super(AssignmentsImpl, self).__init__() self.empty = False self.headAssignment = headAssignment # We first have to find the remaining variables in the body self.varsToAssign = GdlUtils.getVariables(rule) # Remove all the duplicates; we do, however, want to keep the ordering newVarsToAssign = ArrayList() for v in varsToAssign: if not newVarsToAssign.contains(v): newVarsToAssign.add(v) self.varsToAssign = newVarsToAssign self.varsToAssign.removeAll(headAssignment.keySet()) # varsToAssign is set at this point # We see if iterating over entire tuples will give us a # better result, and we look for the best way of doing that. # Let's get the domains of the variables # Map<GdlVariable, Set<GdlConstant>> varDomains = model.getVarDomains(rule); # Since we're looking at a particular rule, we can do this one step better # by looking at the domain of the head, which may be more restrictive # and taking the intersections of the two domains where applicable # Map<GdlVariable, Set<GdlConstant>> headVarDomains = model.getVarDomainsInSentence(rule.getHead()); # We can run the A* search for a good set of source conjuncts # at this point, then use the result to build the rest. completedSentenceFormSizes = HashMap() if completedSentenceFormValues != None: for form in completedSentenceFormValues.keySet(): completedSentenceFormSizes.put(form, completedSentenceFormValues.get(form).size()) varDomainSizes = HashMap() for var in varDomains.keySet(): varDomainSizes.put(var, varDomains.get(var).size()) bestOrdering = IterationOrderCandidate() bestOrdering = getBestIterationOrderCandidate(rule, varDomains, functionInfoMap, completedSentenceFormSizes, headAssignment, False)# model, # TODO: True here? # Want to replace next few things with order # Need a few extra things to handle the use of iteration over existing tuples self.varsToAssign = bestOrdering.getVariableOrdering() # For each of these vars, we have to find one or the other. # Let's start by finding all the domains, a task already done. self.valuesToIterate = Lists.newArrayListWithCapacity(len(self.varsToAssign)) for var in varsToAssign: if varDomains.containsKey(var): if not varDomains.get(var).isEmpty(): self.valuesToIterate.add(ImmutableList.copyOf(varDomains.get(var))) else: self.valuesToIterate.add(ImmutableList.of(GdlPool.getConstant("0"))) else: self.valuesToIterate.add(ImmutableList.of(GdlPool.getConstant("0"))) # Okay, the iteration-over-domain is done. # Now let's look at sourced iteration. self.sourceDefiningSlot = ArrayList(len(self.varsToAssign)) i = 0 while i < len(self.varsToAssign): self.sourceDefiningSlot.add(-1) i += 1 # We also need to convert values into tuples # We should do so while constraining to any constants in the conjunct # Let's convert the conjuncts sourceConjuncts = bestOrdering.getSourceConjuncts() self.tuplesBySource = Lists.newArrayListWithCapacity(len(sourceConjuncts)) # new ArrayList<List<List<GdlConstant>>>(len(sourceConjuncts)); self.varsChosenBySource = Lists.newArrayListWithCapacity(len(sourceConjuncts)) # new ArrayList<List<Integer>>(len(sourceConjuncts)); self.putDontCheckBySource = Lists.newArrayListWithCapacity(len(sourceConjuncts)) # new ArrayList<List<Boolean>>(len(sourceConjuncts)); j = 0 while j < len(sourceConjuncts): # flatten into a tuple # Go through the vars/constants in the tuple while i < len(conjunctTuple): if isinstance(term, (GdlConstant, )): constraintSlots.add(i) constraintValues.add(term) # TODO: What if tuple size ends up being 0? # Need to keep that in mind elif isinstance(term, (GdlVariable, )): varsChosen.add(varIndex) if self.sourceDefiningSlot.get(varIndex) == -1: # We define it self.sourceDefiningSlot.set(varIndex, j) putDontCheck.add(True) else: # It's an overlap; we just check for consistency putDontCheck.add(False) else: raise RuntimeException("Function returned in tuple") i += 1 self.varsChosenBySource.add(ImmutableList.copyOf(varsChosen)) self.putDontCheckBySource.add(ImmutableList.copyOf(putDontCheck)) # Now we put the tuples together # We use constraintSlots and constraintValues to check that the # tuples have compatible values for sentence in sentences: # Check that it doesn't conflict with our headAssignment if not headAssignment.isEmpty(): for var in headAssignment.keySet(): if tupleAssignment.containsKey(var) and tupleAssignment.get(var) != headAssignment.get(var): continue while c < len(constraintSlots): if not longTuple.get(slot) == value: continue c += 1 while s < len(longTuple): # constraintSlots is sorted in ascending order if c < len(constraintSlots) and constraintSlots.get(c) == s: c += 1 else: shortTuple.add(longTuple.get(s)) s += 1 # The tuple fits the source conjunct tuples.add(ImmutableList.copyOf(shortTuple)) # sortTuples(tuples); //Needed? Useful? Not sure. Probably not? self.tuplesBySource.add(ImmutableList.copyOf(tuples)) j += 1 # We now want to see which we can give assignment functions to self.valuesToCompute = ArrayList(len(self.varsToAssign)) for var in varsToAssign: self.valuesToCompute.add(None) self.indicesToChangeWhenNull = ArrayList(len(self.varsToAssign)) i = 0 while i < len(self.varsToAssign): # Change itself, why not? # Actually, instead let's try -1, to catch bugs better self.indicesToChangeWhenNull.add(-1) i += 1 # Now we have our functions already selected by the ordering # bestOrdering.functionalConjunctIndices; # Make AssignmentFunctions out of the ordering functionalConjuncts = bestOrdering.getFunctionalConjuncts() # print "functionalConjuncts: " + functionalConjuncts; i = 0 while i < len(functionalConjuncts): if functionalConjunct != None: # These are the only ones that could be constant functions if functionInfoMap != None: functionInfo = functionInfoMap.get(conjForm) if functionInfo != None: # Now we need to figure out which variables are involved # and which are suitable as functional outputs. # 1) Which vars are in this conjunct? # 2) Of these vars, which is "rightmost"? # 3) Is it only used once in the relation? if Collections.frequency(varsInSentence, rightmostVar) != 1: continue # Can't use it # 4) Which slot is it used in in the relation? # 5) Build an AssignmentFunction if appropriate. # This should be able to translate from values of # the other variables to the value of the wanted # variable. # We don't guarantee that this works until we check if not function_.functional(): continue self.valuesToCompute.set(index, function_) remainingVarsInSentence.remove(rightmostVar) self.indicesToChangeWhenNull.set(index, self.varsToAssign.indexOf(nextRightmostVar)) i += 1 # We now have the remainingVars also assigned their domains # We also cover the distincts here # Assume these are just variables and constants self.distincts = ArrayList() for literal in rule.getBody(): if isinstance(literal, (GdlDistinct, )): self.distincts.add(literal) computeVarsToChangePerDistinct() # Need to add "distinct" restrictions to head assignment, too... checkDistinctsAgainstHead()
def getAllSentencesInBody(cls, body): """ generated source for method getAllSentencesInBody """ sentences = Lists.newArrayList() GdlVisitors.visitAll(body, GdlVisitor()) return sentences
def optimizeAwayTrue(cls, components, negations, pn, trueComponent, falseComponent): """ generated source for method optimizeAwayTrue """ assert ((components != None and negations != None) or pn != None) for output in Lists.newArrayList(trueComponent.getOutputs()): if isEssentialProposition(output) or isinstance(output, (Transition, )): continue if isinstance(output, (Proposition, )): # Move its outputs to be outputs of true for child in output.getOutputs(): # Disconnect child.removeInput(output) # output.removeOutput(child); //do at end # Reconnect; will get children before returning, if nonessential trueComponent.addOutput(child) child.addInput(trueComponent) output.removeAllOutputs() if not isEssentialProposition(output): # Remove the proposition entirely trueComponent.removeOutput(output) output.removeInput(trueComponent) # Update its location to the trueComponent in our map if components != None: components.put(prop.__name__, trueComponent) negations.put(prop.__name__, falseComponent) else: pn.removeComponent(output) elif isinstance(output, (Or, )): # Attach children of or to trueComponent for child in or_.getOutputs(): child.addInput(trueComponent) trueComponent.addOutput(child) child.removeInput(or_) # Disconnect or completely or_.removeAllOutputs() for parent in or_.getInputs(): parent.removeOutput(or_) or_.removeAllInputs() if pn != None: pn.removeComponent(or_) elif isinstance(output, (And, )): # Remove as input from and and_.removeInput(trueComponent) trueComponent.removeOutput(and_) # If and has only one input, remove it if and_.getInputs().size() == 1: and_.removeInput(in_) in_.removeOutput(and_) for out in and_.getOutputs(): # Disconnect from and out.removeInput(and_) # and.removeOutput(out); //do at end # Connect directly to the new input out.addInput(in_) in_.addOutput(out) and_.removeAllOutputs() if pn != None: pn.removeComponent(and_) elif and_.getInputs().size() == 0: if pn != None: pn.removeComponent(and_) elif isinstance(output, (Not, )): # Disconnect from trueComponent not_.removeInput(trueComponent) trueComponent.removeOutput(not_) # Connect all children of the not to falseComponent for child in not_.getOutputs(): # Disconnect child.removeInput(not_) # not.removeOutput(child); //Do at end # Connect to falseComponent child.addInput(falseComponent) falseComponent.addOutput(child) not_.removeAllOutputs() if pn != None: pn.removeComponent(not_) elif isinstance(output, (Transition, )): # ??? System.err.println("Fix optimizeAwayTrue's case for Transitions")
def deepCopyOf(cls, original): """ generated source for method deepCopyOf """ copy = Lists.newArrayListWithCapacity(len(original)) for originalTermModel in original: copy.add(cls.TermModel.copyOf(originalTermModel)) return copy
def create(cls, form, domainsForSlots): """ generated source for method create """ return CartesianSentenceFormDomain(form, ImmutableList.copyOf(Lists.transform(domainsForSlots, Function())))
def toSampleTerms(self, bodyModels): """ generated source for method toSampleTerms """ results = Lists.newArrayList() for termModel in bodyModels: results.add(self.toSampleTerms(termModel)) return results
def getDomain(self, form, sentence): """ generated source for method getDomain """ domainContents = Lists.newArrayList() getDomainInternal(sentence.getBody(), self.sentencesModel.get(NameAndArity(sentence)), domainContents) return CartesianSentenceFormDomain.create(form, domainContents)