source: branches/comu-ver2/data/module/log4php/php5/log4php/helpers/LoggerPatternConverter.php @ 18220

Revision 18220, 12.9 KB checked in by yokkuns, 11 years ago (diff)

#149 ロガークラス作成

Line 
1<?php
2/**
3 * Licensed to the Apache Software Foundation (ASF) under one or more
4 * contributor license agreements.  See the NOTICE file distributed with
5 * this work for additional information regarding copyright ownership.
6 * The ASF licenses this file to You under the Apache License, Version 2.0
7 * (the "License"); you may not use this file except in compliance with
8 * the License.  You may obtain a copy of the License at
9 *
10 *     http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 *
19 * @package log4php
20 * @subpackage helpers
21 */
22
23/**
24 * @ignore
25 */
26if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__) . '/..');
27
28/**
29 */
30require_once(LOG4PHP_DIR . '/LoggerLog.php');
31
32/**
33 * Array for fast space padding
34 * Used by {@link LoggerPatternConverter::spacePad()}. 
35 */
36$GLOBALS['log4php.LoggerPatternConverter.spaces'] = array(" ", "  ", "    ", "        ", //1,2,4,8 spaces
37                            "                ", // 16 spaces
38                            "                                " ); // 32 spaces
39
40/**
41 * LoggerPatternConverter is an abstract class that provides the formatting
42 * functionality that derived classes need.
43 *
44 * <p>Conversion specifiers in a conversion patterns are parsed to
45 * individual PatternConverters. Each of which is responsible for
46 * converting a logging event in a converter specific manner.</p>
47 *
48 * @author  Marco Vassura
49 * @version $Revision: 635069 $
50 * @package log4php
51 * @subpackage helpers
52 * @abstract
53 * @since 0.3
54 */
55class LoggerPatternConverter {
56
57    /**
58     * @var LoggerPatternConverter next converter in converter chain
59     */
60    var $next = null;
61   
62    var $min = -1;
63    var $max = 0x7FFFFFFF;
64    var $leftAlign = false;
65
66    /**
67     * Constructor
68     *
69     * @param LoggerFormattingInfo $fi
70     */
71    function LoggerPatternConverter($fi = null)
72    { 
73        if ($fi !== null) {
74            $this->min = $fi->min;
75            $this->max = $fi->max;
76            $this->leftAlign = $fi->leftAlign;
77        }
78    }
79 
80    /**
81     * Derived pattern converters must override this method in order to
82     * convert conversion specifiers in the correct way.
83     *
84     * @param LoggerLoggingEvent $event
85     */
86    function convert($event) {}
87
88    /**
89     * A template method for formatting in a converter specific way.
90     *
91     * @param string &$sbuf string buffer
92     * @param LoggerLoggingEvent $e
93     */
94    function format(&$sbuf, $e)
95    {
96        LoggerLog::debug("LoggerPatternConverter::format() sbuf='$sbuf'");   
97   
98        $s = $this->convert($e);
99       
100        LoggerLog::debug("LoggerPatternConverter::format() converted event is '$s'");   
101       
102   
103        if($s == null or empty($s)) {
104            if(0 < $this->min)
105                $this->spacePad($sbuf, $this->min);
106            return;
107        }
108       
109        $len = strlen($s);
110   
111        if($len > $this->max) {
112            $sbuf .= substr($s , 0, ($len - $this->max));
113        } elseif($len < $this->min) {
114            if($this->leftAlign) {     
115                $sbuf .= $s;
116                $this->spacePad($sbuf, ($this->min - $len));
117            } else {
118                $this->spacePad($sbuf, ($this->min - $len));
119                $sbuf .= $s;
120            }
121        } else {
122            $sbuf .= $s;
123        }
124    }   
125
126
127    /**
128     * Fast space padding method.
129     *
130     * @param string    &$sbuf     string buffer
131     * @param integer   $length    pad length
132     *
133     * @todo reimplement using PHP string functions
134     */
135    function spacePad(&$sbuf, $length)
136    {
137        LoggerLog::debug("LoggerPatternConverter::spacePad() sbuf='$sbuf' len='$length'");       
138   
139        while($length >= 32) {
140          $sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][5];
141          $length -= 32;
142        }
143       
144        for($i = 4; $i >= 0; $i--) {   
145            if(($length & (1<<$i)) != 0) {
146                $sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][$i];
147            }
148        }
149
150        // $sbuf = str_pad($sbuf, $length);
151    }
152}
153
154// ---------------------------------------------------------------------
155//                      PatternConverters
156// ---------------------------------------------------------------------
157
158/**
159 * @author  Marco Vassura
160 * @package log4php
161 * @subpackage helpers
162 */
163class LoggerBasicPatternConverter extends LoggerPatternConverter {
164
165    /**
166     * @var integer
167     */
168    var $type;
169
170    /**
171     * Constructor
172     *
173     * @param string $formattingInfo
174     * @param integer $type
175     */
176    function LoggerBasicPatternConverter($formattingInfo, $type)
177    {
178      LoggerLog::debug("LoggerBasicPatternConverter::LoggerBasicPatternConverter() type='$type'");   
179   
180      $this->LoggerPatternConverter($formattingInfo);
181      $this->type = $type;
182    }
183
184    /**
185     * @param LoggerLoggingEvent $event
186     * @return string
187     */
188    function convert($event)
189    {
190        switch($this->type) {
191            case LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER:
192                $timeStamp = $event->getTimeStamp();
193                $startTime = LoggerLoggingEvent::getStartTime();
194                    return (string)(int)($timeStamp * 1000 - $startTime * 1000);
195               
196            case LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER:
197                    return $event->getThreadName();
198
199            case LOG4PHP_LOGGER_PATTERN_PARSER_LEVEL_CONVERTER:
200                $level = $event->getLevel();
201                    return $level->toString();
202
203            case LOG4PHP_LOGGER_PATTERN_PARSER_NDC_CONVERTER:
204                    return $event->getNDC();
205
206            case LOG4PHP_LOGGER_PATTERN_PARSER_MESSAGE_CONVERTER:
207                    return $event->getRenderedMessage();
208               
209            default:
210                return '';
211        }
212    }
213}
214
215/**
216 * @author  Marco Vassura
217 * @package log4php
218 * @subpackage helpers
219 */
220class LoggerLiteralPatternConverter extends LoggerPatternConverter {
221   
222    /**
223     * @var string
224     */
225    var $literal;
226
227    /**
228     * Constructor
229     *
230     * @param string $value
231     */
232    function LoggerLiteralPatternConverter($value)
233    {
234        LoggerLog::debug("LoggerLiteralPatternConverter::LoggerLiteralPatternConverter() value='$value'");   
235   
236        $this->literal = $value;
237    }
238
239    /**
240     * @param string &$sbuf
241     * @param LoggerLoggingEvent $event
242     */
243    function format(&$sbuf, $event)
244    {
245        $sbuf .= $this->literal;
246    }
247
248    /**
249     * @param LoggerLoggingEvent $event
250     * @return string
251     */
252    function convert($event)
253    {
254      return $this->literal;
255    }
256}
257
258/**
259 * @author  Marco Vassura
260 * @package log4php
261 * @subpackage helpers
262 */
263class LoggerDatePatternConverter extends LoggerPatternConverter {
264
265    /**
266     * @var string
267     */
268    var $df;
269   
270    /**
271     * Constructor
272     *
273     * @param string $formattingInfo
274     * @param string $df
275     */
276    function LoggerDatePatternConverter($formattingInfo, $df)
277    {
278        LoggerLog::debug("LoggerDatePatternConverter::LoggerDatePatternConverter() dateFormat='$df'");   
279   
280        $this->LoggerPatternConverter($formattingInfo);
281        $this->df = $df;
282    }
283
284    /**
285     * @param LoggerLoggingEvent $event
286     * @return string
287     */
288    function convert($event)
289    {
290        $timeStamp = $event->getTimeStamp();
291        $usecs = round(($timeStamp - (int)$timeStamp) * 1000);
292        $this->df = preg_replace('/((?<!\\\\)(?:\\\\{2})*)u/', '${1}' . sprintf('%03d', $usecs), $this->df);
293         
294        return date($this->df, $event->getTimeStamp());
295       
296    }
297}
298
299/**
300 * @author  Marco Vassura
301 * @package log4php
302 * @subpackage helpers
303 */
304class LoggerMDCPatternConverter extends LoggerPatternConverter {
305
306    /**
307     * @var string
308     */
309    var $key;
310
311    /**
312     * Constructor
313     *
314     * @param string $formattingInfo
315     * @param string $key
316     */
317    function LoggerMDCPatternConverter($formattingInfo, $key)
318    {
319      LoggerLog::debug("LoggerMDCPatternConverter::LoggerMDCPatternConverter() key='$key'");   
320
321      $this->LoggerPatternConverter($formattingInfo);
322      $this->key = $key;
323    }
324
325    /**
326     * @param LoggerLoggingEvent $event
327     * @return string
328     */
329    function convert($event)
330    {
331        return $event->getMDC($this->key);
332    }
333}
334
335/**
336 * @author  Marco Vassura
337 * @package log4php
338 * @subpackage helpers
339 */
340class LoggerLocationPatternConverter extends LoggerPatternConverter {
341   
342    /**
343     * @var integer
344     */
345    var $type;
346
347    /**
348     * Constructor
349     *
350     * @param string $formattingInfo
351     * @param integer $type
352     */
353    function LoggerLocationPatternConverter($formattingInfo, $type)
354    {
355      LoggerLog::debug("LoggerLocationPatternConverter::LoggerLocationPatternConverter() type='$type'");   
356   
357      $this->LoggerPatternConverter($formattingInfo);
358      $this->type = $type;
359    }
360
361    /**
362     * @param LoggerLoggingEvent $event
363     * @return string
364     */
365    function convert($event)
366    {
367        $locationInfo = $event->getLocationInformation();
368        switch($this->type) {
369            case LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER:
370                    return $locationInfo->getFullInfo();
371            case LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER:
372                    return $locationInfo->getMethodName();
373            case LOG4PHP_LOGGER_PATTERN_PARSER_LINE_LOCATION_CONVERTER:
374                    return $locationInfo->getLineNumber();
375            case LOG4PHP_LOGGER_PATTERN_PARSER_FILE_LOCATION_CONVERTER:
376                    return $locationInfo->getFileName();
377            default:
378                return '';
379        }
380    }
381}
382
383/**
384 * @author  Marco Vassura
385 * @package log4php
386 * @subpackage helpers
387 * @abstract
388 */
389class LoggerNamedPatternConverter extends LoggerPatternConverter {
390
391    /**
392     * @var integer
393     */
394    var $precision;
395
396    /**
397     * Constructor
398     *
399     * @param string $formattingInfo
400     * @param integer $precision
401     */
402    function LoggerNamedPatternConverter($formattingInfo, $precision)
403    {
404      LoggerLog::debug("LoggerNamedPatternConverter::LoggerNamedPatternConverter() precision='$precision'");   
405   
406      $this->LoggerPatternConverter($formattingInfo);
407      $this->precision =  $precision;
408    }
409
410    /**
411     * @param LoggerLoggingEvent $event
412     * @return string
413     * @abstract
414     */
415    function getFullyQualifiedName($event)
416    {
417        // abstract
418        return;
419    }
420
421    /**
422     * @param LoggerLoggingEvent $event
423     * @return string
424     */
425    function convert($event)
426    {
427        $n = $this->getFullyQualifiedName($event);
428        if ($this->precision <= 0) {
429                return $n;
430        } else {
431                $len = strlen($n);
432           
433                // We substract 1 from 'len' when assigning to 'end' to avoid out of
434                // bounds exception in return r.substring(end+1, len). This can happen if
435                // precision is 1 and the category name ends with a dot.
436                $end = $len -1 ;
437                for($i = $this->precision; $i > 0; $i--) {
438                    $end = strrpos(substr($n, 0, ($end - 1)), '.');
439                    if ($end == false)
440                        return $n;
441                }
442                return substr($n, ($end + 1), $len);
443        }
444    }
445}
446
447/**
448 * @author  Marco Vassura
449 * @package log4php
450 * @subpackage helpers
451 */
452class LoggerClassNamePatternConverter extends LoggerNamedPatternConverter {
453
454    /**
455     * Constructor
456     *
457     * @param string $formattingInfo
458     * @param integer $precision
459     */
460    function LoggerClassNamePatternConverter($formattingInfo, $precision)
461    {
462        LoggerLog::debug("LoggerClassNamePatternConverter::LoggerClassNamePatternConverter() precision='$precision'");   
463   
464        $this->LoggerNamedPatternConverter($formattingInfo, $precision);
465    }
466
467    /**
468     * @param LoggerLoggingEvent $event
469     * @return string
470     */
471    function getFullyQualifiedName($event)
472    {
473        return $event->fqcn;
474    }
475}
476
477/**
478 * @author  Marco Vassura
479 * @package log4php
480 * @subpackage helpers
481 */
482class LoggerCategoryPatternConverter extends LoggerNamedPatternConverter {
483
484    /**
485     * Constructor
486     *
487     * @param string $formattingInfo
488     * @param integer $precision
489     */
490    function LoggerCategoryPatternConverter($formattingInfo, $precision)
491    {
492        LoggerLog::debug("LoggerCategoryPatternConverter::LoggerCategoryPatternConverter() precision='$precision'");   
493   
494        $this->LoggerNamedPatternConverter($formattingInfo, $precision);
495    }
496
497    /**
498     * @param LoggerLoggingEvent $event
499     * @return string
500     */
501    function getFullyQualifiedName($event)
502    {
503      return $event->getLoggerName();
504    }
505}
506
Note: See TracBrowser for help on using the repository browser.