def lopUselessLeaves(cls, pn):
""" generated source for method lopUselessLeaves """
usefulComponents = HashSet()
toAdd = Stack()
toAdd.add(pn.getTerminalProposition())
usefulComponents.add(pn.getInitProposition())
for goalProps in pn.getGoalPropositions().values():
toAdd.addAll(goalProps)
for legalProps in pn.getLegalPropositions().values():
toAdd.addAll(legalProps)
while not toAdd.isEmpty():
if usefulComponents.contains(curComp):
continue
usefulComponents.add(curComp)
toAdd.addAll(curComp.getInputs())
allComponents = ArrayList(pn.getComponents())
for c in allComponents:
if not usefulComponents.contains(c):
pn.removeComponent(c)
def removeUnreachableBasesAndInputs(cls, pn, basesTrueByInit):
""" generated source for method removeUnreachableBasesAndInputs """
reachability = Maps.newHashMap()
numTrueInputs = HashMultiset.create()
numFalseInputs = HashMultiset.create()
toAdd = Stack()
legalsToInputs = Maps.newHashMap()
for legalProp in Iterables.concat(pn.getLegalPropositions().values()):
if inputProp != None:
legalsToInputs.put(legalProp, inputProp)
for c in pn.getComponents():
ConcurrencyUtils.checkForInterruption()
if isinstance(c, (Constant, )):
if c.getValue():
toAdd.add(Pair.of(c, cls.Type.TRUE))
else:
toAdd.add(Pair.of(c, cls.Type.FALSE))
for p in pn.getInputPropositions().values():
toAdd.add(Pair.of(p, cls.Type.FALSE))
for baseProp in pn.getBasePropositions().values():
if basesTrueByInit.contains(baseProp):
toAdd.add(Pair.of(baseProp, cls.Type.TRUE))
else:
toAdd.add(Pair.of(baseProp, cls.Type.FALSE))
initProposition = pn.getInitProposition()
toAdd.add(Pair.of(initProposition, cls.Type.BOTH))
while not toAdd.isEmpty():
ConcurrencyUtils.checkForInterruption()
if oldType == None:
oldType = cls.Type.NEITHER
if isinstance(curComp, (Proposition, )):
typeToAdd = newInputType
elif isinstance(curComp, (Transition, )):
typeToAdd = newInputType
elif isinstance(curComp, (Constant, )):
typeToAdd = newInputType
elif isinstance(curComp, (Not, )):
typeToAdd = newInputType.opposite()
elif isinstance(curComp, (And, )):
if newInputType.hasTrue:
numTrueInputs.add(curComp)
if numTrueInputs.count(curComp) == curComp.getInputs().size():
typeToAdd = cls.Type.TRUE
if newInputType.hasFalse:
typeToAdd = typeToAdd.with_(cls.Type.FALSE)
elif isinstance(curComp, (Or, )):
if newInputType.hasFalse:
numFalseInputs.add(curComp)
if numFalseInputs.count(curComp) == curComp.getInputs().size():
typeToAdd = cls.Type.FALSE
if newInputType.hasTrue:
typeToAdd = typeToAdd.with_(cls.Type.TRUE)
else:
raise RuntimeException("Unhandled component type " + curComp.__class__)
if oldType.includes(typeToAdd):
continue
reachability.put(curComp, typeToAdd.with_(oldType))
typeToAdd = typeToAdd.minus(oldType)
if typeToAdd == cls.Type.NEITHER:
raise RuntimeException("Something's messed up here")
for output in curComp.getOutputs():
toAdd.add(Pair.of(output, typeToAdd))
if legalsToInputs.containsKey(curComp):
if inputProp == None:
raise IllegalStateException()
toAdd.add(Pair.of(inputProp, typeToAdd))
trueConst = Constant(True)
falseConst = Constant(False)
pn.addComponent(trueConst)
pn.addComponent(falseConst)
for entry in reachability.entrySet():
if type_ == cls.Type.TRUE or type_ == cls.Type.FALSE:
if isinstance(c, (Constant, )):
continue
for input in c.getInputs():
input.removeOutput(c)
c.removeAllInputs()
if type_ == cls.Type.TRUE ^ (isinstance(c, (Not, ))):
c.addInput(trueConst)
trueConst.addOutput(c)
else:
c.addInput(falseConst)
falseConst.addOutput(c)
cls.optimizeAwayTrueAndFalse(pn, trueConst, falseConst)
class MappingGdlScrambler(GdlScrambler):
""" generated source for class MappingGdlScrambler """
scrambleMapping = Map()
unscrambleMapping = Map()
random = Random()
scrambledPrefix = int()
scrambledTokens = Stack()
def __init__(self, theRandom):
""" generated source for method __init__ """
super(MappingGdlScrambler, self).__init__()
self.random = theRandom
self.scrambleMapping = HashMap()
self.unscrambleMapping = HashMap()
self.scrambledPrefix = 0
self.scrambledTokens = Stack()
for word in WordList.words:
self.scrambledTokens.add(word)
Collections.shuffle(self.scrambledTokens, self.random)
class ScramblingRenderer(GdlRenderer):
""" generated source for class ScramblingRenderer """
def renderConstant(self, constant):
""" generated source for method renderConstant """
return scrambleWord(constant.getValue())
def renderVariable(self, variable):
""" generated source for method renderVariable """
return scrambleWord(variable.__str__())
class UnscramblingRenderer(GdlRenderer):
""" generated source for class UnscramblingRenderer """
def renderConstant(self, constant):
""" generated source for method renderConstant """
return unscrambleWord(constant.getValue())
def renderVariable(self, variable):
""" generated source for method renderVariable """
return unscrambleWord(variable.__str__())
def scramble(self, x):
""" generated source for method scramble """
return self.ScramblingRenderer().renderGdl(x)
def unscramble(self, x):
""" generated source for method unscramble """
return GdlFactory.create(self.UnscramblingRenderer().renderGdl(GdlFactory.create(x)))
def scrambles(self):
""" generated source for method scrambles """
return True
def scrambleWord(self, realWord):
""" generated source for method scrambleWord """
if not shouldMap(realWord):
return realWord
if not self.scrambleMapping.containsKey(realWord):
if realWord.startsWith("?"):
fakeWord = "?" + fakeWord
self.scrambleMapping.put(realWord, fakeWord)
self.unscrambleMapping.put(fakeWord, realWord)
return self.scrambleMapping.get(realWord)
def unscrambleWord(self, fakeWord):
""" generated source for method unscrambleWord """
if not shouldMap(fakeWord):
return fakeWord
fakeWord = fakeWord.lower()
if not self.unscrambleMapping.containsKey(fakeWord):
return fakeWord
return self.unscrambleMapping.get(fakeWord)
def getRandomWord(self):
""" generated source for method getRandomWord """
if self.scrambledTokens.isEmpty():
for word in WordList.words:
self.scrambledTokens.add(word + self.scrambledPrefix)
Collections.shuffle(self.scrambledTokens, self.random)
self.scrambledPrefix += 1
return self.scrambledTokens.pop()
@classmethod
def shouldMap(cls, token):
""" generated source for method shouldMap """
if GdlPool.KEYWORDS.contains(token.lower()):
return False
try:
Integer.parseInt(token)
return False
except NumberFormatException as e:
return True
