MARC21.php

Go to the documentation of this file.

<?php

 

require_once "ISO2709.php";

 

class MARC21RecordSetIterator extends ISO2709RecordSetIterator {

    public function __construct( $input ) {

        parent::__construct( $input );

        $this->prepend = fread( $this->input, 5 );

        if( ctype_digit( $this->prepend ) ) $this->RecordTerminator = ISO2709::RecordTerminator;

        else if( $this->prepend === "=LDR " ) {

            $this->RecordTerminator = "\r\n\r\n";

        } else if( $this->prepend === "=000 " ) {

            $this->RecordTerminator = "\r\n\r\n";

        }

        $this->recordClass = "MARC21Record";

    }

}

 

class MARC21RecordSetArray extends ISO2709RecordSetArray {

    public function __construct( $input ) {

        parent::__construct( $input );

        $this->recordClass = "MARC21Record";

    }

}

 

class MARC21Record extends ISO2709Record {

    protected $mnemonicType;

    function __construct( ) {

        parent::__construct();

        $this->set_default( "identifierLength", 2 );

        $this->set_default( "indicatorLength", 2 );

        $this->set_default( "lengthOfLengthOfField", 4 );

        $this->set_default( "lengthOfStartingCharacterPosition", 5 );

        $this->set_default( "lengthOfImplementationDefined", 0 );

        $this->mnemonicType = "LC";

    }

 

    function isTagValid( $tag ) {

        return is_string( $tag ) and ctype_digit( $tag ) and strlen( $tag ) == 3 and $tag !== "000";

    }

 

    function assertTagValid( $tag ) {

        if( !self::isTagValid( $tag ) ) {

            $this->exception("MARC21: Tags must be numeric and must be 3 bytes long. Thus '$tag' is not allowed.");

            return false;

        }

        return parent::assertTagValid( $tag );

    }

 

    function isTagRepeatable( $tag ) {

        return $tag != "001" and $tag != "005";

    }

 

    // 00* ordered ASCII-wise, otherwise order by century


    function tagOrder( $a, $b ) {

        if(!parent::isTagValid($a) || !parent::isTagValid($b)) return 0;

        if( $a === $b ) return 0;

        $a0 = substr( $a, 0, 2 );

        $b0 = substr( $b, 0, 2 );

        if( $a0 === $b0 and $a0 === "00" ) return strcmp( $a, $b );

        if( $a0 === "00" ) { return -1; }

        if( $b0 === "00" ) { return 1; }

        $a0 = substr( $a, 0, 1 );

        $b0 = substr( $b, 0, 1 );

        if( $a0 === "0" and $b0 === "0" ) {

            if( $a === "049" ) return 1;

            if( $b === "049" ) return -1;

        }

        return strcmp( $a0, $b0 );

    }

 

    function assertTagOrder( $a, $b ) {

        if( self::tagOrder( $a, $b ) > 0 ) {

            $this->exception("MARC21: 00* is ordered by ASCII, and the rest by century. Thus '$a' should not precede '$b'.");

            return false;

        }

        return parent::assertTagOrder( $a, $b );

    }

 

    function loadFromBinaryString( $string, $fuzzy = true ) {

        $ret = parent::loadFromBinaryString( $string );

        if( $ret === false ) return $ret;

        if( strlen($this->leader) != 24 ) return false;

        if(!ctype_print($this->leader))

            $this->exception("MARC21: Leader can only contain 0x20 through 0x7E, not 0x" . bin2hex( $this->leader ) );

        if($this->leader[23] != "0")

            $this->exception("MARC21: Last character of leader is supposed to be '0' not '{$this->leader[23]}'");

        return true;

        // Check data order


        # MARC21


        # 00*-00* are in numeric-alpha order in both directory and data (with no intervening in either directory or data)


    }

 

    function CheckField( $field ) {

        parent::CheckField( $field );

        if( substr( $field->tag, 0, 2 ) === "00" ) {

            // No extra requirements on control fields


        } else {

            // Indicators must be length 2, numeric, lower case, or space


            if( !preg_match("/^[0-9a-z ]{2}$/", $field->indicators) )

                $this->exception("MARC21 8.3.5: indicators should be length 2, and each character should be lower case, numeric, or a space. " .

                    "So field '{$field->tag}' with indicators '{$field->indicators}' is not allowed." );

            // Subfield identifiers must be length 1, numeric, or lower case


            foreach( $field->subfields as $subfield ) {

                if( !preg_match("/^[0-9a-z]$/", $subfield->identifier) )

                    $this->exception("MARC21 8.3.5: subfield identifiers should be length 1, and each character should be lower case or numeric. " .

                        "So field '{$field->tag}' with subfield '{$subfield->identifier}' is not allowed." );

            }

        }

    }

 

