<h2>Editing File: /opt/alt/php71/usr/share/pear/File/MARC/Record.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php

/* vim: set expandtab shiftwidth=4 tabstop=4 softtabstop=4 foldmethod=marker: */

/**
 * Parser for MARC records
 *
 * This package is based on the PHP MARC package, originally called &quot;php-marc&quot;,
 * that is part of the Emilda Project (http://www.emilda.org). Christoffer
 * Landtman generously agreed to make the &quot;php-marc&quot; code available under the
 * GNU LGPL so it could be used as the basis of this PEAR package.
 * 
 * PHP version 5
 *
 * LICENSE: This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * @category  File_Formats
 * @package   File_MARC
 * @author    Christoffer Landtman &lt;landtman@realnode.com&gt;
 * @author    Dan Scott &lt;dscott@laurentian.ca&gt;
 * @copyright 2003-2008 Oy Realnode Ab, Dan Scott
 * @license   http://www.gnu.org/copyleft/lesser.html  LGPL License 2.1
 * @version   CVS: $Id$
 * @link      http://pear.php.net/package/File_MARC
 */

// {{{ class File_MARC_Record
/**
 * Represents a single MARC record
 * 
 * A MARC record contains a leader and zero or more fields held within a
 * linked list structure. Fields are represented by {@link File_MARC_Data_Field}
 * objects.
 *
 * @category File_Formats
 * @package  File_MARC
 * @author   Christoffer Landtman &lt;landtman@realnode.com&gt;
 * @author   Dan Scott &lt;dscott@laurentian.ca&gt;
 * @license  http://www.gnu.org/copyleft/lesser.html  LGPL License 2.1
 * @link     http://pear.php.net/package/File_MARC
 */
class File_MARC_Record
{

    // {{{ properties
    /**
     * Contains a linked list of {@link File_MARC_Data_Field} objects for
     * this record
     * @var File_MARC_List
     */
    protected $fields;

    /**
     * Record leader
     * @var string
     */
    protected $leader;

    /**
     * Non-fatal warnings generated during parsing
     * @var array
     */
    protected $warnings;

    /**
     * XMLWriter for writing collections
     * 
     * @var XMLWriter
     */
    protected $marcxml;

    /**
     * MARC instance for access to the XML header/footer methods
     * We need this so that we can properly wrap a collection of MARC records.
     * 
     * @var File_MARC
     */
    protected $marc;

    // }}}

    // {{{ Constructor: function __construct()
    /**
     * Start function
     *
     * Set all variables to defaults to create new File_MARC_Record object
     *
     * @param File_MARC $marc MARC record from File_MARC or File_MARCXML
     *
     * @return true 
     */
    function __construct($marc = null)
    {
        $this-&gt;fields = new File_MARC_List();
        $this-&gt;setLeader(str_repeat(' ', 24));
        if (!$marc) {
            $marc = new File_MARC(null, File_MARC::SOURCE_STRING); // oh the hack
        }
        $this-&gt;marc = $marc;
        $this-&gt;marcxml = $marc-&gt;getXMLWriter();
    }
    // }}}

    // {{{ Destructor: function __destruct()
    /**
     * Destroys the data field
     */
    function __destruct()
    {
        $this-&gt;fields = null;
        $this-&gt;warnings = null;
    }
    // }}}

    // {{{ getLeader()
    /**
     * Get MARC leader
     *
     * Returns the leader for the MARC record. No validation
     * on the specified leader is performed.
     *
     * @return string returns the leader
     */
    function getLeader()
    {
        return (string)$this-&gt;leader;
    }
    // }}}

    // {{{ setLeader()
    /**
     * Set MARC record leader
     *
     * Sets the leader for the MARC record. No validation
     * on the specified leader is performed.
     *
     * @param string $leader Leader
     *
     * @return string returns the leader
     */
    function setLeader($leader)
    {
        $this-&gt;leader = $leader;
        return $this-&gt;leader;
    }
    // }}}

    // {{{ appendField()
    /**
     * Appends field to MARC record
     *
     * Adds a {@link File_MARC_Control_Field} or {@link File_MARC_Data_Field}
     * object to the end of the existing list of fields.
     *
     * @param File_MARC_Field $new_field The field to add
     *
     * @return File_MARC_Field The field that was added
     */
    function appendField(File_MARC_Field $new_field)
    {
        /* Append as the last field in the record */
        $this-&gt;fields-&gt;appendNode($new_field);
        return $new_field;
    }
    // }}}

