use strict;
use XML::Twig;
-use Equinox::Migration::SubfieldMapper 1.003;
-
-# FIXME
-#
-# sample functionality should be extracted into a new module which
-# uses E::M::SM to drive sampling of individual datafields, and
-# reports ALL datafields which occur
-#
-# --sample should give the list of all datafields
-# --samplefile should take a SM map as teh argument and introspect the mapped datafields
+use Equinox::Migration::SubfieldMapper 1.004;
=head1 NAME
=head1 VERSION
-Version 1.000
+Version 1.001
=cut
-our $VERSION = '1.000';
+our $VERSION = '1.001';
=head1 SYNOPSIS
# get the next record and wipe current parsed record
return 0 unless defined $self->{data}{recs}[ $self->{data}{rptr} ];
my $record = $self->{data}{recs}[ $self->{data}{rptr} ];
- $self->{data}{crec} = { egid => undef, bib => undef, tags => undef };
+ $self->{data}{crec} = { egid => undef, tags => undef };
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;
}
if ($map->has($tag)) {
push @{$crec->{tags}}, { tag => $tag, uni => undef, multi => undef };
+ 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};
+ }
}
}
# 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;
- # handle modifiers
+ # test filters
+ for my $filter ( @{$map->filters($field)} ) {
+ return if ($sub->text =~ /$filter/i);
+ }
+ # 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;
}
}
+ # if this were a multi field, it would be handled already. make sure its a singleton
die "Multiple occurances of a non-multi field: $tag$code at rec ",
($self->{data}{rptr} + 1),"\n" if (defined $dataf->{uni}{$code});
+
+ # everything seems okay
$dataf->{uni}{$code} = $sub->text;
}
for my $code (@{$mods->{required}{$tag_id}}) {
my $found = 0;
- $found = 1 if ($crec->{bib}{($tag_id . $code)});
for my $tag (@{$crec->{tags}}) {
$found = 1 if ($tag->{multi}{($tag_id . $code)});
$found = 1 if ($tag->{uni}{$code});
}
+=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
A mapping which is not flagged as C<multi>, but which occurs more than
once per datafield will cause a fatal error.
-=head2 bib
-
-The C<bib> modifier declares that a mapping is "bib-level", and should
-be encountered once per B<record> instead of once per B<datafield> --
-which is another way of saying that it occurs in a non-repeating
-datafield or in a controlfield.
-
=head2 required
-By default, if a mapping does not occur in a datafield (or record, in
-the case of C<bib> mappings), processing continues normally. if a
-mapping has the C<required> modifier, however, it must appear, or a
-fatal error will occur.
+By default, if a mapping does not occur in a datafield, processing
+continues normally. if a mapping has the C<required> modifier,
+however, it must appear, or a fatal error will occur.
=head1 PARSED RECORDS
Then C<$rec> will look like:
{
- egid => evergreen_record_id,
- bib => {
- (tag_id . sub_code)1 => value1,
- (tag_id . sub_code)2 => value2,
- ...
- },
+ egid => evergreen_record_id,
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, a C<bib> key which points to a hashref, and a C<tags>
-key which points to an arrayref.
-
-=head3 C<bib>
-
-A reference to a hash which holds extracted data which occurs only
-once per record (and is therefore "bib-level"; the default assumption
-is that a tag/subfield pair can occur multiple times per record). The
-keys are composed of tag id and subfield code, catenated
-(e.g. 901c). The values are the contents of that subfield of that tag.
-
-If there are no tags defined as bib-level in the mapfile, C<bib> will
-be C<undef>.
+that record, a C<tags> key which points to an arrayref, and a C<tmap>
+key which points to a hashref.
=head3 C<tags>
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>.
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
projects / migration-tools.git / blobdiff