NAME

DTA::CAB::Format::Registry - registry for DTA::CAB I/O formats

SYNOPSIS

use DTA::CAB::Format::Registry;

##========================================================================
## Constructors etc.

$reg = DTA::CAB::Format::Registry->new(%args);
$reg = $reg->clear();
$reg = $reg->refresh();
$reg = $reg->compile(%opts);
\%classReg = $reg->register(%classReg);

##========================================================================
## Methods: Access

\%classReg_or_undef = $reg->lookup(%opts);
$fmt = $reg->newFormat($class_or_short_or_suffix, %opts);

$class_or_undef = $reg->readerClass($class_or_short_or_suffix);
$class_or_undef = $reg->writerClass($class_or_short_or_suffix);
$fmt = $reg->newReader(%opts);
$fmt = $reg->newWriter(%opts);

$readerClass_or_undef = $CLASS_OR_OBJ->fileReaderClass($filename);
$readerClass_or_undef = $CLASS_OR_OBJ->fileWriterClass($filename);
\%classReg_or_undef = $reg->guessFilenameFormat($filename);

\%classReg_or_undef = $reg->short2reg($shortname);
\%classReg_or_undef = $reg->base2reg($basename);

DESCRIPTION

DTA::CAB::Format::Registry provides an object-oriented API for maintainence and easy access to a set of DTA::CAB::Format subclasses.

Constructors etc.

new

$reg = DTA::CAB::Format::Registry->new(%args);

%$obj, %args:

reg => [\%classReg, ...],               ##-- registered classes
short2reg => {$short=>\%classReg, ...}, ##-- short names to registry entries
base2reg  => {$base =>\%classReg, ...}, ##-- base names to registry entries

each \%classReg is a HASH-ref of the form:

name          => $basename,      ##-- basename for the class (package name)
short         => $shortname,     ##-- short name for the class (default = package name suffix, lower-cased)
readerClass   => $readerClass,   ##-- default: $base   ##-- NYI
writerClass   => $writerClass,   ##-- default: $base   ##-- NYI
filenameRegex => $regex,         ##-- filename regex for guessFilename()

See also "register".

refresh

$reg = $reg->clear();

Clears the registry.

refresh

$reg = $reg->refresh();

Re-registers all formats in $reg->{reg}.

compile

$reg = $reg->compile(%opts);

Adds the following keys to each registry item \%classReg:

reader => $readerObj,  ##-- = $classReg{readerClass}->new(%opts)
writer => $writerObj,  ##-- = $classReg{writerClass}->new(%opts)

register

\%classReg = $reg->register(%classReg);

%classReg:

name          => $basename,      ##-- basename for the class (package name): REQUIRED
short         => $shortname,     ##-- short name for the class (default = package name suffix, lower-cased)
readerClass   => $readerClass,   ##-- default: $base   ##-- NYI
writerClass   => $writerClass,   ##-- default: $base   ##-- NYI
filenameRegex => $regex,         ##-- filename regex for guessFilenameFormat()

Methods: Access

lookup

\%classReg_or_undef = $reg->lookup(%opts);

Get the most recently registered entry for %opts, which may contain (in order of decreasing priority):

class => $class,      ##-- short name, basename, or "DTA::CAB::Format::" suffix
file  => $filename,   ##-- attempt to guess format from $filename

newFormat

$fmt = $reg->newFormat($class_or_short_or_suffix, %opts);

Creates a new format of the registered base class matching $class_or_short_or_suffix; backwards-compatible.

readerClass

$class_or_undef = $reg->readerClass($class_or_short_or_suffix);

Get registered reader class for $class_or_short_or_suffix

writerClass

$class_or_undef = $reg->writerClass($class_or_short_or_suffix);

Get registered writer class for $class_or_short_or_suffix

newReader

$fmt = $reg->newReader(%opts);

Create and return a new reader object. %opts may contain any %lookup options (class,file), and are otherwise passed to READERCLASS->new()

newWriter

$fmt = $reg->newWriter(%opts);

Create and return a new writer object. %opts may contain any %lookup options (class,file), and are otherwise passed to WRITERCLASS->new().

fileReaderClass

$readerClass_or_undef = $CLASS_OR_OBJ->fileReaderClass($filename);

Backkwards-compatible wrapper for lookup(); attempts to guess reader class name from $filename.

fileWriterClass

$readerClass_or_undef = $CLASS_OR_OBJ->fileWriterClass($filename);

Backwards-compatible wrapper for lookup(); attempts to guess writer class name from $filename.

guessFilenameFormat

\%classReg_or_undef = $reg->guessFilenameFormat($filename);

Backwards-compatible wrapper for $reg->lookup(file=>$filename).

short2reg

\%classReg_or_undef = $reg->short2reg($shortname);

Gets registry entry for short name $shortname.

base2reg

\%classReg_or_undef = $reg->base2reg($basename);

Gets registry entry for class basename $basename.

AUTHOR

Bryan Jurish <moocow@cpan.org>

COPYRIGHT AND LICENSE

Copyright (C) 2011-2019 by Bryan Jurish

This package is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.24.1 or, at your option, any later version of Perl 5 you may have available.

SEE ALSO

dta-cab-convert.perl(1), DTA::CAB::Format(3pm), DTA::CAB(3pm), perl(1), ...