    // {{{ prependField()
    /**
     * Prepends field to MARC record
     *
     * Adds a {@link File_MARC_Control_Field} or {@link File_MARC_Data_Field}
     * object to the start of to the existing list of fields.
     *
     * @param File_MARC_Field $new_field The field to add
     *
     * @return File_MARC_Field The field that was added
     */
    function prependField(File_MARC_Field $new_field)
    {
        $this-&gt;fields-&gt;prependNode($new_field);
        return $new_field;
    }
    // }}}

    // {{{ insertField()
    /**
     * Inserts a field in the MARC record relative to an existing field
     *
     * Inserts a {@link File_MARC_Control_Field} or {@link File_MARC_Data_Field}
     * object before or after a specified existing field.
     *
     * &lt;code&gt;
     * // Example: Insert a new field before the first 650 field
     *
     * // Create the new field
     * $subfields[] = new File_MARC_Subfield('a', 'Scott, Daniel.');
     * $new_field = new File_MARC_Data_Field('100', $subfields, 0, null);
     *
     * // Retrieve the target field for our insertion point
     * $subject = $record-&gt;getFields('650');
     *
     * // Insert the new field
     * if (is_array($subject)) {
     *     $record-&gt;insertField($new_field, $subject[0], true);
     * }
     * elseif ($subject) {
     *     $record-&gt;insertField($new_field, $subject, true);
     * }
     * &lt;/code&gt;
     *
     * @param File_MARC_Field $new_field      The field to add
     * @param File_MARC_Field $existing_field The target field
     * @param bool            $before         Insert the new field before the existing field if true, after the existing field if false
     *
     * @return File_MARC_Field                The field that was added
     */
    function insertField(File_MARC_Field $new_field, File_MARC_Field $existing_field, $before = false)
    {
        $this-&gt;fields-&gt;insertNode($new_field, $existing_field, $before);
        return $new_field;
    }
    // }}}

    // {{{ _buildDirectory()
    /**
     * Build record directory
     *
     * Generate the directory of the record according to the current contents
     * of the record.
     *
     * @return array Array ($fields, $directory, $total, $base_address)
     */
    private function _buildDirectory()
    {
        // Vars
        $fields = array();
        $directory = array();
        $data_end = 0;

        foreach ($this-&gt;fields as $field) {
            // No empty fields allowed
            if (!$field-&gt;isEmpty()) {
                // Get data in raw format
                $str = $field-&gt;toRaw();
                $fields[] = $str;

                // Create directory entry
                $len = strlen($str);
                $direntry = sprintf(&quot;%03s%04d%05d&quot;, $field-&gt;getTag(), $len, $data_end);
                $directory[] = $direntry;
                $data_end += $len;
            }
        }

        /**
         * Rules from MARC::Record::USMARC
         */
        $base_address
            = File_MARC::LEADER_LEN +    // better be 24
                (count($directory) * File_MARC::DIRECTORY_ENTRY_LEN) +
                                // all the directory entries
                1;              // end-of-field marker


        $total
            = $base_address +  // stuff before first field
                $data_end +      // Length of the fields
                1;              // End-of-record marker


        return array($fields, $directory, $total, $base_address);
    }
    // }}}

    // {{{ setLeaderLengths()
    /**
     * Set MARC record leader lengths
     *
     * Set the Leader lengths of the record according to defaults specified in
     * {@link http://www.loc.gov/marc/bibliographic/ecbdldrd.html}
     *
     * @param int $record_length Record length
     * @param int $base_address  Base address of data
     *
     * @return bool              Success or failure
     */
    function setLeaderLengths($record_length, $base_address)
    {
        if (!is_int($record_length)) {
            return false;
        }
        if (!is_int($base_address)) {
            return false;
        }

        // Set record length
        $this-&gt;setLeader(substr_replace($this-&gt;getLeader(), sprintf(&quot;%05d&quot;, $record_length), 0, 5));
        $this-&gt;setLeader(substr_replace($this-&gt;getLeader(), sprintf(&quot;%05d&quot;, $base_address), File_MARC::DIRECTORY_ENTRY_LEN, 5));
        $this-&gt;setLeader(substr_replace($this-&gt;getLeader(), '22', 10, 2));
        $this-&gt;setLeader(substr_replace($this-&gt;getLeader(), '4500', 20, 4));

        if (strlen($this-&gt;getLeader()) &gt; File_MARC::LEADER_LEN) {
            // Avoid incoming leaders that are mangled to be overly long
            $this-&gt;setLeader(substr($this-&gt;getLeader(), 0, File_MARC::LEADER_LEN));
            $this-&gt;addWarning(&quot;Input leader was too long; truncated to &quot; . File_MARC::LEADER_LEN . &quot; characters&quot;);
        }
        return true;
    }
    // }}}

