public static String substituteVariable(String input, PropertyContainer pc0, PropertyContainer pc1) throws ScanException { Node node = tokenizeAndParseString(input); NodeToStringTransformer nodeToStringTransformer = new NodeToStringTransformer(node, pc0, pc1); return nodeToStringTransformer.transform(); }
private void handleVariable(Node n, StringBuilder stringBuilder, Stack<Node> cycleCheckStack) throws ScanException { if (haveVisitedNodeAlready(n, cycleCheckStack)) { cycleCheckStack.push(n); String error = constructRecursionErrorMessage(cycleCheckStack); throw new IllegalArgumentException(error); compileNode(payload, keyBuffer, cycleCheckStack); String key = keyBuffer.toString(); String value = lookupKey(key); Node innerNode = tokenizeAndParseString(value); compileNode(innerNode, stringBuilder, cycleCheckStack); cycleCheckStack.pop(); return; compileNode(defaultPart, defaultPartBuffer, cycleCheckStack); cycleCheckStack.pop(); String defaultVal = defaultPartBuffer.toString();
private void compileNode(Node inputNode, StringBuilder stringBuilder, Stack<Node> cycleCheckStack) throws ScanException { Node n = inputNode; while (n != null) { switch (n.type) { case LITERAL: handleLiteral(n, stringBuilder); break; case VARIABLE: handleVariable(n, stringBuilder, cycleCheckStack); break; } n = n.next; } }
public static String substituteVariable(String input, PropertyContainer pc0, PropertyContainer pc1) throws ScanException { Tokenizer tokenizer = new Tokenizer(input); Parser parser = new Parser(tokenizer.tokenize()); Node node = parser.parse(); NodeToStringTransformer nodeToStringTransformer = new NodeToStringTransformer(node, pc0, pc1); return nodeToStringTransformer.transform(); }
/** * See http://logback.qos.ch/manual/configuration.html#variableSubstitution */ public static String substVars(String input, PropertyContainer pc0, PropertyContainer pc1) { try { return NodeToStringTransformer.substituteVariable(input, pc0, pc1); } catch (ScanException e) { throw new IllegalArgumentException("Failed to parse input [" + input + "]", e); } }
public String transform() throws ScanException { StringBuilder stringBuilder = new StringBuilder(); compileNode(node, stringBuilder, new Stack<Node>()); return stringBuilder.toString(); }
private void handleVariable(Node n, StringBuilder stringBuilder) { StringBuilder keyBuffer = new StringBuilder(); Node payload = (Node) n.payload; compileNode(payload, keyBuffer); String key = keyBuffer.toString(); String value = lookupKey(key); if (value != null) { stringBuilder.append(value); return; } if (n.defaultPart == null) { stringBuilder.append(key + CoreConstants.UNDEFINED_PROPERTY_SUFFIX); return; } Node defaultPart = (Node) n.defaultPart; StringBuilder defaultPartBuffer = new StringBuilder(); compileNode(defaultPart, defaultPartBuffer); String defaultVal = defaultPartBuffer.toString(); stringBuilder.append(defaultVal); }
/** * Determine if a node has already been visited already by checking the cycleDetectionStack * for it's existence. This method is used -- rather than Stack.contains() -- because * we want to ignore the Node's 'next' attribute when comparing for equality. */ private boolean haveVisitedNodeAlready(Node node, Stack<Node> cycleDetectionStack) { for (Node cycleNode : cycleDetectionStack) { if (equalNodes(node, cycleNode)) { return true; } } return false; } private boolean equalNodes(Node node1, Node node2) {
public static String substituteVariable(String input, PropertyContainer pc0, PropertyContainer pc1) throws ScanException { Tokenizer tokenizer = new Tokenizer(input); Parser parser = new Parser(tokenizer.tokenize()); Node node = parser.parse(); NodeToStringTransformer nodeToStringTransformer = new NodeToStringTransformer(node, pc0, pc1); return nodeToStringTransformer.transform(); }
/** * See http://logback.qos.ch/manual/configuration.html#variableSubstitution */ public static String substVars(String input, PropertyContainer pc0, PropertyContainer pc1) { try { return NodeToStringTransformer.substituteVariable(input, pc0, pc1); } catch (ScanException e) { throw new IllegalArgumentException("Failed to parse input [" + input + "]", e); } }
public String transform() { StringBuilder stringBuilder = new StringBuilder(); compileNode(node, stringBuilder); return stringBuilder.toString(); }
private void handleVariable(Node n, StringBuilder stringBuilder) { StringBuilder keyBuffer = new StringBuilder(); Node payload = (Node) n.payload; compileNode(payload, keyBuffer); String key = keyBuffer.toString(); String value = lookupKey(key); if (value != null) { stringBuilder.append(value); return; } if (n.defaultPart == null) { stringBuilder.append(key + CoreConstants.UNDEFINED_PROPERTY_SUFFIX); return; } Node defaultPart = (Node) n.defaultPart; StringBuilder defaultPartBuffer = new StringBuilder(); compileNode(defaultPart, defaultPartBuffer); String defaultVal = defaultPartBuffer.toString(); stringBuilder.append(defaultVal); }
/** * Determine if a node has already been visited already by checking the cycleDetectionStack * for it's existence. This method is used -- rather than Stack.contains() -- because * we want to ignore the Node's 'next' attribute when comparing for equality. */ private boolean haveVisitedNodeAlready(Node node, Stack<Node> cycleDetectionStack) { for (Node cycleNode : cycleDetectionStack) { if (equalNodes(node, cycleNode)) { return true; } } return false; }
private void handleVariable(Node n, StringBuilder stringBuilder, Stack<Node> cycleCheckStack) throws ScanException { if (haveVisitedNodeAlready(n, cycleCheckStack)) { cycleCheckStack.push(n); String error = constructRecursionErrorMessage(cycleCheckStack); throw new IllegalArgumentException(error); compileNode(payload, keyBuffer, cycleCheckStack); String key = keyBuffer.toString(); String value = lookupKey(key); Node innerNode = tokenizeAndParseString(value); compileNode(innerNode, stringBuilder, cycleCheckStack); cycleCheckStack.pop(); return; compileNode(defaultPart, defaultPartBuffer, cycleCheckStack); cycleCheckStack.pop(); String defaultVal = defaultPartBuffer.toString();
void checkInputEqualsOutput(String input) throws ScanException { Node node = makeNode(input); NodeToStringTransformer nodeToStringTransformer = new NodeToStringTransformer(node, propertyContainer0); assertEquals(input, nodeToStringTransformer.transform()); }
public static String substituteVariable(String input, PropertyContainer pc0, PropertyContainer pc1) throws ScanException { Node node = tokenizeAndParseString(input); NodeToStringTransformer nodeToStringTransformer = new NodeToStringTransformer(node, pc0, pc1); return nodeToStringTransformer.transform(); }
private void compileNode(Node inputNode, StringBuilder stringBuilder, Stack<Node> cycleCheckStack) throws ScanException { Node n = inputNode; while (n != null) { switch (n.type) { case LITERAL: handleLiteral(n, stringBuilder); break; case VARIABLE: handleVariable(n, stringBuilder, cycleCheckStack); break; } n = n.next; } }
/** * See http://logback.qos.ch/manual/configuration.html#variableSubstitution */ public static String substVars(String input, PropertyContainer pc0, PropertyContainer pc1) { try { return NodeToStringTransformer.substituteVariable(input, pc0, pc1); } catch (ScanException e) { throw new IllegalArgumentException("Failed to parse input [" + input + "]", e); } }
public String transform() { StringBuilder stringBuilder = new StringBuilder(); compileNode(node, stringBuilder); return stringBuilder.toString(); }
/** * Determine if a node has already been visited already by checking the cycleDetectionStack * for it's existence. This method is used -- rather than Stack.contains() -- because * we want to ignore the Node's 'next' attribute when comparing for equality. */ private boolean haveVisitedNodeAlready(Node node, Stack<Node> cycleDetectionStack) { for (Node cycleNode : cycleDetectionStack) { if (equalNodes(node, cycleNode)) { return true; } } return false; }