How to use

NodeToStringTransformer

in

ch.qos.logback.core.subst

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;
}