/** * Public method to determine if the word has been solved * * @return boolean true if solved */ public boolean isSolved() { /** Always use a local result */ boolean result = false; /** No. of true occurrences */ int countTrue = 0; /** Iterate over all letters, be sure there is an Assertion for each */ List<CipherLetter> list = this.getLetters(); int count = list.size(); for (CipherLetter letter : list) { Stack<Assumption> stack = letter.getAffirmations().getStatements(); for (int i = 0; i < stack.size(); i++) { Assumption assumption = stack.pop(); if (!assumption.isRetractable()) { countTrue++; } } } /** If the no. of true occurrences equals the no. of letters it's solved */ if (count == countTrue) { result = true; } return result; }
/** * Populates the HTML templates by replacing variables in the template string with the given value * string. * * @param template The template html to be populated * @param values Array of a variable, even number of key-value pairs: { "key1", "val1", "key2", * "val2", ... } * @return The populated template */ public static String populateTemplate(String template, String... values) { Assumption.assertTrue("The number of values passed in must be even", values.length % 2 == 0); String populatedTemplate = template; for (int i = 0; i < values.length; i += 2) { populatedTemplate = populatedTemplate.replace(values[i], values[i + 1]); } return populatedTemplate; }
@Override public double executeFloat(RubyBasicObject receiver) throws UnexpectedResultException { if (hasFloat && receiver.getRubyClass() == expectedClass && unmodifiedAssumption.isValid()) { return integerFixnumValue; } else { return next.executeFloat(receiver); } }
@Override public boolean executeBoolean(RubyBasicObject receiver) throws UnexpectedResultException { if (hasBoolean && receiver.getRubyClass() == expectedClass && unmodifiedAssumption.isValid()) { return booleanValue; } else { return next.executeBoolean(receiver); } }
@Override public void leave(Node astNode, VirtualFrame frame, Object result) { try { inactiveAssumption.check(); } catch (InvalidAssumptionException e) { final ActiveLeaveDebugProbe activeNode = createActive(); replace(activeNode); activeNode.leave(astNode, frame, result); } }
@Override public long executeLongFixnum(RubyBasicObject receiver) throws UnexpectedResultException { if (hasLongFixnum && receiver.getRubyClass() == expectedClass && unmodifiedAssumption.isValid()) { return longFixnumValue; } else { return next.executeLongFixnum(receiver); } }
@Override public Object execute(RubyBasicObject receiver) { // TODO(CS): not sure trying next on invalid assumption is right... if (receiver.getRubyClass() == expectedClass && unmodifiedAssumption.isValid()) { return value; } else { return next.execute(receiver); } }
/** * Transforms the already calculated term into a new implication of the already calculated term * and the given assertion. */ @Override public Assumption assume(Assumption assumption) { wp = new Implication(assumption.getTerm(), wp); return null; }
/** * Substitutes the middle third of the given string with dots and returns the "obscured" string * * @param inputString * @return */ public static String obscure(String inputString) { Assumption.assertNotNull(inputString); String frontPart = inputString.substring(0, inputString.length() / 3); String endPart = inputString.substring(2 * inputString.length() / 3); return frontPart + ".." + endPart; }