srcjar/org/apache/log4j/pattern/BridgePatternConverter.java

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * the License.  You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.apache.log4j.pattern;
  19
  20 import org.apache.log4j.spi.LoggingEvent;
  21
  22 import java.util.ArrayList;
  23 import java.util.Iterator;
  24 import java.util.List;
  25 import java.util.Map;
  26
  27
  28 /**
  29  * The class implements the pre log4j 1.3 org.apache.log4j.helpers.PatternConverter
  30  * contract by delegating to the log4j 1.3 pattern implementation.
  31  *
  32  *
  33  * @author Curt Arnold
  34  *
  35  */
  36 public final class BridgePatternConverter
  37   extends org.apache.log4j.helpers.PatternConverter {
  38   /**
  39    * Pattern converters.
  40    */
  41   private LoggingEventPatternConverter[] patternConverters;
  42
  43   /**
  44    * Field widths and alignment corresponding to pattern converters.
  45    */
  46   private FormattingInfo[] patternFields;
  47
  48   /**
  49    * Does pattern process exceptions.
  50    */
  51   private boolean handlesExceptions;
  52
  53   /**
  54    * Create a new instance.
  55    * @param pattern pattern, may not be null.
  56    */
  57   public BridgePatternConverter(
  58     final String pattern) {
  59     next = null;
  60     handlesExceptions = false;
  61
  62     List converters = new ArrayList();
  63     List fields = new ArrayList();
  64     Map converterRegistry = null;
  65
  66     PatternParser.parse(
  67       pattern, converters, fields, converterRegistry,
  68       PatternParser.getPatternLayoutRules());
  69
  70     patternConverters = new LoggingEventPatternConverter[converters.size()];
  71     patternFields = new FormattingInfo[converters.size()];
  72
  73     int i = 0;
  74     Iterator converterIter = converters.iterator();
  75     Iterator fieldIter = fields.iterator();
  76
  77     while (converterIter.hasNext()) {
  78       Object converter = converterIter.next();
  79
  80       if (converter instanceof LoggingEventPatternConverter) {
  81         patternConverters[i] = (LoggingEventPatternConverter) converter;
  82         handlesExceptions |= patternConverters[i].handlesThrowable();
  83       } else {
  84         patternConverters[i] =
  85           new org.apache.log4j.pattern.LiteralPatternConverter("");
  86       }
  87
  88       if (fieldIter.hasNext()) {
  89         patternFields[i] = (FormattingInfo) fieldIter.next();
  90       } else {
  91         patternFields[i] = FormattingInfo.getDefault();
  92       }
  93
  94       i++;
  95     }
  96   }
  97
  98   /**
  99    * {@inheritDoc}
 100    */
 101   protected String convert(final LoggingEvent event) {
 102     //
 103     //  code should be unreachable.
 104     //
 105     StringBuffer sbuf = new StringBuffer();
 106     format(sbuf, event);
 107
 108     return sbuf.toString();
 109   }
 110
 111   /**
 112      Format event to string buffer.
 113      @param sbuf string buffer to receive formatted event, may not be null.
 114      @param e event to format, may not be null.
 115    */
 116   public void format(final StringBuffer sbuf, final LoggingEvent e) {
 117     for (int i = 0; i < patternConverters.length; i++) {
 118       int startField = sbuf.length();
 119       patternConverters[i].format(e, sbuf);
 120       patternFields[i].format(startField, sbuf);
 121     }
 122   }
 123
 124   /**
 125    * Will return false if any of the conversion specifiers in the pattern
 126    * handles {@link Exception Exceptions}.
 127    * @return true if the pattern formats any information from exceptions.
 128    */
 129   public boolean ignoresThrowable() {
 130     return !handlesExceptions;
 131   }
 132 }