    function loadFromMnemonicString( $string ) {

        $this->leader = array();

        $this->fields = array();

        $this->exceptions = array();

        $this->raw = $string;

        foreach( explode( "\r\n", $string ) as $line ) {

            $field = $this->ParseMnemonicLine( $line );

            if( $field !== false ) $this->AppendField( $field );

        }

    }

 

    function loadFromXMLString( $string ) {

        $this->leader = array(); # XXX ??

        $this->fields = array();

        $this->exceptions = array();

        $this->raw = $string;

 

        $doc = new DOMDocument();

        $doc->loadXML($string);

        $xpath = new DOMXpath($doc);

 

        $leaderfield = $xpath->query('//record/leader');

        if ($leaderfield) { # <leader>00838mas a2200301 a 4500</leader>

            $leader = $leaderfield[0]->nodeValue;

            if( strlen($leader) != 24 ) return false;

            $this->leader = $leader;

        }

 

        # $field = new ISO2709Field( $tag, $data, $indicators, $subfields, $directoryEntry, $this );


 

        $controlfield = $xpath->query('//record/controlfield');

        if ($controlfield) { # <controlfield tag="001"> 92005291 </controlfield>

            foreach ($controlfield as $cfd) {

                $tag = $cfd->getAttribute('tag');

                $data = $cfd->nodeValue;

                $field = new ISO2709Field( $tag, $data ); 

                $this->AppendField( $field );

            }

        }

 

        $datafield = $xpath->query('//record/datafield');

        if ($datafield) { # <datafield ind1=" " ind2=" " tag="035"><subfield code="9">AHE8121LM</subfield></datafield>

            foreach ($datafield as $dfd) {

                $tag = $dfd->getAttribute('tag');

                $indicators = $dfd->getAttribute('ind1') . $dfd->getAttribute('ind2');

                $subfields = array();

                foreach ($dfd->childNodes as $subf) {

                    if ($subf->nodeType == '1') { # Element

                        $code = $subf->getAttribute('code');

                        $value = $subf->nodeValue;

                        $subfields[] = new ISO2709Subfield( $code, $value );

                    } 

                }

                $field = new ISO2709Field( $tag, null, $indicators, $subfields);

                $this->AppendField( $field );

            }

        }

    }

 

    function asXMLString( ) {

        $str = '<record>';

        $str .= '<leader>' . $this->leader . '</leader>';

        foreach( $this->fields as $field ) {

            $tag = escapeXmlAttribute($field->tag);

            if ( isset($field->data ) ) {

                $data = escapeXmlInnerText($field->data);

                $str .= "<controlfield tag=\"$tag\">$data</controlfield>";

            } else {

                $ind1 = escapeXmlAttribute($field->indicators[0]);

                $ind2 = escapeXmlAttribute($field->indicators[1]);

                $str .= "<datafield tag=\"$tag\" ind1=\"$ind1\" ind2=\"$ind2\">"; 

                foreach( $field->subfields as $subfield ) {

                    $code = escapeXmlAttribute($subfield->identifier);

                    $data = escapeXmlInnerText($subfield->data);

                    $str .= "<subfield code=\"$code\">$data</subfield>";

                }

                $str .= '</datafield>';

            }

        }

        $str .= '</record>';

        file_put_contents("/tmp/wiggle",$str);

        return $str;

    }

 

    function loadFromString( $string ) {

        if (preg_match("/^ *([^ ])/",$string,$m)) {

            $starts_with = $m[1];

            if ($starts_with == '<') {

                return $this->loadFromXMLString( $string );

            }

            if ($starts_with == '=') {

                return $this->loadFromMnemonicString( $string );

            }

            if (ctype_digit($starts_with)) {

                return $this->loadFromBinaryString( $string );

            }

            return false;

        }

        return false;

    }

 

