Defined (1)

The class is defined in the following location(s).

/wp-includes/Text/Diff.php  

class Text_Diff { 
 
    /** 
     * Array of changes. 
     * 
     * @var array 
     */ 
    var $_edits; 
 
    /** 
     * Computes diffs between sequences of strings. 
     * 
     * @param string $engine     Name of the diffing engine to use.  'auto' 
     *                           will automatically select the best. 
     * @param array $params      Parameters to pass to the diffing engine. 
     *                           Normally an array of two arrays, each 
     *                           containing the lines from a file. 
     */ 
    function __construct( $engine, $params ) 
    { 
        // Backward compatibility workaround. 
        if (!is_string($engine)) { 
            $params = array($engine, $params); 
            $engine = 'auto'; 
        } 
 
        if ($engine == 'auto') { 
            $engine = extension_loaded('xdiff') ? 'xdiff' : 'native'; 
        } else { 
            $engine = basename($engine); 
        } 
 
        // WP #7391 
        require_once dirname(__FILE__).'/Diff/Engine/' . $engine . '.php'; 
        $class = 'Text_Diff_Engine_' . $engine; 
        $diff_engine = new $class(); 
 
        $this->_edits = call_user_func_array(array($diff_engine, 'diff'), $params); 
    } 
 
    /** 
     * PHP4 constructor. 
     */ 
    public function Text_Diff( $engine, $params ) { 
        self::__construct( $engine, $params ); 
    } 
 
    /** 
     * Returns the array of differences. 
     */ 
    function getDiff() 
    { 
        return $this->_edits; 
    } 
 
    /** 
     * returns the number of new (added) lines in a given diff. 
     * 
     * @since Text_Diff 1.1.0 
     * 
     * @return integer The number of new lines 
     */ 
    function countAddedLines() 
    { 
        $count = 0; 
        foreach ($this->_edits as $edit) { 
            if (is_a($edit, 'Text_Diff_Op_add') || 
                is_a($edit, 'Text_Diff_Op_change')) { 
                $count += $edit->nfinal(); 
            } 
        } 
        return $count; 
    } 
 
    /** 
     * Returns the number of deleted (removed) lines in a given diff. 
     * 
     * @since Text_Diff 1.1.0 
     * 
     * @return integer The number of deleted lines 
     */ 
    function countDeletedLines() 
    { 
        $count = 0; 
        foreach ($this->_edits as $edit) { 
            if (is_a($edit, 'Text_Diff_Op_delete') || 
                is_a($edit, 'Text_Diff_Op_change')) { 
                $count += $edit->norig(); 
            } 
        } 
        return $count; 
    } 
 
    /** 
     * Computes a reversed diff. 
     * 
     * Example: 
     * <code> 
     * $diff = new Text_Diff($lines1, $lines2); 
     * $rev = $diff->reverse(); 
     * </code> 
     * 
     * @return Text_Diff  A Diff object representing the inverse of the 
     *                    original diff.  Note that we purposely don't return a 
     *                    reference here, since this essentially is a clone() 
     *                    method. 
     */ 
    function reverse() 
    { 
        if (version_compare(zend_version(), '2', '>')) { 
            $rev = clone($this); 
        } else { 
            $rev = $this; 
        } 
        $rev->_edits = array(); 
        foreach ($this->_edits as $edit) { 
            $rev->_edits[] = $edit->reverse(); 
        } 
        return $rev; 
    } 
 
    /** 
     * Checks for an empty diff. 
     * 
     * @return boolean  True if two sequences were identical. 
     */ 
    function isEmpty() 
    { 
        foreach ($this->_edits as $edit) { 
            if (!is_a($edit, 'Text_Diff_Op_copy')) { 
                return false; 
            } 
        } 
        return true; 
    } 
 
