Class ParameterFormatter

java.lang.Object
org.apache.logging.log4j.message.ParameterFormatter

final class ParameterFormatter extends Object
Supports parameter formatting as used in ParameterizedMessage and ReusableParameterizedMessage.
  • Field Details

  • Constructor Details

    • ParameterFormatter

      private ParameterFormatter()
  • Method Details

    • countArgumentPlaceholders

      static int countArgumentPlaceholders(String messagePattern)
      Counts the number of unescaped placeholders in the given messagePattern.
      Parameters:
      messagePattern - the message pattern to be analyzed.
      Returns:
      the number of unescaped placeholders.
    • countArgumentPlaceholders2

      static int countArgumentPlaceholders2(String messagePattern, int[] indices)
      Counts the number of unescaped placeholders in the given messagePattern.
      Parameters:
      messagePattern - the message pattern to be analyzed.
      Returns:
      the number of unescaped placeholders.
    • countArgumentPlaceholders3

      static int countArgumentPlaceholders3(char[] messagePattern, int length, int[] indices)
      Counts the number of unescaped placeholders in the given messagePattern.
      Parameters:
      messagePattern - the message pattern to be analyzed.
      Returns:
      the number of unescaped placeholders.
    • format

      static String format(String messagePattern, Object[] arguments)
      Replace placeholders in the given messagePattern with arguments.
      Parameters:
      messagePattern - the message pattern containing placeholders.
      arguments - the arguments to be used to replace placeholders.
      Returns:
      the formatted message.
    • formatMessage2

      static void formatMessage2(StringBuilder buffer, String messagePattern, Object[] arguments, int argCount, int[] indices)
      Replace placeholders in the given messagePattern with arguments.
      Parameters:
      buffer - the buffer to write the formatted message into
      messagePattern - the message pattern containing placeholders.
      arguments - the arguments to be used to replace placeholders.
    • formatMessage3

      static void formatMessage3(StringBuilder buffer, char[] messagePattern, int patternLength, Object[] arguments, int argCount, int[] indices)
      Replace placeholders in the given messagePattern with arguments.
      Parameters:
      buffer - the buffer to write the formatted message into
      messagePattern - the message pattern containing placeholders.
      arguments - the arguments to be used to replace placeholders.
    • formatMessage

      static void formatMessage(StringBuilder buffer, String messagePattern, Object[] arguments, int argCount)
      Replace placeholders in the given messagePattern with arguments.
      Parameters:
      buffer - the buffer to write the formatted message into
      messagePattern - the message pattern containing placeholders.
      arguments - the arguments to be used to replace placeholders.
    • isDelimPair

      private static boolean isDelimPair(char curChar, String messagePattern, int curCharIndex)
      Returns true if the specified char and the char at curCharIndex + 1 in the specified message pattern together form a "{}" delimiter pair, returns false otherwise.
    • handleRemainingCharIfAny

      private static void handleRemainingCharIfAny(String messagePattern, int len, StringBuilder buffer, int escapeCounter, int i)
      Detects whether the message pattern has been fully processed or if an unprocessed character remains and processes it if necessary, returning the resulting position in the result char array.
    • handleLastChar

      private static void handleLastChar(StringBuilder buffer, int escapeCounter, char curChar)
      Processes the last unprocessed character and returns the resulting position in the result char array.
    • handleLiteralChar

      private static void handleLiteralChar(StringBuilder buffer, int escapeCounter, char curChar)
      Processes a literal char (neither an '\' escape char nor a "{}" delimiter pair) and returns the resulting position.
    • writeDelimPair

      private static void writeDelimPair(StringBuilder buffer)
      Writes "{}" to the specified result array at the specified position and returns the resulting position.
    • isOdd

      private static boolean isOdd(int number)
      Returns true if the specified parameter is odd.
    • writeEscapedEscapeChars

      private static void writeEscapedEscapeChars(int escapeCounter, StringBuilder buffer)
      Writes a '\' char to the specified result array (starting at the specified position) for each pair of '\' escape chars encountered in the message format and returns the resulting position.
    • writeUnescapedEscapeChars

      private static void writeUnescapedEscapeChars(int escapeCounter, StringBuilder buffer)
      Writes the specified number of '\' chars to the specified result array (starting at the specified position) and returns the resulting position.
    • writeArgOrDelimPair

      private static void writeArgOrDelimPair(Object[] arguments, int argCount, int currentArgument, StringBuilder buffer)
      Appends the argument at the specified argument index (or, if no such argument exists, the "{}" delimiter pair) to the specified result char array at the specified position and returns the resulting position.
    • deepToString

      static String deepToString(Object o)
      This method performs a deep toString of the given Object. Primitive arrays are converted using their respective Arrays.toString methods while special handling is implemented for "container types", i.e. Object[], Map and Collection because those could contain themselves.

      It should be noted that neither AbstractMap.toString() nor AbstractCollection.toString() implement such a behavior. They only check if the container is directly contained in itself, but not if a contained container contains the original one. Because of that, Arrays.toString(Object[]) isn't safe either. Confusing? Just read the last paragraph again and check the respective toString() implementation.

      This means, in effect, that logging would produce a usable output even if an ordinary System.out.println(o) would produce a relatively hard-to-debug StackOverflowError.

      Parameters:
      o - The object.
      Returns:
      The String representation.
    • recursiveDeepToString

      static void recursiveDeepToString(Object o, StringBuilder str)
      This method performs a deep toString() of the given Object.

      Primitive arrays are converted using their respective Arrays.toString() methods, while special handling is implemented for container types, i.e. Object[], Map and Collection, because those could contain themselves.

      It should be noted that neither AbstractMap.toString() nor AbstractCollection.toString() implement such a behavior. They only check if the container is directly contained in itself, but not if a contained container contains the original one. Because of that, Arrays.toString(Object[]) isn't safe either. Confusing? Just read the last paragraph again and check the respective toString() implementation.

      This means, in effect, that logging would produce a usable output even if an ordinary System.out.println(o) would produce a relatively hard-to-debug StackOverflowError.

      Parameters:
      o - the Object to convert into a String
      str - the StringBuilder that o will be appended to
    • recursiveDeepToString

      private static void recursiveDeepToString(Object o, StringBuilder str, Set<Object> dejaVu)
      This method performs a deep toString() of the given Object.

      Primitive arrays are converted using their respective Arrays.toString() methods, while special handling is implemented for container types, i.e. Object[], Map and Collection, because those could contain themselves.

      dejaVu is used in case of those container types to prevent an endless recursion.

      It should be noted that neither AbstractMap.toString() nor AbstractCollection.toString() implement such a behavior. They only check if the container is directly contained in itself, but not if a contained container contains the original one. Because of that, Arrays.toString(Object[]) isn't safe either. Confusing? Just read the last paragraph again and check the respective toString() implementation.

      This means, in effect, that logging would produce a usable output even if an ordinary System.out.println(o) would produce a relatively hard-to-debug StackOverflowError.

      Parameters:
      o - the Object to convert into a String
      str - the StringBuilder that o will be appended to
      dejaVu - a set of container objects directly or transitively containing o
    • appendSpecialTypes

      private static boolean appendSpecialTypes(Object o, StringBuilder str)
    • appendDate

      private static boolean appendDate(Object o, StringBuilder str)
    • isMaybeRecursive

      private static boolean isMaybeRecursive(Object o)
      Returns true if the specified object is an array, a Map or a Collection.
    • appendPotentiallyRecursiveValue

      private static void appendPotentiallyRecursiveValue(Object o, StringBuilder str, Set<Object> dejaVu)
    • appendArray

      private static void appendArray(Object o, StringBuilder str, Set<Object> dejaVu, Class<?> oClass)
    • appendMap

      private static void appendMap(Object o, StringBuilder str, Set<Object> dejaVu)
      Specialized handler for Maps.
    • appendCollection

      private static void appendCollection(Object o, StringBuilder str, Set<Object> dejaVu)
      Specialized handler for Collections.
    • getOrCreateDejaVu

      private static Set<Object> getOrCreateDejaVu(Set<Object> dejaVu)
    • createDejaVu

      private static Set<Object> createDejaVu()
    • cloneDejaVu

      private static Set<Object> cloneDejaVu(Set<Object> dejaVu)
    • tryObjectToString

      private static void tryObjectToString(Object o, StringBuilder str)
    • handleErrorInObjectToString

      private static void handleErrorInObjectToString(Object o, StringBuilder str, Throwable t)
    • identityToString

      static String identityToString(Object obj)
      This method returns the same as if Object.toString() would not have been overridden in obj.

      Note that this isn't 100% secure as collisions can always happen with hash codes.

      Copied from Object.hashCode():

      As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java™ programming language.)
      Parameters:
      obj - the Object that is to be converted into an identity string.
      Returns:
      the identity string as also defined in Object.toString()