    // {{{ getField()
    /**
     * Return the first {@link File_MARC_Data_Field} or
     * {@link File_MARC_Control_Field} object that matches the specified tag
     * name. Returns false if no match is found.
     *
     * @param string $spec tag name
     * @param bool   $pcre if true, then match as a regular expression
     *
     * @return {@link File_MARC_Data_Field}|{@link File_MARC_Control_Field} first field that matches the requested tag name
     */
    function getField($spec = null, $pcre = null)
    {
        foreach ($this-&gt;fields as $field) {
            if (($pcre
                &amp;&amp; preg_match(&quot;/$spec/&quot;, $field-&gt;getTag()))
                || (!$pcre
                &amp;&amp; $spec == $field-&gt;getTag())
            ) {
                return $field;
            }
        }
        return false;
    }
    // }}}

    // {{{ getFields()
    /**
     * Return an array or {@link File_MARC_List} containing all
     * {@link File_MARC_Data_Field} or  {@link File_MARC_Control_Field} objects
     * that match the specified tag name. If the tag name is omitted all
     * fields are returned.
     *
     * @param string $spec tag name
     * @param bool   $pcre if true, then match as a regular expression
     *
     * @return File_MARC_List|array {@link File_MARC_Data_Field} or
     * {@link File_MARC_Control_Field} objects that match the requested tag name
     */
    function getFields($spec = null, $pcre = null)
    {
        if (!$spec) {
            return $this-&gt;fields;
        }

        // Okay, we're actually looking for something specific
        $matches = array();
        foreach ($this-&gt;fields as $field) {
            if (($pcre &amp;&amp; preg_match(&quot;/$spec/&quot;, $field-&gt;getTag()))
                || (!$pcre &amp;&amp; $spec == $field-&gt;getTag())
            ) {
                $matches[] = $field;
            }
        }
        return $matches;
    }
    // }}}

    // {{{ deleteFields()
    /**
     * Delete all occurrences of a field matching a tag name from the record.
     *
     * @param string $tag  tag for the fields to be deleted
     * @param bool   $pcre if true, then match as a regular expression
     *
     * @return int         number of fields that were deleted
     */
    function deleteFields($tag, $pcre = null)
    {
        $cnt = 0;
        foreach ($this-&gt;getFields() as $field) {
            if (($pcre
                &amp;&amp; preg_match(&quot;/$tag/&quot;, $field-&gt;getTag()))
                || (!$pcre
                &amp;&amp; $tag == $field-&gt;getTag())
            ) {
                $field-&gt;delete();
                $cnt++;
            }
        }
        return $cnt;
    }
    // }}}

    // {{{ addWarning()
    /**
     * Add a warning to the MARC record that something non-fatal occurred during
     * parsing.
     *
     * @param string $warning warning message
     *
     * @return true
     */
    public function addWarning($warning)
    {
        $this-&gt;warnings[] = $warning;
    }
    // }}}

    // {{{ getWarnings()
    /**
     * Return the array of warnings from the MARC record.
     *
     * @return array warning messages
     */
    public function getWarnings()
    {
        return $this-&gt;warnings;
    }
    // }}}

    // {{{ output methods
    /**
     * ========== OUTPUT METHODS ==========
     */

    // {{{ toRaw()
    /**
     * Return the record in raw MARC format.
     *
     * If you have modified an existing MARC record or created a new MARC
     * record, use this method to save the record for use in other programs
     * that accept the MARC format -- for example, your integrated library
     * system.
     *
     * &lt;code&gt;
     * // Example: Modify a record and save the output to a file
     * $record-&gt;deleteFields('650');
     *
     * // Now that the record has no subject fields, save it to disk
     * fopen($file, '/home/dan/no_subject.mrc', 'w');
     * fwrite($file, $record-&gt;toRaw());
     * fclose($file);
     * &lt;/code&gt;
     *
     * @return string Raw MARC data
     */
    function toRaw()
    {
        list($fields, $directory, $record_length, $base_address) = $this-&gt;_buildDirectory();
        $this-&gt;setLeaderLengths($record_length, $base_address);

        /**
         * Glue together all parts
         */
        return $this-&gt;getLeader().implode(&quot;&quot;, $directory).File_MARC::END_OF_FIELD.implode(&quot;&quot;, $fields).File_MARC::END_OF_RECORD;
    }
    // }}}

