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

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

#149 ロガークラス作成

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