      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:
    124: