ISO2709.php

Go to the documentation of this file.

 <?php

 

 

 /***********************************************************************


 **


 **  Methods for dealing with ISO2709 (MARC) records and files


 */


 

 # TODO: should fields be in directory order or data order?


 

 # TODO: Missing exceptions:


 # ISO2709


 # 001 is non-repeatable


 # 001 is first in data


 # 002-009 are next in data, but in any order


 

 class ISO2709RecordSetIterator implements Iterator {

     protected $input, $currentPosition, $currentRecord, $valid, $RecordTerminator, $prepend;

     public function __construct( $input ) {

         if( is_string( $input ) ) $input = fopen( $input, "rb" );

         if( !is_resource( $input ) ) throw new Exception("ISO2709RecordSetIterator requires a file resource, filename, or URL to be created");

         $this->input = $input;

         $this->recordClass = "ISO2709Record";

         $this->RecordTerminator = ISO2709::RecordTerminator;

         $this->prepend = "";

     }

     public function valid() { return $this->valid; }

     public function current() {

         return $this->currentRecord;

     }

     public function key() {

         return $this->currentPosition;

     }

     public function next() {

         if( $this->currentRecord === null ) $this->currentRecord = new $this->recordClass();

         $this->currentPosition++;

         $string = stream_get_line( $this->input, 99999, $this->RecordTerminator );

         $this->valid = true;

         if( $string === false ) $this->valid = false;

         else $this->currentRecord->loadFromString( $this->prepend . $string );

         $this->prepend = "";

     }

     public function rewind() {

         if($this->currentPosition !== null) rewind( $this->input );

         $this->currentPosition = -1;

         $this->currentRecord = new $this->recordClass();

         $this->next();

     }

 }

 

 class ISO2709RecordSetArray implements ArrayAccess {

     protected $input, $records, $numRecords, $cache, $recordOffsets, $numCache, $recordClass;

 

     function __construct( $input, $numCache = 10 ) {

         if( is_string( $input ) ) $input = fopen( $input, "rb" );

         if( !is_resource( $input ) ) throw new Exception("ISO2709RecordSetArray requires a file resource, filename, or URL to be created");

         $this->input = $input;

         $this->records = array();

         $this->cache = array();

         $this->recordOffsets = array();

         $this->recordOffsets[0] = 0;

         $this->numCache = $numCache;

         $this->recordClass = "ISO2709Record";

     }

 

     public function offsetExists( $offset ) {

         if(!is_int($offset) or $offset < 0 or ($this->numRecords !== null and $this->numRecords <= $offset))

             return false;

         return $this->offsetGet( $offset ) === false;

     }

 

     public function offsetGet ( $offset ) {

         # Update cache


         foreach( array_keys( $this->cache, $offset ) as $k ) { unset($this->cache[$k]); }

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

         array_push( $this->cache, $offset );

         while( count( $this->cache ) > $this->numCache ) {

             $k = array_shift( $this->cache );

             unset( $this->records[$k] );

         }

         # Now get the record


         if( !isset( $this->records[ $offset ] ) ) {

             if( !isset( $this->recordOffsets[$offset] ) ) {

                 for( $i = $offset - 1 ; $i > 0 ; $i-- ) {

                     if( isset( $this->recordOffsets[$i] ) ) break;

                 }

                 fseek( $this->input, $this->recordOffsets[$i], SEEK_SET );

                 while( $i < $offset ) {

                     stream_get_line( $this->input, 99999, ISO2709::RecordTerminator );

                     $i++;

                     $this->recordOffsets[ $i ] = ftell( $this->input );

                 }

             } else {

                 fseek( $this->input, $this->recordOffsets[$offset], SEEK_SET );

             }

             $this->records[ $offset ] = new $this->recordClass();

             $this->records[ $offset ]->loadFromBinaryStream( $this->input );

             if(feof($this->input)) {

                 $this->numRecords = $offset+1;

             } else {

                 $this->recordOffsets[$offset+1] = ftell( $this->input );

             }

         }

         return $this->records[ $offset ];

     }

 

     public function offsetSet ( $offset, $value ) {

         throw new Exception( "This type of record set is read-only, sorry" );

     }

 

     public function offsetUnset ( $offset ) {

         throw new Exception( "This type of record set is read-only, sorry" );

     }

 }

 

 class ISO2709 {

     /* A record must be terminated with 0x1D, 


     the directory and each field must be terminated with 0x1E, 


     and each subfield begins with an identifier which must in turn begin


     with 0x1F */


     const RecordTerminator = "\035";

     const FieldTerminator = "\036";

     const SubfieldInitiator = "\037";

 

 };

 

 class ISO2709Exception extends Exception { };

 

 class ISO2709Record {

     public $leader; // string form of the leader (mnemonic marc format)


     public $fields; // array of ISO2709 fields


     public $exceptions; // an array of standards violations as strings


     public $raw;

     protected $identifierLength, $indicatorLength;

 

     protected $defaults;

 

     protected function set_default( $name, $value ) {

         if( !isset( $this->defaults ) ) $this->defaults=array();

         if( !isset( $this->defaults[$name] ) ) $this->defaults[$name] = $value;

     }

 

     function __construct( ) { 

         $this->set_default( "identifierLength", 0 ); // required, so if not available disable subfields


         $this->set_default( "indicatorLength", 0 ); // advisory only


         $this->set_default( "lengthOfLengthOfField", 4 ); // required, but no real default; use MARC21


         $this->set_default( "lengthOfStartingCharacterPosition", 5 ); // required, but no real default; use MARC21


         $this->set_default( "lengthOfImplementationDefined", 0 ); // required, it seems like 0 is the only sensible value; use MARC21


         $this->leader = "";

         $this->fields = array();

         $this->exceptions = array();

     }

 

     ############################################################    


     ##


     ##  Standards conformance


     ##


 

     // ISO2709 4.5.1


     function isTagValid( $tag ) {

         return ($tag !== "000") && is_string( $tag ) && ( preg_match('/^[0-9A-Z]{3}$/',$tag) || preg_match('/^[0-9a-z]{3}$/',$tag) );

     }

 

     function assertTagValid( $tag ) {

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

             $this->exception("ISO2709 4.5.1: Tags must be alphanumeric, using only one case, and must be 3 bytes long. Thus '$tag' is not allowed.");

             return false;

         }

         if( !$this->isTagValid( $tag ) ) {

             $this->exception("Unknown: Invalid tag '$tag'");

             return false;

         }

         return true;

     }

 

     // ISO2709 4.1


     function isTagRepeatable( $tag ) {

         return ($tag !== "001");

     }

 

     function assertTagRepeatable( $tag ) {

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

             $this->exception("ISO2709 4.5.1: 001 refers to the record identifier field, which is not repeatable (4.1c)");

             return false;

         }

         if( !$this->isTagRepeatable( $tag ) ) {

             $this->exception("Unknown: Tag '$tag' is not repeatable.");

             return false;

         }

         return true;

     }

 

     // ISO2709 4.1


     // -1 if $a must come before $b, +1 if $a must come after $b, 0 if unspecified


     // ISO2709 ordering is simple 001, then 00*, then ***


     function tagOrder( $a, $b ) {

         if(!$this->isTagValid($a) || !$this->isTagValid($b)) return 0;

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

         if( $a === "001" ) return -1;

         if( $b === "001" ) return +1;

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

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

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

         if( $a === "00" ) return -1;

         if( $b === "00" ) return +1;

         return 0;

     }

 

     function assertTagOrder( $a, $b ) {

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

             $this->exception("ISO2709 4.1: Field 001 is first, followed by 00* in any order, followed by all other tags; hence '$a' cannot precede '$b'");

         else if( $this->tagOrder( $a, $b ) > 0 )

             $this->exception("Unknown: '$a' is not supposed to precede '$b'");

     }

 

     function exception( $string ) {

         $this->exceptions[] = $string;

     }

 

     ############################################################


     ##


     ##  Parsing a binary string


     ##


 

     public function loadFromBinaryStream( $filehandle ) {

         $peek = stream_get_line( $filehandle, 99999, ISO2709::RecordTerminator );

         if( $peek ) $peek .= ISO2709::RecordTerminator;

         else return false;

         /* 


         $peek = fread( $filehandle, 5 );


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


         if( ! ctype_digit( $peek ) ) return false;


         $peek .= fread( $filehandle, intval( $peek ) - 5 );


         */


         return $this->loadFromBinaryString( $peek );

     }

 

     private function checkString( $name, $trueValue, $string, $start = 0, $length = false, $default = false ) {

         $string = ( $length === false ) ? substr( $string, $start ) : substr( $string, $start, $length );

         if( is_int( $trueValue ) ) {

             if( !ctype_digit( $string ) or intval( $string ) !== $trueValue )

                 $this->exception(

                 "ISO2709: Value '$string' for \"$name\" does not match computed value '$trueValue'" );

         } else {

             if( !ctype_digit( $string ) )

                 $this->exception(

                 "ISO2709: Value '$string' for \"$name\" is not numeric" );

         }

         return ctype_digit($string)?intval( $string ):$default;

     }

 

     public function setLeader( $string ) {

         $this->leader = $string;

         $this->indicatorLength = $this->checkString( "Indicator Length", false, $this->leader, 10, 1, $this->defaults["indicatorLength"] );

         $this->identifierLength = $this->checkString( "Identifier Length", false, $this->leader, 11, 1, $this->defaults["identifierLength"] );

     }

 

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

         $this->leader = substr( $string, 0, 24 );

         $this->fields = array();

         $this->exceptions = array();

         $this->raw = $string;

 

         // We now ignore the leader as much as possible


         $recordLength = strpos( $string, ISO2709::RecordTerminator ) + 1;

         $baseAddressOfData = strpos( $string, ISO2709::FieldTerminator )+1;

 

         $this->checkString( "Record Length", $recordLength, $this->leader, 0, 5 );

         $indicatorLength = $this->checkString( "Indicator Length", false, $this->leader, 10, 1, $this->defaults["indicatorLength"] );

         $identifierLength = $this->checkString( "Identifier Length", false, $this->leader, 11, 1, $this->defaults["identifierLength"] );

         $this->checkString( "Base Address of Data", $baseAddressOfData, $this->leader, 12, 5 );

         $lengthOfLengthOfField = $this->checkString( "Length of Length-Of-Field portion of directory entry", false, $this->leader, 20, 1, $this->defaults["lengthOfLengthOfField"] );

         $lengthOfStartingCharacterPosition = $this->checkString( "Length of Starting-Character-Position portion of directory entry", false, $this->leader, 21, 1, $this->defaults["lengthOfStartingCharacterPosition"] );

         $lengthOfImplementationDefined = $this->checkString( "Length of Implementation-Defined portion of directory entry", false, $this->leader, 22, 1, $this->defaults["lengthOfImplementationDefined"] );

         if( "$lengthOfLengthOfField$lengthOfStartingCharacterPosition$lengthOfImplementationDefined" !== "450" ) {

             $this->exception( "MARC21: $lengthOfLengthOfField$lengthOfStartingCharacterPosition$lengthOfImplementationDefined != 450" );

             $lengthOfLengthOfField = 4;

             $lengthOfStartingCharacterPosition = 5;

             $lengthOfImplementationDefined = 0;

         }

 

         $this->indicatorLength = $indicatorLength; // advisory only


         $this->identifierLength = $identifierLength; // required


 

         $lengthOfDirectoryEntry = 3 + $lengthOfLengthOfField + $lengthOfStartingCharacterPosition + $lengthOfImplementationDefined;

 

         if( 0 != ( ( $baseAddressOfData-25) % $lengthOfDirectoryEntry ) )

         $this->exception( "ISO2709 4.4.1: Directory does not end on directory entry boundary ".

             "(Directory is ". ($baseAddressOfData-25)." bytes long, " .

             "each entry is 3 + $lengthOfLengthOfField + $lengthOfStartingCharacterPosition + $lengthOfImplementationDefined = $lengthOfDirectoryEntry bytes long, " .

             "leaving " . (($baseAddressOfData-25)%$lengthOfDirectoryEntry) . " bytes leftover)" );

 

         // now read the directory


         $fieldTypeMode = 0;

         $lastTag = false;

         for( $i = 24 ; $i+$lengthOfDirectoryEntry+1 <= $baseAddressOfData ; $i+= $lengthOfDirectoryEntry ) {

             $tag = substr( $string, $i, 3 );

 

             $off = $this->checkString( "Start of field '$tag'", false, $string, $i+3+$lengthOfLengthOfField, $lengthOfStartingCharacterPosition );

             if( $baseAddressOfData + $off > strlen($string) ) {

                 $off = substr( $string, $i+3+$lengthOfLengthOfField, $lengthOfStartingCharacterPosition );

                 $this->exception( "ISO2709: Offset '$off' of field '$tag' is beyond end of string. Losing this field." );

                 continue;

             }

             if( $string[ $baseAddressOfData + $off - 1 ] !== ISO2709::FieldTerminator ) {

                 $this->exception( "Jack: Data for field '$tag' does not immediately follow a field terminator" );

                 $off = strrpos( substr( $string, 0, $baseAddressOfData + $off ), ISO2709::FieldTerminator ) - $baseAddressOfData + 1;

             }

             $len = strpos( $string, ISO2709::FieldTerminator, $baseAddressOfData + $off ) - ( $baseAddressOfData + $off - 1);

             $imp = substr( $string, $i + 3 + $lengthOfLengthOfField + $lengthOfStartingCharacterPosition, $lengthOfImplementationDefined );

 

             $maxFieldLen = intval( "1" .str_repeat( $lengthOfLengthOfField, "0" ) ) - 1;

             $calclen = 0;

             while( substr( $string, $i+3, $lengthOfLengthOfField ) === "000" ) {

                 $calclen += $maxFieldLen;

                 $i += $lengthOfDirectoryEntry;

                 $newTag = substr( $string, $i, 3 );

                 if( $tag !== $newTag ) {

                     $this->exception("ISO2709 4.4.4: When the recorded field length is 0, each following directory entry refers to the same field. However, we went from '$tag' to '$newTag'.");

                     $i -= $lengthOfDirectoryEntry;

                     break;

                 }

             }

             $this->checkString( "Length of field '$tag'", $len-$calclen, $string, $i+3, $lengthOfLengthOfField );

 

 

             // read in the field


             $data = substr( $string, $baseAddressOfData + $off, $len - 1 );

             $this->AppendFieldBinary( $tag, $data, array( $tag, $len, $off, $imp ) );

         }

         return true;

     }

 

     function DataNotInDirectory( ) {

         $string = $this->raw;

         $recordLength = strpos( $string, ISO2709::RecordTerminator ) + 1;

         $baseAddressOfData = strpos( $string, ISO2709::FieldTerminator )+1;

         $lengthOfLengthOfField = $this->checkString( "Length of Length-Of-Field portion of directory entry", false, $this->leader, 20, 1, $this->defaults["lengthOfLengthOfField"] );

         $lengthOfStartingCharacterPosition = $this->checkString( "Length of Starting-Character-Position portion of directory entry", false, $this->leader, 21, 1, $this->defaults["lengthOfStartingCharacterPosition"] );

         $lengthOfImplementationDefined = $this->checkString( "Length of Implementation-Defined portion of directory entry", false, $this->leader, 22, 1, $this->defaults["lengthOfImplementationDefined"] );

         $lengthOfDirectoryEntry = 3 + $lengthOfLengthOfField + $lengthOfStartingCharacterPosition + $lengthOfImplementationDefined;

 

         $map = str_repeat( "?", $recordLength );

         for( $i = 24 ; $i+$lengthOfDirectoryEntry+1 <= $baseAddressOfData ; $i+= $lengthOfDirectoryEntry ) {

             $tag = substr( $string, $i, 3 );

             $off = intval( substr( $string, $i+3+$lengthOfLengthOfField, $lengthOfStartingCharacterPosition ) );

             $off = strrpos( substr( $string, 0, $baseAddressOfData + $off ), ISO2709::FieldTerminator ) - $baseAddressOfData + 1;

 

             $calclen = 0;

             $maxFieldLen = intval( "1" .str_repeat( $lengthOfLengthOfField, "0" ) ) - 1;

             while( substr( $string, $i+3, $lengthOfLengthOfField ) === "000" ) {

                 $i += $lengthOfDirectoryEntry;

                 $calclen += $maxFieldLen;

             }

             $len = $calclen + intval( substr( $string, $i+3, $lengthOfLengthOfField ) );

 

             for( $j = 0 ; $j < $len ; $j++ ) {

                 $map[$baseAddressOfData+$off+$j] = " ";

             }

             $map = substr_replace( $map, $tag, $baseAddressOfData+$off );

             $map[$baseAddressOfData+$off+$len-1] = "t";

         }

         for( $i = 0 ; $i < $recordLength ; $i++ ) {

             if( $i < 24 ) $map[$i] = "l";

             else if( $i+1 < $baseAddressOfData ) $map[$i] = "d";

             else if( $string[$i] == ISO2709::FieldTerminator ) {

                 if($map[$i] != "t") $map[$i]="#";

                 else $map[$i] = "T";

             }

         }

         print $map."\n";

     }

 

     function loadFromString( $string ) {

         return $this->loadFromBinaryString( $string );

     }

         

 

     ############################################################


     ##


     ##  Append a field to a MARC record


     ##


 

     function ParseBinaryField( $tag, $data, $directoryEntry ) {

         # Check for valid tag


         $this->assertTagValid($tag);

 

         # Strip out indicators and subfields, handling bad data


         # If there is a subfield identifier initiator, then everything before it is the indicators


         # Otherwise the indicators are precisely the first indicatorLength bytes


         if( false !== ( $subfieldStart = strpos( $data, ISO2709::SubfieldInitiator ) ) ) {

             $indicators = substr( $data, 0, $subfieldStart );

             $subfields = explode( ISO2709::SubfieldInitiator, substr( $data, $subfieldStart+1 ) );

             foreach( $subfields as $k => $v ) {

                 $identifier = substr( $v, 0, $this->identifierLength - 1);

                 $subdata = substr( $v, $this->identifierLength-1 );

                 $subfields[$k] = new ISO2709Subfield( $identifier, $subdata );

             }

             $data = "";

         } else {

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

                 $indicators = substr( $data, 0, $this->indicatorLength );

                 $data = substr( $data, $this->indicatorLength );

             } else {

                 $indicators = "";

             }

             $subfields = array();

         }

         return new ISO2709Field( $tag, $data, $indicators, $subfields, $directoryEntry, $this );

     }

 

     function AppendFieldBinary( $tag, $data, $directoryEntry = array(), $reorder = false ) {

         $field = $this->ParseBinaryField( $tag, $data, $directoryEntry );

         $this->AppendField( $field, $reorder );

     }

 

     function CheckField( $field ) {

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

             if( $field->indicators !== "" )

                 $this->exception("ISO2709 4.5.4: Control fields have no indicators, but field '{$field->tag}' has indicators '{$field->indicators}'");

             if( count( $field->subfields ) > 0 )

                 $this->exception("ISO2709 4.5.4: Control fields have no subfields, but field '{$field->tag}' has " . count( $field->subfields) . " subfields");

         } else {

             if( strlen( $field->indicators ) != $this->indicatorLength )

                 $this->exception("ISO2709 4.5.4d: Field '{$field->tag}' has indicators '{$field->indicators}' of the wrong length (specified length is {$this->indicatorLength})");

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

                 if( strlen( $subfield->identifier ) + 1 != $this->identifierLength )

                     $this->exception("ISO2709: Field '{$field->tag}' has subfield '\${$subfield->identifier}' but that is not the right length of a subfield identifier.");

             }

             if( $field->data !== "" and $this->indicatorLength > 0 )

                 $this->exception("ISO2709 4.5.4: Field '{$field->tag}' has data, but should only have subfields");

         }

     }

 

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

         $this->checkField( $field );

         $field->record = $this;

 

         # Check for valid ordering


         $numTags = count( $this->fields );

         if( $numTags > 0 ) {

             if( $reorder === false ) {

                 $lastTag = $this->fields[ $numTags - 1 ]->tag;

                 #$this->assertTagOrder( $lastTag, $field->tag );


                 $appendAfter = $numTags;

             } else {

                 for( $i = $numTags - 1 ; $i >= 0 ; $i-- ) {

                     $lastTag = $this->fields[ $i ]->tag;

                     if( $this->tagOrder( $lastTag, $field->tag ) <= 0 ) {

                         #print "Append {$field->tag} after $lastTag \n";


                         break;

                     }

                     #print "Do not {$field->tag} after $lastTag \n";


                 }

                 $appendAfter = $i;

             }

         } else { $appendAfter = -1; }

 

         array_splice( $this->fields, $appendAfter+1, 0, array( $field ) );

     }

 

     function removeField( $field ) {

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

             if( $v === $field ) unset( $this->fields[$k] );

         }

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

     }

 

     function delFields( $tag ) {

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

             if( $v->tag === $tag ) unset( $this->fields[$k] );

         }

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

     }

 

     function getFields( $tag ) {

         $ret = array();

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

             if( $v->tag === $tag ) $ret[] = $v;

         }

         return $ret;

     }

 

     function getTagPattern( $patt ) {

         $ret = array();

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

             if( preg_match("/$patt/", $v->tag ) ) $ret[] = $v;

         }

         return $ret;

     }

 

     ############################################################


     ##


     ##  Export as binary


     ##


 

     public function AsBinaryString( ) {

         // We now ignore the leader as much as possible


         $indicatorLength = $this->indicatorLength; // advisory, we will write corrupt files if requested


         $identifierLength = $this->identifierLength; // advisory


         $lengthOfLengthOfField = $this->checkString( "Length of Length-Of-Field portion of directory entry", false, $this->leader, 20, 1, $this->defaults["lengthOfLengthOfField"] );

         $lengthOfStartingCharacterPosition = $this->checkString( "Length of Starting-Character-Position portion of directory entry", false, $this->leader, 21, 1, $this->defaults["lengthOfStartingCharacterPosition"] );

         $lengthOfImplementationDefined = $this->checkString( "Length of Implementation-Defined portion of directory entry", false, $this->leader, 22, 1, $this->defaults["lengthOfImplementationDefined"] );

         $lengthOfDirectoryEntry = 3 + $lengthOfLengthOfField + $lengthOfStartingCharacterPosition + $lengthOfImplementationDefined;

 

         $directory = "";

         $data = "";

         $baseAddressOfData = 24 + $lengthOfDirectoryEntry * count( $this->fields ) + 1;

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

             $tag = $v->tag;

             $start = strlen( $data );

             $data .= $v->indicators;

             foreach( $v->subfields as $vv ) {

                 $data .= ISO2709::SubfieldInitiator . $vv->identifier . $vv->data;

             }

             $data .= $v->data;

             $data .= ISO2709::FieldTerminator;

             $length = strlen($data) - $start;

             $impdef = $v->directoryEntry[3];

             $directory .= sprintf(

                 "%3.3s" .

                 "%0{$lengthOfLengthOfField}.{$lengthOfLengthOfField}d" .

                 "%0{$lengthOfStartingCharacterPosition}.{$lengthOfStartingCharacterPosition}d" .

                 "%{$lengthOfImplementationDefined}.{$lengthOfImplementationDefined}s",

                 $tag, $length, $start, $impdef );

         }

         $directory .= ISO2709::FieldTerminator;

         $data .= ISO2709::RecordTerminator;

         $recordLength = $baseAddressOfData + strlen($data);

         $leader = sprintf("%05.5d%1.1s%4.4s%1.1d%1.1d%05.5d%3.3s%1.1d%1.1d%1.1d%1.1s",

             $recordLength, substr( $this->leader, 5, 1 ),

                         substr( $this->leader, 6, 4), $indicatorLength,

                         $identifierLength, $baseAddressOfData, substr( $this->leader, 17, 3 ),

                         $lengthOfLengthOfField,

                         $lengthOfStartingCharacterPosition,

                         $lengthOfImplementationDefined, substr( $this->leader, 23, 1 ) );

         $this->leader = $leader;

         $ret = $leader . $directory . $data;

         assert( strlen( $leader ) + strlen( $directory ) === $baseAddressOfData );

         assert( strlen( $ret ) === $recordLength );

         return $ret;

     }

 

     ############################################################


     ##


     ##  Export as Mnemonic string


     ##


 

 

     public function AsMnemonicString( 

         $leader_tag = "LDR", 

         $field_initiator = "=",

         $tag_terminator = "  ",

         $identifier_initiator = "\$", 

         $field_terminator = "\r\n", 

         $record_terminator = "\r\n",

         $space_replacer = " "


     ) {

         $ret = array();

         $ret[] = sprintf( "%s%3.3s%s%s%s%s%s", $field_initiator, $leader_tag,

                 $tag_terminator, "", "", $this->leader, $field_terminator );

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

             $ret[] = $v->AsMnemonicString( $field_initiator,$tag_terminator,$identifier_initiator,$field_terminator, $space_replacer );

         }

         foreach( $this->exceptions as $v ) {

             $ret[] = sprintf( "%s%3.3s%s%s%s%s%s", $field_initiator, "XXX",

                                 $tag_terminator, "xx", "\$x$v", "", $field_terminator );

         }

         return implode( $ret ) . $record_terminator;

     }

 }

 

 class ISO2709Field {

     public $tag, $data, $indicators, $subfields, $directoryEntry;

     function __construct( $tag, $data, $indicators = "", $subfields = array(), $directoryEntry = array(), $record = null ) {

         $this->tag=$tag;

         $this->data=$data;

         $this->indicators = $indicators;

         $this->directoryEntry = $directoryEntry;

         if( !isset( $this->directoryEntry[0] ) ) $this->directoryEntry[0] = $tag;

         if( !isset( $this->directoryEntry[3] ) ) $this->directoryEntry[3] = "";

         $this->record = $record;

         $this->subfields = array();

         foreach( $subfields as $v ) { $this->appendSubfield( $v ); }

     }

     function remove() {

         return $this->record->removeField( $this );

     }

     function delete() {

         return $this->record->removeField( $this );

     }

     function appendSubfield( $subfield, $arg2 = null ) {

         if( is_a( $subfield, "ISO2709Subfield" ) ) {

             $subfield->field = $this;

             $this->subfields[] = $subfield;

         } else {

             $this->appendSubfield( new ISO2709Subfield( $subfield, $arg2 ) );

         }

     }

 

     # maybe title more specific


     function insertSubfieldBefore( $identifier, $subfield, $arg3 = null) {

         if( is_a( $subfield, "ISO2709Subfield" ) ) {

             $found = false;

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

                 if( $v->identifier === $identifier ) {

                     array_splice($this->subfields,$k,0,array($subfield));

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

                     $found = true;

                     if( $k > 0 ) {

                         if (preg_match("/(.*?)( *[\:\/=] *)$/",$this->subfields[$k-1]->data,$m)) {

                             $this->subfields[$k-1]->data = $m[1];

                             $this->subfields[$k]->data .= $m[2];

                         }

                     }

                     break;

                 }

             }

             return $found;

         } else {

             return $this->insertSubfieldBefore( $identifier, new ISO2709Subfield( $subfield, $arg3 ) );

         }

     }

     

     function removeSubfield( \ISO2709Subfield $subfield ) {

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

             if( $v === $subfield ) unset( $this->subfields[$k] );

         }

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

     }

     function getOneSubfield( $identifier ) {

         foreach( $this->subfields as $v ) {

             if( $v->identifier === $identifier ) return $v;

         }

         return false;

     }

     function getSubfields( $identifier ) {

         $ret = array();

         foreach( $this->subfields as $v ) {

             if( $v->identifier === $identifier ) $ret[] = $v;

         }

         return $ret;

     }

 

     public function AsMnemonicString( 

         $field_initiator = "=",

         $tag_terminator = "  ",

         $identifier_initiator = "\$", 

         $field_terminator = "\r\n", 

         $space_replacer = " "


     ) {

         $sub = "";

         foreach( $this->subfields as $vv ) {

             $sub .= $identifier_initiator . $vv->identifier . $vv->data;

         }

         $indicators = str_replace(" ",$space_replacer, $this->indicators );

         $data = str_replace(" ",$space_replacer, $this->data );

         return sprintf( "%s%3.3s%s%s%s%s%s", $field_initiator, $this->tag, 

             $tag_terminator, $indicators, $sub, $data, $field_terminator );

     }

 }

 

 class ISO2709Subfield {

     public $identifier, $data, $field;

     function __construct( $identifier, $data ) {

         $this->identifier = $identifier;

         $this->data = $data;

     }

     function remove() {

         return $this->field->removeSubfield( $this );

     }

     function delete() {

         return $this->field->removeSubfield( $this );

     }

 

     function prev() {

         $prev = null;

         foreach( $this->field->subfields as $vv ) {

             if ($vv == $this) {

                 return $prev;

             } else {

                 $prev = $vv;

             }

         }

     }

 

 }