    // {{{ __toString()
    /**
     * Return the MARC record in a pretty printed string
     *
     * This method produces an easy-to-read textual display of a MARC record.
     *
     * The structure is roughly:
     * &lt;tag&gt; &lt;ind1&gt; &lt;ind2&gt; _&lt;code&gt;&lt;data&gt;
     *                     _&lt;code&gt;&lt;data&gt;
     *
     * @return string Formatted representation of MARC record
     */
    function __toString()
    {
        // Begin output
        $formatted = &quot;LDR &quot; . $this-&gt;getLeader() . &quot;\n&quot;;
        foreach ($this-&gt;fields as $field) {
            if (!$field-&gt;isEmpty()) {
                $formatted .= $field-&gt;__toString() . &quot;\n&quot;;
            }
        }
        return $formatted;
    }
    // }}}

    // {{{ toJSON()
    /**
     * Return the MARC record in JSON format
     *
     * This method produces a JSON representation of a MARC record. The input
     * encoding must be UTF8, otherwise the returned values will be corrupted.
     *
     * @return string          representation of MARC record in JSON format
     *
     * @todo Fix encoding input / output issues (PHP 6.0 required?)
     */
    function toJSON()
    {
        $json = new StdClass();
        $json-&gt;leader = utf8_encode($this-&gt;getLeader());

        /* Start fields */
        $fields = array();
        foreach ($this-&gt;fields as $field) {
            if (!$field-&gt;isEmpty()) {
                switch(get_class($field)) {
                case &quot;File_MARC_Control_Field&quot;:
                    $fields[] = array(utf8_encode($field-&gt;getTag()) =&gt; utf8_encode($field-&gt;getData()));
                    break;

                case &quot;File_MARC_Data_Field&quot;:
                    $subs = array();
                    foreach ($field-&gt;getSubfields() as $sf) {
                        $subs[] = array(utf8_encode($sf-&gt;getCode()) =&gt; utf8_encode($sf-&gt;getData()));
                    }
                    $contents = new StdClass();
                    $contents-&gt;ind1 = utf8_encode($field-&gt;getIndicator(1));
                    $contents-&gt;ind2 = utf8_encode($field-&gt;getIndicator(2));
                    $contents-&gt;subfields = $subs;
                    $fields[] = array(utf8_encode($field-&gt;getTag()) =&gt; $contents);
                    break;
                }
            }
        }
        /* End fields and record */

        $json-&gt;fields = $fields;
        $json_rec = json_encode($json);
        // Required because json_encode() does not let us stringify integer keys
        return preg_replace('/(&quot;subfields&quot;:)(.*?)\[&quot;([^\&quot;]+?)&quot;\]/', '\1\2{&quot;0&quot;:&quot;\3&quot;}', $json_rec);
    }

    // }}}

    // {{{ toJSONHash()
    /**
     * Return the MARC record in Bill Dueber's MARC-HASH JSON format
     *
     * This method produces a JSON representation of a MARC record as defined
     * at http://robotlibrarian.billdueber.com/new-interest-in-marc-hash-json/
     * The input * encoding must be UTF8, otherwise the returned values will
     * be corrupted.
     *
     * @return string          representation of MARC record in JSON format
     *
     * @todo Fix encoding input / output issues (PHP 6.0 required?)
     */
    function toJSONHash()
    {
        $json = new StdClass();
        $json-&gt;type = &quot;marc-hash&quot;;
        $json-&gt;version = array(1, 0);
        $json-&gt;leader = utf8_encode($this-&gt;getLeader());

        /* Start fields */
        $fields = array();
        foreach ($this-&gt;fields as $field) {
            if (!$field-&gt;isEmpty()) {
                switch(get_class($field)) {
                case &quot;File_MARC_Control_Field&quot;:
                    $fields[] = array(utf8_encode($field-&gt;getTag()), utf8_encode($field-&gt;getData()));
                    break;

                case &quot;File_MARC_Data_Field&quot;:
                    $subs = array();
                    foreach ($field-&gt;getSubfields() as $sf) {
                        $subs[] = array(utf8_encode($sf-&gt;getCode()), utf8_encode($sf-&gt;getData()));
                    }
                    $contents = array(
                        utf8_encode($field-&gt;getTag()),
                        utf8_encode($field-&gt;getIndicator(1)),
                        utf8_encode($field-&gt;getIndicator(2)),
                        $subs
                    );
                    $fields[] = $contents;
                    break;
                }
            }
        }
        /* End fields and record */

        $json-&gt;fields = $fields;
        return json_encode($json);
    }

