]>
Dogcows Code - chaz/p5-CGI-Ex/blob - Ex/Conf.pm
5 CGI::Ex::Conf - Conf Reader/Writer for many different data format types
9 ###----------------------------------------------------------------###
10 # Copyright 2007 - Paul Seamons #
11 # Distributed under the Perl Artistic License without warranty #
12 ###----------------------------------------------------------------###
15 use base
qw(Exporter);
30 @EXPORT_OK = qw(conf_read conf_write in_cache);
34 $DEFAULT_EXT = 'conf';
36 %EXT_READERS = ('' => \
&read_handler_yaml
,
37 'conf' => \
&read_handler_yaml
,
38 'json' => \
&read_handler_json
,
39 'val_json' => \
&read_handler_json
,
40 'ini' => \
&read_handler_ini
,
41 'pl' => \
&read_handler_pl
,
42 'sto' => \
&read_handler_storable
,
43 'storable' => \
&read_handler_storable
,
44 'val' => \
&read_handler_yaml
,
45 'xml' => \
&read_handler_xml
,
46 'yaml' => \
&read_handler_yaml
,
47 'yml' => \
&read_handler_yaml
,
48 'html' => \
&read_handler_html
,
49 'htm' => \
&read_handler_html
,
52 %EXT_WRITERS = ('' => \
&write_handler_yaml
,
53 'conf' => \
&write_handler_yaml
,
54 'ini' => \
&write_handler_ini
,
55 'json' => \
&write_handler_json
,
56 'val_json' => \
&write_handler_json
,
57 'pl' => \
&write_handler_pl
,
58 'sto' => \
&write_handler_storable
,
59 'storable' => \
&write_handler_storable
,
60 'val' => \
&write_handler_yaml
,
61 'xml' => \
&write_handler_xml
,
62 'yaml' => \
&write_handler_yaml
,
63 'yml' => \
&write_handler_yaml
,
64 'html' => \
&write_handler_html
,
65 'htm' => \
&write_handler_html
,
68 ### $DIRECTIVE controls how files are looked for when namespaces are not absolute.
69 ### If directories 1, 2 and 3 are passed and each has a config file
70 ### LAST would return 3, FIRST would return 1, and MERGE will
71 ### try to put them all together. Merge behavior of hashes
72 ### is determined by $IMMUTABLE_\w+ variables.
73 $DIRECTIVE = 'LAST'; # LAST, MERGE, FIRST
75 $IMMUTABLE_QR = qr/_immu(?:table)?$/i;
77 $IMMUTABLE_KEY = 'immutable';
79 ###----------------------------------------------------------------###
82 my $class = shift || __PACKAGE__
;
83 my $args = shift || {};
85 return bless {%$args}, $class;
90 return $self->{paths
} ||= \
@DEFAULT_PATHS;
93 ###----------------------------------------------------------------###
97 my $args = shift || {};
100 ### they passed the right stuff already
102 if (UNIVERSAL
::isa
($file, 'SCALAR')) {
103 if ($$file =~ /^\s*</) {
104 return html_parse_yaml_load
($$file, $args); # allow for ref to a YAML string
106 return yaml_load
($$file); # allow for ref to a YAML string
112 ### allow for a pre-cached reference
113 } elsif (exists $CACHE{$file} && ! $args->{no_cache
}) {
114 return $CACHE{$file};
116 ### if contains a newline - treat it as a YAML string
117 } elsif (index($file,"\n") != -1) {
118 return yaml_load
($file);
120 ### otherwise base it off of the file extension
121 } elsif ($args->{file_type
}) {
122 $ext = $args->{file_type
};
123 } elsif ($file =~ /\.(\w+)$/) {
126 $ext = defined($args->{default_ext
}) ? $args->{default_ext
}
127 : defined($DEFAULT_EXT) ? $DEFAULT_EXT
129 $file = length($ext) ? "$file.$ext" : $file;
132 ### determine the handler
133 my $handler = $EXT_READERS{$ext} || croak
"Unknown file extension: $ext";
135 ### don't die if the file is not found - do die otherwise
137 eval { die "Conf file $file not found" };
138 warn "Conf file $file not found" if ! $args->{'no_warn_on_fail'} && ! $NO_WARN_ON_FAIL;
142 return eval { scalar $handler->($file, $args) } || die "Error while reading conf file $file\n$@";
148 my $args = shift || {};
149 return conf_read
($file, {%$self, %$args});
152 ### allow for different kinds of merging of arguments
153 ### allow for key fallback on hashes
154 ### allow for immutable values on hashes
157 my $namespace = shift;
158 my $args = shift || {};
159 my $REF = $args->{ref} || undef; # can pass in existing set of options
160 my $IMMUTABLE = $args->{immutable
} || {}; # can pass existing immutable types
162 $self = $self->new() if ! ref $self;
164 ### allow for fast short ciruit on path lookup for several cases
167 if (ref($namespace) # already a ref
168 || index($namespace,"\n") != -1 # yaml string to read in
169 || $namespace =~ m
|^\
.{0,2}/.+$| # absolute or relative file
171 push @paths, $namespace;
172 $directive = 'FIRST';
174 ### use the default directories
176 $directive = uc($args->{directive
} || $self->{directive
} || $DIRECTIVE);
177 $namespace =~ s
|::|/|g
; # allow perlish style namespace
178 my $paths = $args->{paths
} || $self->paths
179 || croak
"No paths found during read on $namespace";
180 $paths = [$paths] if ! ref $paths;
181 if ($directive eq 'LAST') { # LAST shall be FIRST
182 $directive = 'FIRST';
183 $paths = [reverse @$paths] if $#$paths != 0;
185 foreach my $path (@$paths) {
186 next if exists $CACHE{$path} && ! $CACHE{$path};
187 push @paths, "$path/$namespace";
191 ### make sure we have at least one path
193 croak
"Couldn't find a path for namespace $namespace. Perhaps you need to pass paths => \@paths";
196 ### now loop looking for a ref
197 foreach my $path (@paths) {
198 my $ref = $self->read_ref($path, $args) || next;
200 if (UNIVERSAL
::isa
($ref, 'ARRAY')) {
202 } elsif (UNIVERSAL
::isa
($ref, 'HASH')) {
205 croak
"Unknown config type of \"".ref($ref)."\" for namespace $namespace";
207 } elsif (! UNIVERSAL
::isa
($ref, ref($REF))) {
208 croak
"Found different reference types for namespace $namespace"
209 . " - wanted a type ".ref($REF);
211 if (ref($REF) eq 'ARRAY') {
212 if ($directive eq 'MERGE') {
216 splice @$REF, 0, $#$REF + 1, @$ref;
219 my $immutable = delete $ref->{$IMMUTABLE_KEY};
221 if ($directive eq 'MERGE') {
222 while (($key,$val) = each %$ref) {
223 next if $IMMUTABLE->{$key};
224 my $immute = $key =~ s/$IMMUTABLE_QR//o;
225 $IMMUTABLE->{$key} = 1 if $immute || $immutable;
230 delete $REF->{$key} while $key = each %$REF;
231 while (($key,$val) = each %$ref) {
232 my $immute = $key =~ s/$IMMUTABLE_QR//o;
233 $IMMUTABLE->{$key} = 1 if $immute || $immutable;
239 $REF->{"Immutable Keys"} = $IMMUTABLE if scalar keys %$IMMUTABLE;
243 ###----------------------------------------------------------------###
245 sub read_handler_ini
{
247 require Config
::IniHash
;
248 return Config
::IniHash
::ReadINI
($file);
251 sub read_handler_pl
{
253 ### do has odd behavior in that it turns a simple hashref
254 ### into hash - help it out a little bit
256 return ($#ref != 0) ? {@ref} : $ref[0];
259 sub read_handler_json
{
262 open (IN
, $file) || die "Couldn't open $file: $!";
263 CORE
::read(IN
, my $text, -s
$file);
265 return scalar JSON
::jsonToObj
($text);
268 sub read_handler_storable
{
271 return Storable
::retrieve
($file);
274 sub read_handler_yaml
{
277 open (IN
, $file) || die "Couldn't open $file: $!";
278 CORE
::read(IN
, my $text, -s
$file);
280 return yaml_load
($text);
286 my @ret = eval { YAML
::Load
($text) };
290 return ($#ret == 0) ? $ret[0] : \
@ret;
293 sub read_handler_xml
{
296 return XML
::Simple
::XMLin
($file);
299 ### this handler will only function if a html_key (such as validation)
300 ### is specified - actually this somewhat specific to validation - but
301 ### I left it as a general use for other types
304 sub read_handler_html
{
307 if (! eval { require YAML
}) {
311 while (my($pkg, $file, $line, $sub) = caller($i++)) {
312 return undef if $sub =~ /\bpreload_files$/;
319 open (IN
, $file) || return undef;
320 CORE
::read(IN
, my $html, -s
$file);
323 return html_parse_yaml_load
($html, $args);
326 sub html_parse_yaml_load
{
328 my $args = shift || {};
329 my $key = $args->{html_key
} || $HTML_KEY;
330 return undef if ! $key || $key !~ /^\w+$/;
335 (document\
. # global javascript
336 | var\s
+ # local javascript
337 | <\w
+\s
+[^>]*?) # input, form, select, textarea tag
339 \s
*=\s
* # an equals sign
340 ([\"\']) # open quote
341 (.+?[^\\]) # something in between
344 my ($line, $quot, $yaml) = ($1, $2, $3);
345 if ($line =~ /^(document\.|var\s)/) { # js variable
346 $yaml =~ s/\\$quot/$quot/g;
347 $yaml =~ s/\\n\\\n?/\n/g;
348 $yaml =~ s/\\\\/\\/g;
349 $yaml =~ s/\s*$/\n/s; # fix trailing newline
350 $str = $yaml; # use last one found
351 } else { # inline attributes
352 $yaml =~ s/\s*$/\n/s; # fix trailing newline
353 if ($line =~ m/<form/i) {
354 $yaml =~ s/^\Q$1\E//m if $yaml =~ m/^( +)/s;
357 } elsif ($line =~ m/\bname\s*=\s*('[^\']*'|"[^\"]*"|\S+)/) {
360 $yaml =~ s/^/ /mg; # indent entire thing
361 $yaml =~ s/^(\ *[^\s&*\{\[])/\n$1/; # add first newline
362 $str .= "$key:$yaml";
366 $str .= "group order: [".join(", ",@order)."]\n"
367 if $str && $#order != -1 && $key eq 'validation';
369 return undef if ! $str;
370 my $ref = eval { yaml_load
($str) };
373 if ($err =~ /line:\s+(\d+)/) {
375 while ($str =~ m/(.+)/gm) {
377 $err .= "LINE = \"$1\"\n";
386 ###----------------------------------------------------------------###
390 my $conf = shift || croak
"Missing conf";
391 my $args = shift || {};
395 croak
"Invalid filename for write: $file";
397 } elsif (index($file,"\n") != -1) {
398 croak
"Cannot use a yaml string as a filename during write";
400 ### allow for a pre-cached reference
401 } elsif (exists $CACHE{$file} && ! $args->{no_cache
}) {
402 warn "Cannot write back to a file that is in the cache";
405 ### otherwise base it off of the file extension
406 } elsif ($args->{file_type
}) {
407 $ext = $args->{file_type
};
408 } elsif ($file =~ /\.(\w+)$/) {
411 $ext = defined($args->{default_ext
}) ? $args->{default_ext
}
412 : defined($DEFAULT_EXT) ? $DEFAULT_EXT
414 $file = length($ext) ? "$file.$ext" : $file;
417 ### determine the handler
419 if ($args->{handler
}) {
420 $handler = (UNIVERSAL
::isa
($args->{handler
},'CODE'))
421 ? $args->{handler
} : $args->{handler
}->{$ext};
424 $handler = $EXT_WRITERS{$ext} || croak
"Unknown file extension: $ext";
427 return eval { scalar $handler->($file, $conf, $args) } || die "Error while writing conf file $file\n$@";
434 my $args = shift || {};
435 conf_write
($file, $conf, {%$self, %$args});
438 ### Allow for writing out conf values
439 ### Allow for writing out the correct filename (if there is a path array)
440 ### Allow for not writing out immutable values on hashes
443 my $namespace = shift;
444 my $conf = shift || croak
"Must pass hashref to write out"; # the info to write
445 my $args = shift || {};
446 my $IMMUTABLE = $args->{immutable
} || {}; # can pass existing immutable types
448 $self = $self->new() if ! ref $self;
450 ### allow for fast short ciruit on path lookup for several cases
453 if (ref($namespace) # already a ref
454 || $namespace =~ m
|^\
.{0,2}/.+$| # absolute or relative file
456 push @paths, $namespace;
457 $directive = 'FIRST';
459 } elsif (index($namespace,"\n") != -1) { # yaml string - can't write that
460 croak
"Cannot use a yaml string as a namespace for write";
462 ### use the default directories
464 $directive = uc($args->{directive
} || $self->{directive
} || $DIRECTIVE);
465 $namespace =~ s
|::|/|g
; # allow perlish style namespace
466 my $paths = $args->{paths
} || $self->paths
467 || croak
"No paths found during write on $namespace";
468 $paths = [$paths] if ! ref $paths;
469 if ($directive eq 'LAST') { # LAST shall be FIRST
470 $directive = 'FIRST';
471 $paths = [reverse @$paths] if $#$paths != 0;
473 foreach my $path (@$paths) {
474 next if exists $CACHE{$path} && ! $CACHE{$path};
475 push @paths, "$path/$namespace";
479 ### make sure we have at least one path
481 croak
"Couldn't find a path for namespace $namespace. Perhaps you need to pass paths => \@paths";
485 if ($directive eq 'FIRST') {
487 } elsif ($directive eq 'LAST' || $directive eq 'MERGE') {
490 croak
"Unknown directive ($directive) during write of $namespace";
493 ### remove immutable items (if any)
494 if (UNIVERSAL
::isa
($conf, 'HASH') && $conf->{"Immutable Keys"}) {
495 $conf = {%$conf}; # copy the values - only for immutable
496 my $IMMUTABLE = delete $conf->{"Immutable Keys"};
497 foreach my $key (keys %$IMMUTABLE) {
498 delete $conf->{$key};
502 ### finally write it out
503 $self->write_ref($path, $conf);
508 ###----------------------------------------------------------------###
510 sub write_handler_ini
{
513 require Config
::IniHash
;
514 return Config
::IniHash
::WriteINI
($file, $ref);
517 sub write_handler_pl
{
520 ### do has odd behavior in that it turns a simple hashref
521 ### into hash - help it out a little bit
522 require Data
::Dumper
;
523 local $Data::Dump
::Purity
= 1;
524 local $Data::Dumper
::Sortkeys
= 1;
525 local $Data::Dumper
::Quotekeys
= 0;
526 local $Data::Dumper
::Pad
= ' ';
527 local $Data::Dumper
::Varname
= 'VunderVar';
528 my $str = Data
::Dumper-
>Dumpperl([$ref]);
529 if ($str =~ s/^(.+?=\s*)//s) {
531 $str =~ s/^\s{1,$l}//mg;
533 if ($str =~ /\$VunderVar/) {
534 die "Ref to be written contained circular references - can't write";
538 open (OUT
, ">$file") || die $!;
543 sub write_handler_json
{
547 my $str = JSON
::objToJson
($ref, {pretty
=> 1, indent
=> 2});
549 open (OUT
, ">$file") || die $!;
554 sub write_handler_storable
{
558 return Storable
::store
($ref, $file);
561 sub write_handler_yaml
{
565 return YAML
::DumpFile
($file, $ref);
568 sub write_handler_xml
{
573 open (OUT
, ">$file") || die $!;
574 print OUT
scalar(XML
::Simple-
>new->XMLout($ref, noattr
=> 1));
578 sub write_handler_html
{
581 die "Write of conf information to html is not supported";
584 ###----------------------------------------------------------------###
588 my $paths = shift || $self->paths;
590 ### what extensions do we look for
592 if ($self->{'handler'}) {
593 if (UNIVERSAL
::isa
($self->{'handler'},'HASH')) {
594 %EXT = %{ $self->{'handler'} };
598 if (! $self->{'html_key'} && ! $HTML_KEY) {
599 delete $EXT{$_} foreach qw(html htm);
602 return if ! keys %EXT;
604 ### look in the paths for the files
605 foreach my $path (ref($paths) ? @$paths : $paths) {
608 next if exists $CACHE{$path};
610 my $ext = ($path =~ /\.(\w+)$/) ? $1 : '';
611 next if ! $EXT{$ext};
612 $CACHE{$path} = $self->read($path);
616 File
::Find
::find
(sub {
617 return if exists $CACHE{$File::Find
::name
};
618 return if $File::Find
::name
=~ m
|/CVS/|;
620 my $ext = (/\.(\w+)$/) ? $1 : '';
621 return if ! $EXT{$ext};
622 $CACHE{$File::Find
::name
} = $self->read($File::Find
::name
);
631 my ($self, $file) = (@_ == 2) ? @_ : (undef, shift());
632 return exists($CACHE{$file}) || 0;
635 ###----------------------------------------------------------------###
643 use CGI::Ex::Conf qw(conf_read conf_write);
645 my $hash = conf_read("/tmp/foo.yaml");
647 conf_write("/tmp/foo.yaml", {key1 => $val1, key2 => $val2});
652 my $cob = CGI::Ex::Conf->new;
654 my $full_path_to_file = "/tmp/foo.val"; # supports ini, sto, val, pl, xml
655 my $hash = $cob->read($file);
657 local $cob->{default_ext} = 'conf'; # default anyway
660 my @paths = qw(/tmp, /home/pauls);
661 local $cob->{paths} = \@paths;
662 my $hash = $cob->read('My::NameSpace');
663 # will look in /tmp/My/NameSpace.conf and /home/pauls/My/NameSpace.conf
666 my $hash = $cob->read('My::NameSpace', {paths => ['/tmp']});
667 # will look in /tmp/My/NameSpace.conf
670 local $cob->{directive} = 'MERGE';
671 my $hash = $cob->read('FooSpace');
673 my $hash = $cob->read('FooSpace', {directive => 'MERGE'});
674 # will return merged hashes from /tmp/FooSpace.conf and /home/pauls/FooSpace.conf
675 # immutable keys are preserved from originating files
678 local $cob->{directive} = 'FIRST';
679 my $hash = $cob->read('FooSpace');
680 # will return values from first found file in the path.
683 local $cob->{directive} = 'LAST'; # default behavior
684 my $hash = $cob->read('FooSpace');
685 # will return values from last found file in the path.
689 $cob->write('FooSpace'); # will write it out the changes
693 There are half a million Conf readers out there. Why not add one more.
694 Actually, this module provides a wrapper around the many file formats
695 and the config modules that can handle them. It does not introduce any
698 This module also provides a preload ability which is useful in conjunction
701 Oh - and it writes too.
709 Takes a file and optional argument hashref. Figures out the type
710 of handler to use to read the file, reads it and returns the ref.
711 If you don't need the extended merge functionality, or key fallback,
712 or immutable keys, or path lookup ability - then use this method.
713 Otherwise - use ->read.
717 First argument may be either a perl data structure, yaml string, a
718 full filename, or a file "namespace".
720 The second argument can be a hashref of override values (referred to
723 If the first argument is a perl data structure, it will be
724 copied one level deep and returned (nested structures will contain the
725 same references). A yaml string will be parsed and returned. A full
726 filename will be read using the appropriate handler and returned (a
727 file beginning with a / or ./ or ../ is considered to be a full
728 filename). A file "namespace" (ie "footer" or "my::config" or
729 "what/ever") will be turned into a filename by looking for that
730 namespace in the paths found either in $args->{paths} or in
731 $self->{paths} or in @DEFAULT_PATHS. @DEFAULT_PATHS is empty by
732 default as is $self->{paths} - read makes no attempt to guess what
733 directories to look in. If the namespace has no extension the
734 extension listed in $args->{default_ext} or $self->{default_ext} or
735 $DEFAULT_EXT will be used).
737 my $ref = $cob->read('My::NameSpace', {
738 paths => [qw(/tmp /usr/data)],
741 # would look first for /tmp/My/NameSpace.pl
742 # and then /usr/data/My/NameSpace.pl
744 my $ref = $cob->read('foo.sto', {
745 paths => [qw(/tmp /usr/data)],
748 # would look first for /tmp/foo.sto
749 # and then /usr/data/foo.sto
751 When a namespace is used and there are multiple possible paths, there
752 area a few options to control which file to look for. A directive of
753 'FIRST', 'MERGE', or 'LAST' may be specified in $args->{directive} or
754 $self->{directive} or the default value in $DIRECTIVE will be used
755 (default is 'LAST'). When 'FIRST' is specified the first path that
756 contains the namespace is returned. If 'LAST' is used, the last
757 found path that contains the namespace is returned. If 'MERGE' is
758 used, the data structures are joined together. If they are
759 arrayrefs, they are joined into one large arrayref. If they are
760 hashes, they are layered on top of each other with keys found in later
761 paths overwriting those found in earlier paths. This allows for
762 setting system defaults in a root file, and then allow users to have
765 It is possible to make keys in a root file be immutable (non
766 overwritable) by adding a suffix of _immutable or _immu to the key (ie
767 {foo_immutable => 'bar'}). If a value is found in the file that
768 matches $IMMUTABLE_KEY, the entire file is considered immutable.
769 The immutable defaults may be overriden using $IMMUTABLE_QR and $IMMUTABLE_KEY.
771 Errors during read die. If the file does not exist undef is returned.
775 Takes a file and the reference to be written. Figures out the type
776 of handler to use to write the file and writes it. If you used the ->read_ref
777 use this method. Otherwise, use ->write.
781 Allows for writing back out the information read in by ->read. If multiple
782 paths where used - the directive 'FIRST' will write the changes to the first
783 file in the path - otherwise the last path will be used. If ->read had found
784 immutable keys, then those keys are removed before writing.
786 Errors during write die.
788 =item C<preload_files>
790 Arguments are file(s) and/or directory(s) to preload. preload_files will
791 loop through the arguments, find the files that exist, read them in using
792 the handler which matches the files extension, and cache them by filename
793 in %CACHE. Directories are spidered for file extensions which match those
794 listed in %EXT_READERS. This is useful for a server environment where CPU
795 may be more precious than memory.
799 Allow for testing if a particular filename is registered in the %CACHE - typically
800 from a preload_files call. This is useful when building wrappers around the
801 conf_read and conf_write method calls.
811 Takes a filename. Returns the read contents of that filename. The handler
812 to use is based upon the extention on the file.
814 my $hash = conf_read('/tmp/foo.yaml');
816 my $hash = conf_read('/tmp/foo', {file_type => 'yaml'});
818 Takes a filename and a data structure. Writes the data to the filename. The handler
819 to use is based upon the extention on the file.
821 conf_write('/tmp/foo.yaml', \%hash);
823 conf_write('/tmp/foo', \%hash, {file_type => 'yaml'});
829 CGI::Ex::Conf supports the files found in %EXT_READERS by default.
830 Additional types may be added to %EXT_READERS, or a custom handler may be
831 passed via $args->{handler} or $self->{handler}. If the custom handler is
832 a code ref, all files will be passed to it. If it is a hashref, it should
833 contain keys which are extensions it supports, and values which read those
836 Some file types have benefits over others. Storable is very fast, but is
837 binary and not human readable. YAML is readable but very slow. I would
838 suggest using a readable format such as YAML and then using preload_files
839 to load in what you need at run time. All preloaded files are faster than
840 any of the other types.
842 The following is the list of handlers that ships with CGI::Ex::Conf (they
843 will only work if the supporting module is installed on your system):
849 Should be a file containing a perl structure which is the last thing returned.
851 =item C<sto> and C<storable>
853 Should be a file containing a structure stored in Storable format.
856 =item C<yaml> and C<conf> and C<val>
858 Should be a file containing a yaml document. Multiple documents are returned
859 as a single arrayref. Also - any file without an extension and custom handler
860 will be read using YAML. See L<YAML>.
864 Should be a windows style ini file. See L<Config::IniHash>
868 Should be an xml file. It will be read in by XMLin. See L<XML::Simple>.
872 Should be a json file. It will be read using the JSON library. See L<JSON>.
874 =item C<html> and C<htm>
876 This is actually a custom type intended for use with CGI::Ex::Validate.
877 The configuration to be read is actually validation that is stored
878 inline with the html. The handler will look for any form elements or
879 input elements with an attribute with the same name as in $HTML_KEY. It
880 will also look for a javascript variable by the same name as in $HTML_KEY.
881 All configuration items done this way should be written in YAML.
882 For example, if $HTML_KEY contained 'validation' it would find validation in:
884 <input type=text name=username validation="{required: 1}">
885 # automatically indented and "username:\n" prepended
887 <form name=foo validation="
888 general no_confirm: 1
892 document.validation = "\n\
893 username: {required: 1}\n\
898 var validation = "\n\
899 username: {required: 1}\n\
903 If the key $HTML_KEY is not set, the handler will always return undef
904 without even opening the file.
910 Make a similar write method that handles immutability.
914 This module may be distributed under the same terms as Perl itself.
918 Paul Seamons <perl at seamons dot com>
This page took 0.089925 seconds and 4 git commands to generate.