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  * @package log4php

    19  */

    20 

    21 /**

    22  * Contains various helper methods.

    23  *

    24  * @package log4php

    25  * @subpackage helpers

    26  * @since 2.3

    27  */

    28 class LoggerUtils {

    29 

    30     /**

    31      * Splits a fully qualified class name into fragments delimited by the

    32      * namespace separator (\).

    33      *

    34      * For backward compatibility, a dot (.) can be used as a delimiter as

    35      * well.

    36      *

    37      * @param string $name

    38      *

    39      * @return array Class name split into fragments.

    40      */

    41     public static function tokenizeClassName($name) {

    42         $name = str_replace('.', '\\', $name);

    43         $name = trim($name, ' \\');

    44         $fragments = explode('\\', $name);

    45 

    46         foreach ($fragments as $key => $fragment) {

    47             if (trim($fragment) === '') {

    48                 unset($fragments[$key]);

    49             }

    50         }

    51 

    52         return $fragments;

    53     }

    54 

    55     /**

    56      * Attempts to shorten the given class name to the desired length.

    57      *

    58      * This is done by separating the class name into fragments (delimited

    59      * by \ or .) and trimming individual fragments, starting with the left,

    60      * until desired length has been reached.

    61      *

    62      * The final fragment (i.e. class name) will never be shortened so the

    63      * result may still be longer than given length.

    64      *

    65      * @param string $name The (qualified) class name.

    66      * @param integer $length The length to shorten to. If null or 0 is given,

    67      * the name will be returned without shortening.

    68      */

    69     public static function shortenClassName($name, $length) {

    70         if ($length === null || $length < 0) {

    71             return $name;

    72         }

    73 

    74         $name = str_replace('.', '\\', $name);

    75         $name = trim($name, ' \\');

    76 

    77         // Check if any shortening is required

    78         $currentLength = strlen($name);

    79         if ($currentLength <= $length) {

    80             return $name;

    81         }

    82 

    83         // Split name into fragments

    84         $fragments = explode('\\', $name);

    85 

    86         // If zero length is specified, return only last fragment

    87         if ($length == 0) {

    88             return array_pop($fragments);

    89         }

    90 

    91         // If the name splits to only one fragment, then it cannot be shortened

    92         $count = count($fragments);

    93         if ($count == 1) {

    94             return $name;

    95         }

    96 

    97         foreach ($fragments as $key => &$fragment) {

    98 

    99             // Never shorten last fragment

   100             if ($key == $count - 1) {

   101                 break;

   102             }

   103 

   104             // Check for empty fragments (shouldn't happen but it's possible)

   105             $fragLen = strlen($fragment);

   106             if ($fragLen <= 1) {

   107                 continue;

   108             }

   109 

   110             // Shorten fragment to one character and check if total length satisfactory

   111             $fragment = substr($fragment, 0, 1);

   112             $currentLength = $currentLength - $fragLen + 1;

   113 

   114             if ($currentLength <= $length) {

   115                 break;

   116             }

   117         }

   118         unset($fragment);

   119 

   120         return implode('\\', $fragments);

   121     }

   122 }

   123