    // }}}


    // {{{ toXML()
    /**
     * Return the MARC record in MARCXML format
     *
     * This method produces an XML representation of a MARC record that
     * attempts to adhere to the MARCXML standard documented at
     * http://www.loc.gov/standards/marcxml/
     *
     * @param string $encoding output encoding for the MARCXML record
     * @param bool   $indent   pretty-print the MARCXML record
     * @param bool   $single   wrap the &lt;record&gt; element in a &lt;collection&gt; element
     *
     * @return string          representation of MARC record in MARCXML format
     *
     * @todo Fix encoding input / output issues (PHP 6.0 required?)
     */
    function toXML($encoding = &quot;UTF-8&quot;, $indent = true, $single = true)
    {
        $this-&gt;marcxml-&gt;setIndent($indent);
        if ($single) {
            $this-&gt;marcxml-&gt;startElement(&quot;collection&quot;);
            $this-&gt;marcxml-&gt;writeAttribute(&quot;xmlns&quot;, &quot;http://www.loc.gov/MARC21/slim&quot;);
            $this-&gt;marcxml-&gt;startElement(&quot;record&quot;);
        } else {
            $this-&gt;marcxml-&gt;startElement(&quot;record&quot;);
            $this-&gt;marcxml-&gt;writeAttribute(&quot;xmlns&quot;, &quot;http://www.loc.gov/MARC21/slim&quot;);
        }
        

        // MARCXML schema has some strict requirements
        // We'll set reasonable defaults to avoid invalid MARCXML
        $xmlLeader = $this-&gt;getLeader();

        // Record status
        if ($xmlLeader[5] == &quot; &quot;) {
            // Default to &quot;n&quot; (new record)
            $xmlLeader[5] = &quot;n&quot;;
        }

        // Type of record
        if ($xmlLeader[6] == &quot; &quot;) {
            // Default to &quot;a&quot; (language material)
            $xmlLeader[6] = &quot;a&quot;;
        }

        $this-&gt;marcxml-&gt;writeElement(&quot;leader&quot;, $xmlLeader);

        foreach ($this-&gt;fields as $field) {
            if (!$field-&gt;isEmpty()) {
                switch(get_class($field)) {
                case &quot;File_MARC_Control_Field&quot;:
                    $this-&gt;marcxml-&gt;startElement(&quot;controlfield&quot;);
                    $this-&gt;marcxml-&gt;writeAttribute(&quot;tag&quot;, $field-&gt;getTag());
                    $this-&gt;marcxml-&gt;text($field-&gt;getData());
                    $this-&gt;marcxml-&gt;endElement(); // end control field
                    break;

                case &quot;File_MARC_Data_Field&quot;:
                    $this-&gt;marcxml-&gt;startElement(&quot;datafield&quot;);
                    $this-&gt;marcxml-&gt;writeAttribute(&quot;tag&quot;, $field-&gt;getTag());
                    $this-&gt;marcxml-&gt;writeAttribute(&quot;ind1&quot;, $field-&gt;getIndicator(1));
                    $this-&gt;marcxml-&gt;writeAttribute(&quot;ind2&quot;, $field-&gt;getIndicator(2));
                    foreach ($field-&gt;getSubfields() as $subfield) {
                        $this-&gt;marcxml-&gt;startElement(&quot;subfield&quot;);
                        $this-&gt;marcxml-&gt;writeAttribute(&quot;code&quot;, $subfield-&gt;getCode());
                        $this-&gt;marcxml-&gt;text($subfield-&gt;getData());
                        $this-&gt;marcxml-&gt;endElement(); // end subfield
                    }
                    $this-&gt;marcxml-&gt;endElement(); // end data field
                    break;
                }
            }
        }

        $this-&gt;marcxml-&gt;endElement(); // end record
        if ($single) {
            $this-&gt;marcxml-&gt;endElement(); // end collection
            $this-&gt;marcxml-&gt;endDocument();
        }
        return $this-&gt;marcxml-&gt;outputMemory();
    }
    // }}}

}
// }}}

</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Falt%2Fphp71%2Fusr%2Fshare%2Fpear%2FFile%2FMARC'>Back to Directory</a>