multi hash now uses just code for key

[migration-tools.git] / Equinox-Migration / lib / Equinox / Migration / MapDrivenMARCXMLProc.pm

diff --git a/Equinox-Migration/lib/Equinox/Migration/MapDrivenMARCXMLProc.pm b/Equinox-Migration/lib/Equinox/Migration/MapDrivenMARCXMLProc.pm
index 805d70c..75424ff 100644 (file)
--- a/Equinox-Migration/lib/Equinox/Migration/MapDrivenMARCXMLProc.pm
+++ b/Equinox-Migration/lib/Equinox/Migration/MapDrivenMARCXMLProc.pm
@@ -4,7 +4,7 @@ use warnings;
 use strict;
 
 use XML::Twig;
-use Equinox::Migration::SubfieldMapper 1.003;
+use Equinox::Migration::SubfieldMapper 1.004;
 
 
 =head1 NAME
@@ -13,11 +13,11 @@ Equinox::Migration::MapDrivenMARCXMLProc
 
 =head1 VERSION
 
-Version 1.000
+Version 1.001
 
 =cut
 
-our $VERSION = '1.000';
+our $VERSION = '1.001';
 
 
 =head1 SYNOPSIS
@@ -51,7 +51,6 @@ sub new {
                        data => { recs => undef, # X::T record objects
                                  rptr => 0,     # next record pointer
                                  crec => undef, # parsed record storage
-                                 tmap => undef, # tag_id-to-tag array map
                                },
                      }, $class;
 
@@ -96,11 +95,10 @@ sub parse_record {
     return 0 unless defined $self->{data}{recs}[ $self->{data}{rptr} ];
     my $record = $self->{data}{recs}[ $self->{data}{rptr} ];
     $self->{data}{crec} = { egid => undef, tags => undef };
-    $self->{data}{tmap} = {};
 
     my @fields = $record->children;
     for my $f (@fields)
-      { $self->process_field($f) }
+      { $self->process_field($f); $f->purge; }
 
     # cleanup memory and increment pointer
     $record->purge;
@@ -117,7 +115,6 @@ sub process_field {
     my $map = $self->{map};
     my $tag = $field->{'att'}->{'tag'};
     my $crec = $self->{data}{crec};
-    my $tmap = $self->{data}{tmap};
 
     # leader
     unless (defined $tag) {
@@ -133,17 +130,22 @@ sub process_field {
     }
     if ($map->has($tag)) {
         push @{$crec->{tags}}, { tag => $tag, uni => undef, multi => undef };
-        push @{$tmap->{$tag}}, (@{$crec->{tags}} - 1);
+        push @{$crec->{tmap}{$tag}}, (@{$crec->{tags}} - 1);
         my @subs = $field->children('subfield');
         for my $sub (@subs)
-          { $self->process_subs($tag, $sub) }
-        # check map to ensure all declared subs have a value
+          { $self->process_subs($tag, $sub); $sub->purge; }
+
+        # check map to ensure all declared tags and subs have a value
         my $mods = $map->mods($field);
         for my $mappedsub ( @{ $map->subfields($tag) } ) {
             next if $mods->{multi};
             $crec->{tags}[-1]{uni}{$mappedsub} = ''
               unless defined $crec->{tags}[-1]{uni}{$mappedsub};
         }
+        for my $mappedtag ( @{ $map->tags }) {
+            $crec->{tmap}{$mappedtag} = undef
+              unless defined $crec->{tmap}{$mappedtag};
+        }
     }
 }
 
@@ -158,6 +160,7 @@ sub process_subs {
     # fetch our datafield struct and fieldname
     my $dataf = $self->{data}{crec}{tags}[-1];
     my $field = $map->field($tag, $code);
+    $self->{data}{crec}{names}{$tag}{$code} = $field;
 
     # test filters
     for my $filter ( @{$map->filters($field)} ) {
@@ -166,8 +169,7 @@ sub process_subs {
     # handle multi modifier
     if (my $mods = $map->mods($field)) {
         if ($mods->{multi}) {
-            my $name = $tag . $code;
-            push @{$dataf->{multi}{$name}}, $sub->text;
+            push @{$dataf->{multi}{$code}}, $sub->text;
             return;
         }
     }
@@ -202,6 +204,24 @@ sub check_required {
 
 }
 
+=head2 recno
+
+Returns current record number (starting from zero)
+
+=cut
+
+sub recno { my ($self) = @_; return $self->{data}{rptr} }
+
+=head2 name
+
+Returns mapped fieldname when pass a tag and code
+
+    my $name = $m->name(999,'a');
+
+=cut
+
+sub name { my ($self, $t, $c) = @_; return $self->{data}{crec}{names}{$t}{$c} };
+
 =head1 MODIFIERS
 
 MapDrivenMARCXMLProc implements the following modifiers, and passes
@@ -240,15 +260,17 @@ Then C<$rec> will look like:
       tags => [
                 {
                   tag   => tag_id,
-                  multi => { (tag_id . sub_code) => [ val1, val2, ... ] },
+                  multi => { code => [ val1, val2, ... ] },
                   uni   => { code => value, code2 => value2, ... },
                 },
                 ...
-              ]
+              ],
+      tmap => { tag_id => [ INDEX_LIST ], tag_id2 => [ INDEX_LIST ], ... }
     }
 
 That is, there is an C<egid> key which points to the Evergreen ID of
-that record, and a C<tags> key which points to an arrayref.
+that record, a C<tags> key which points to an arrayref, and a C<tmap>
+key which points to a hashref.
 
 =head3 C<tags>
 
@@ -259,9 +281,8 @@ Each tag hash holds its own id (e.g. C<998>), and two references to
 two more hashrefs, C<multi> and C<uni>.
 
 The C<multi> hash holds the extracted data for tag/sub mappings which
-have the C<multiple> modifier on them. The keys in C<multi> are
-composed of the tag id and subfield code, catenated
-(e.g. C<901c>). The values are arrayrefs containing the content of all
+have the C<multiple> modifier on them. The keys in C<multi> subfield
+codes.  The values are arrayrefs containing the content of all
 instances of that subfield in that instance of that tag. If no tags
 are defined as C<multi>, it will be C<undef>.
 
@@ -276,6 +297,22 @@ datafield will be given a value of '' (the null string) in the current
 record struct. Oppose subfields which are not mapped, which will be
 C<undef>.
 
+=head3 tmap
+
+A hashref, where each key (a tag id like "650") points to a listref
+containing the index (or indices) of C<tags> where that tag has
+extracted data.
+
+The intended use of this is to simplify the processing of data from
+tags which can appear more than once in a MARC record, like
+holdings. If your holdings data is in 852, C<tmap->{852}> will be a
+listref with the indices of C<tags> which hold the data from the 852
+datafields.
+
+Complimentarily, C<tmap> prevents data from singular datafields from
+having to be copied for every instance of a multiple datafield, as it
+lets you get the data from that record's one instance of whichever
+field you're looking for.
 
 =head1 AUTHOR