    function ParseMnemonicLine( $line ) {

        $equ = substr( $line, 0, 1 );

        $tag = substr( $line, 1, 3 );

        $spa = substr( $line, 4, 2 );

        $dat = substr( $line, 6 );

        if( $equ !== "=" or $spa !== "  " ) {

            $this->exception("Mnemonic: unreadable line '$line'");

            return false;

        }

        if( $tag == "LDR" or $tag == "000" ) {

            $this->leader = $dat;

            $this->indicatorLength = 2;

            $this->identifierLength = 2;

            $this->mnemonicType = ($tag == "LDR") ? "TRME" : "LCMB";

            return false;

        }

        if( $this->mnemonicType === "TRME" ) {

            $dat = str_replace( '$', ISO2709::SubfieldInitiator, $dat );

            $dat = str_replace( '\\', ' ', $dat );

        } else if( $this->mnemonicType === "LCMB" ) {

            $dat = str_replace( '$', ISO2709::SubfieldInitiator, $dat );

            $dat = str_replace( '#', ' ', $dat );

        /* // These might not really be applicable


        } else if( $this->mnemonicType === "OCLC" ) {


            $dat = str_replace( 'ǂ', ISO2709::SubfieldInitiator, $dat );


            // no space translation


        } else if( $this->mnemonicType === "VGER" ) {


            $dat = str_replace( '‡', ISO2709::SubfieldInitiator, $dat );


            // no space translation


        } else if( $this->mnemonicType === "ALMA" ) {


            $dat = str_replace( '$$', ISO2709::SubfieldInitiator, $dat );


        */


        } else {

            if( substr($tag,0,2) === "00" ) {

                $dat = str_replace( '#', ' ', $dat );

                $dat = str_replace( '\\', ' ', $dat );

            } else {

                if( $dat[0] == '\\' ) $dat[0] = ' ';

                if( $dat[1] == '\\' ) $dat[1] = ' ';

                if( $dat[0] == '#' ) $dat[0] = ' ';

                if( $dat[1] == '#' ) $dat[1] = ' ';

                if( strpos( $dat, ISO2709::SubfieldInitiator ) === false ) {

                    $dat = str_replace( '$', ISO2709::SubfieldInitiator, $dat );

                }

            }

        }

        return $this->ParseBinaryField( $tag, $dat, array() );

    }

 

    function AppendField( $field, $reorder = false ) {

        if( is_string( $field ) ) {

            $field = $this->ParseMnemonicLine( $field );

        }

        if( is_a( $field, "ISO2709Field" ) ) return parent::AppendField( $field, $reorder );

    }

 

    

    function AsMnemonicString( $leader_tag = 'LDR', $field_initiator = '=', $tag_terminator = '  ', $identifier_initiator = '$', $field_terminator = "\r\n", $record_terminator = "\r\n", $space_replacer = ' ') {

        if( $this->mnemonicType === "TRME" ) return parent::AsMnemonicString( "LDR", "=", "  ", "\$", "\r\n", "\r\n", "\\" );

        if( $this->mnemonicType === "LCMB" ) return parent::AsMnemonicString( "000", "=", "  ", "\$", "\r\n", "\r\n", "#" );

        if( $this->mnemonicType === "VGER" ) return parent::AsMnemonicString( "LEADER", "=", "  ", "|", "\r\n", "\r\n", "#" );

        #return parent::AsMnemonicString( "LDR", "=", "  ", "\$", "\r\n", "\r\n", " " );

        return parent::AsMnemonicString( $leader_tag, $field_initiator, $tag_terminator, $identifier_initiator, $field_terminator, $record_terminator, $space_replacer );

    }

 

    function delFields( $pattern ) {

        foreach( $this->fields as $k => $v ) {

            $vmne = $v->AsMnemonicString( "=", "  ", "\$", "\r\n", '\\' );

            if( preg_match( "@^" . $pattern . "@", $vmne ) ) unset( $this->fields[$k] );

        }

        $this->fields = array_values( $this->fields );

    }

        

}

 

function escapeXmlAttribute($str) {

    return htmlspecialchars($str, ENT_XML1 | ENT_COMPAT, 'UTF-8');

}

 

function escapeXmlInnerText($str) {

    return htmlspecialchars($str, ENT_XML1, 'UTF-8');

}