    /** 
     * Computes the length of the Longest Common Subsequence (LCS). 
     * 
     * This is mostly for diagnostic purposes. 
     * 
     * @return integer  The length of the LCS. 
     */ 
    function lcs() 
    { 
        $lcs = 0; 
        foreach ($this->_edits as $edit) { 
            if (is_a($edit, 'Text_Diff_Op_copy')) { 
                $lcs += count($edit->orig); 
            } 
        } 
        return $lcs; 
    } 
 
    /** 
     * Gets the original set of lines. 
     * 
     * This reconstructs the $from_lines parameter passed to the constructor. 
     * 
     * @return array  The original sequence of strings. 
     */ 
    function getOriginal() 
    { 
        $lines = array(); 
        foreach ($this->_edits as $edit) { 
            if ($edit->orig) { 
                array_splice($lines, count($lines), 0, $edit->orig); 
            } 
        } 
        return $lines; 
    } 
 
    /** 
     * Gets the final set of lines. 
     * 
     * This reconstructs the $to_lines parameter passed to the constructor. 
     * 
     * @return array  The sequence of strings. 
     */ 
    function getFinal() 
    { 
        $lines = array(); 
        foreach ($this->_edits as $edit) { 
            if ($edit->final) { 
                array_splice($lines, count($lines), 0, $edit->final); 
            } 
        } 
        return $lines; 
    } 
 
    /** 
     * Removes trailing newlines from a line of text. This is meant to be used 
     * with array_walk(). 
     * 
     * @param string $line  The line to trim. 
     * @param integer $key  The index of the line in the array. Not used. 
     */ 
    static function trimNewlines(&$line, $key) 
    { 
        $line = str_replace(array("\n", "\r"), '', $line); 
    } 
 
    /** 
     * Determines the location of the system temporary directory. 
     * 
     * @static 
     * 
     * @access protected 
     * 
     * @return string  A directory name which can be used for temp files. 
     *                 Returns false if one could not be found. 
     */ 
    function _getTempDir() 
    { 
        $tmp_locations = array('/tmp', '/var/tmp', 'c:\WUTemp', 'c:\temp',  
                               'c:\windows\temp', 'c:\winnt\temp'); 
 
        /** Try PHP's upload_tmp_dir directive. */ 
        $tmp = ini_get('upload_tmp_dir'); 
 
        /** Otherwise, try to determine the TMPDIR environment variable. */ 
        if (!strlen($tmp)) { 
            $tmp = getenv('TMPDIR'); 
        } 
 
        /** If we still cannot determine a value, then cycle through a list of 
         * preset possibilities. */ 
        while (!strlen($tmp) && count($tmp_locations)) { 
            $tmp_check = array_shift($tmp_locations); 
            if (@is_dir($tmp_check)) { 
                $tmp = $tmp_check; 
            } 
        } 
 
        /** If it is still empty, we have failed, so return false; otherwise 
         * return the directory determined. */ 
        return strlen($tmp) ? $tmp : false; 
    } 
 
    /** 
     * Checks a diff for validity. 
     * 
     * This is here only for debugging purposes. 
     */ 
    function _check($from_lines, $to_lines) 
    { 
        if (serialize($from_lines) != serialize($this->getOriginal())) { 
            trigger_error("Reconstructed original doesn't match", E_USER_ERROR); 
        } 
        if (serialize($to_lines) != serialize($this->getFinal())) { 
            trigger_error("Reconstructed final doesn't match", E_USER_ERROR); 
        } 
 
        $rev = $this->reverse(); 
        if (serialize($to_lines) != serialize($rev->getOriginal())) { 
            trigger_error("Reversed original doesn't match", E_USER_ERROR); 
        } 
        if (serialize($from_lines) != serialize($rev->getFinal())) { 
            trigger_error("Reversed final doesn't match", E_USER_ERROR); 
        } 
 
        $prevtype = null; 
        foreach ($this->_edits as $edit) { 
            if ($prevtype == get_class($edit)) { 
                trigger_error("Edit sequence is non-optimal", E_USER_ERROR); 
            } 
            $prevtype = get_class($edit); 
        } 
 
        return true; 
    } 
 
}