    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *     http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017
    018    package org.apache.logging.log4j.io;
    019
    020    import java.io.PrintWriter;
    021    import java.io.Writer;
    022    import java.util.Locale;
    023
    024    import org.apache.logging.log4j.Level;
    025    import org.apache.logging.log4j.Marker;
    026    import org.apache.logging.log4j.spi.ExtendedLogger;
    027
    028    /**
    029     * Logs each line written to a pre-defined level. Can also be configured with a Marker. This class provides an interface
    030     * that follows the {@link java.io.PrintWriter} methods in spirit, but doesn't require output to any external writer.
    031     * <p>
    032     * Integration with JDBC logging can be as simple as:
    033     * </p>
    034     * <pre>
    035     *     PrintWriter pw = IoBuilder.forLogger().setLevel(Level.DEBUG).buildPrintWriter();
    036     *     DriverManager.setLogWriter(pw);
    037     *     DataSource ds = ...
    038     *     ds.setLogWriter(pw);
    039     * </pre>
    040     *
    041     * @since 2.1
    042     */
    043    // TODO
    044    // All method implementations that call only super are apparently required for the unit tests to pass.
    045    // Not sure if this a bug in the tests or a feature.
    046    public class LoggerPrintWriter extends PrintWriter {
    047        private static final String FQCN = LoggerPrintWriter.class.getName();
    048
    049        protected LoggerPrintWriter(final ExtendedLogger logger, final boolean autoFlush, final String fqcn,
    050                                    final Level level, final Marker marker) {
    051            super(new LoggerWriter(logger, fqcn == null ? FQCN : fqcn, level, marker), autoFlush);
    052        }
    053
    054        protected LoggerPrintWriter(final Writer writer, final boolean autoFlush, final ExtendedLogger logger,
    055                                    final String fqcn, final Level level, final Marker marker) {
    056            super(new LoggerFilterWriter(writer, logger, fqcn == null ? FQCN : fqcn, level, marker), autoFlush);
    057        }
    058
    059        @Override
    060        public LoggerPrintWriter append(final char c) {
    061            super.append(c);
    062            return this;
    063        }
    064
    065        @Override
    066        public LoggerPrintWriter append(final CharSequence csq) {
    067            super.append(csq);
    068            return this;
    069        }
    070
    071        @Override
    072        public LoggerPrintWriter append(final CharSequence csq, final int start, final int end) {
    073            super.append(csq, start, end);
    074            return this;
    075        }
    076
    077        @Override
    078        public boolean checkError() {
    079            return super.checkError();
    080        }
    081
    082        @Override
    083        public void close() {
    084            super.close();
    085        }
    086
    087        @Override
    088        public void flush() {
    089            super.flush();
    090        }
    091
    092        @Override
    093        public LoggerPrintWriter format(final Locale l, final String format, final Object... args) {
    094            super.format(l, format, args);
    095            return this;
    096        }
    097
    098        @Override
    099        public LoggerPrintWriter format(final String format, final Object... args) {
    100            super.format(format, args);
    101            return this;
    102        }
    103
    104        @Override
    105        public void print(final boolean b) {
    106            super.print(b);
    107        }
    108
    109        @Override
    110        public void print(final char c) {
    111            super.print(c);
    112        }
    113
    114        @Override
    115        public void print(final char[] s) {
    116            super.print(s);
    117        }
    118
    119        @Override
    120        public void print(final double d) {
    121            super.print(d);
    122        }
    123
    124        @Override
    125        public void print(final float f) {
    126            super.print(f);
    127        }
    128
    129        @Override
    130        public void print(final int i) {
    131            super.print(i);
    132        }
    133
    134        @Override
    135        public void print(final long l) {
    136            super.print(l);
    137        }
    138
    139        @Override
    140        public void print(final Object obj) {
    141            super.print(obj);
    142        }
    143
    144        @Override
    145        public void print(final String s) {
    146            super.print(s);
    147        }
    148
    149        @Override
    150        public LoggerPrintWriter printf(final Locale l, final String format, final Object... args) {
    151            super.printf(l, format, args);
    152            return this;
    153        }
    154
    155        @Override
    156        public LoggerPrintWriter printf(final String format, final Object... args) {
    157            super.printf(format, args);
    158            return this;
    159        }
    160
    161        @Override
    162        public void println() {
    163            super.println();
    164        }
    165
    166        @Override
    167        public void println(final boolean x) {
    168            super.println(x);
    169        }
    170
    171        @Override
    172        public void println(final char x) {
    173            super.println(x);
    174        }
    175
    176        @Override
    177        public void println(final char[] x) {
    178            super.println(x);
    179        }
    180
    181        @Override
    182        public void println(final double x) {
    183            super.println(x);
    184        }
    185
    186        @Override
    187        public void println(final float x) {
    188            super.println(x);
    189        }
    190
    191        @Override
    192        public void println(final int x) {
    193            super.println(x);
    194        }
    195
    196        @Override
    197        public void println(final long x) {
    198            super.println(x);
    199        }
    200
    201        @Override
    202        public void println(final Object x) {
    203            super.println(x);
    204        }
    205
    206        @Override
    207        public void println(final String x) {
    208            super.println(x);
    209        }
    210
    211        @Override
    212        public String toString() {
    213            return LoggerPrintWriter.class.getSimpleName() + "{stream=" + this.out + '}';
    214        }
    215
    216        @Override
    217        public void write(final char[] buf) {
    218            super.write(buf);
    219        }
    220
    221        @Override
    222        public void write(final char[] buf, final int off, final int len) {
    223            super.write(buf, off, len);
    224        }
    225
    226        @Override
    227        public void write(final int c) {
    228            super.write(c);
    229        }
    230
    231        @Override
    232        public void write(final String s) {
    233            super.write(s);
    234        }
    235
    236        @Override
    237        public void write(final String s, final int off, final int len) {
    238            super.write(s, off, len);
    239        }
    240    }