App-finddo
view release on metacpan or search on metacpan
script/_finddo view on Meta::CPAN
# }
# $res;
#}
#
#sub add_prefix {
# my ($self, $hash_key, $mode) = @_;
# die "Hash key not a string" if ref($hash_key);
# my $dis = $self->config->disable_modes;
# if (defined($dis) && ref($dis) ne 'ARRAY') {
# die "Invalid config value `disable_modes`: must be an array";
# }
# if ($dis && $self->_in($mode, $dis)) {
# $self->push_error("Can't add prefix for currently disabled mode `$mode`");
# return $hash_key;
# }
# my $mh = $self->modes->{$mode} or die "Unknown mode: $mode";
# $mh->add_prefix($hash_key);
#}
#
#sub remove_prefix {
# my ($self, $hash_key) = @_;
# die "Hash key not a string" if ref($hash_key);
# my $dis = $self->config->disable_modes;
# if (defined($dis) && ref($dis) ne 'ARRAY') {
# die "Invalid config value `disable_modes`: must be an array";
# }
# for my $mh (sort { $b->precedence_level <=> $a->precedence_level }
# grep { !$dis || !$self->_in($_->name, $dis) }
# values %{ $self->modes }) {
# if ($mh->check_prefix($hash_key)) {
# my $r = $mh->remove_prefix($hash_key);
# if (wantarray) { return ($r, $mh->name) }
# else { return $r }
# }
# }
# if (wantarray) { return ($hash_key, $self->config->default_mode) }
# else { return $hash_key }
#}
#
#sub remove_prefix_on_hash {
# my ($self, $hash) = @_;
# die "Not a hash" unless ref($hash) eq 'HASH';
# for (keys %$hash) {
# my $old = $_;
# $_ = $self->remove_prefix($_);
# next unless $old ne $_;
# die "Conflict when removing prefix on hash: $old -> $_ but $_ already exists"
# if exists $hash->{$_};
# $hash->{$_} = $hash->{$old};
# delete $hash->{$old};
# }
# $hash;
#}
#
#sub merge {
# my ($self, $l, $r) = @_;
# $self->path([]);
# $self->errors([]);
# $self->mem({});
# $self->cur_mem_key(undef);
# my ($key, $res, $backup) = $self->_merge(undef, $l, $r);
# {
# success => !@{ $self->errors },
# error => (@{ $self->errors } ?
# join(", ",
# map { sprintf("/%s: %s", join("/", @{ $_->[0] }), $_->[1]) }
# @{ $self->errors }) : ''),
# result => $res,
# backup => $backup,
# };
#}
#
#sub _process_todo {
# my ($self) = @_;
# if ($self->cur_mem_key) {
# for my $mk (keys %{ $self->mem }) {
# my $res = $self->mem->{$mk}{res};
# if (defined($res) && @{ $self->mem->{$mk}{todo} }) {
# for (@{ $self->mem->{$mk}{todo} }) {
# $_->(@$res);
# return if @{ $self->errors };
# }
# $self->mem->{$mk}{todo} = [];
# }
# }
# }
#}
#
#sub _merge {
# my ($self, $key, $l, $r, $mode) = @_;
# my $c = $self->config;
# $mode //= $c->default_mode;
#
# my $mh = $self->modes->{$mode};
# die "Can't find handler for mode $mode" unless $mh;
#
# my $rl = ref($l);
# my $rr = ref($r);
# my $tl = $rl eq 'HASH' ? 'HASH' : $rl eq 'ARRAY' ? 'ARRAY' : $rl eq 'CODE' ? 'CODE' : !$rl ? 'SCALAR' : '';
# my $tr = $rr eq 'HASH' ? 'HASH' : $rr eq 'ARRAY' ? 'ARRAY' : $rr eq 'CODE' ? 'CODE' : !$rr ? 'SCALAR' : '';
# if (!$tl) { $self->push_error("Unknown type in left side: $rl"); return }
# if (!$tr) { $self->push_error("Unknown type in right side: $rr"); return }
# if (!$c->allow_create_array && $tl ne 'ARRAY' && $tr eq 'ARRAY') {
# $self->push_error("Not allowed to create array"); return;
# }
# if (!$c->allow_create_hash && $tl ne 'HASH' && $tr eq 'HASH') {
# $self->push_error("Not allowed to create hash"); return;
# }
# if (!$c->allow_destroy_array && $tl eq 'ARRAY' && $tr ne 'ARRAY') {
# $self->push_error("Not allowed to destroy array"); return;
# }
# if (!$c->allow_destroy_hash && $tl eq 'HASH' && $tr ne 'HASH') {
# $self->push_error("Not allowed to destroy hash"); return;
# }
# my $meth = "merge_${tl}_${tr}";
# if (!$mh->can($meth)) { $self->push_error("No merge method found for $tl + $tr (mode $mode)"); return }
#
# my $memkey;
# if ($rl || $rr) {
# $memkey = sprintf "%s%s %s%s %s %s",
# (defined($l) ? ($rl ? 2 : 1) : 0),
# (defined($l) ? "$l" : ''),
# (defined($r) ? ($rr ? 2 : 1) : 0),
# (defined($r) ? "$r" : ''),
# $mode,
# $self->config;
# }
# if ($memkey) {
# if (exists $self->mem->{$memkey}) {
# $self->_process_todo;
# if (defined $self->mem->{$memkey}{res}) {
# return @{ $self->mem->{$memkey}{res} };
# } else {
# return ($key, undef, undef, 1);
# }
# } else {
# $self->mem->{$memkey} = {res=>undef, todo=>[]};
# $self->cur_mem_key($memkey);
# my ($newkey, $res, $backup) = $mh->$meth($key, $l, $r);
# $self->mem->{$memkey}{res} = [$newkey, $res, $backup];
# $self->_process_todo;
# return ($newkey, $res, $backup);
# }
# } else {
# $self->_process_todo;
# return $mh->$meth($key, $l, $r);
# }
#}
#
#sub _path_is_included {
# my ($self, $p1, $p2) = @_;
# my $res = 1;
# for my $i (0..@$p1-1) {
# do { $res = 0; last } if !defined($p2->[$i]) || $p1->[$i] ne $p2->[$i];
# }
# $res;
#}
#
#1;
#
#__END__
#
### Data/ModeMerge/Config.pm ###
#package Data::ModeMerge::Config;
#
#our $DATE = '2016-07-22';
#our $VERSION = '0.35';
#
#use 5.010;
#use Mo qw(build default);
#
#has recurse_hash => (is => 'rw', default => sub{1});
#has recurse_array => (is => 'rw', default => sub{0});
#has parse_prefix => (is => 'rw', default => sub{1});
#has wanted_path => (is => 'rw');
#has default_mode => (is => 'rw', default => sub{'NORMAL'});
#has disable_modes => (is => 'rw');
#has allow_create_array => (is => 'rw', default => sub{1});
#has allow_create_hash => (is => 'rw', default => sub{1});
#has allow_destroy_array => (is => 'rw', default => sub{1});
#has allow_destroy_hash => (is => 'rw', default => sub{1});
#has exclude_parse => (is => 'rw');
#has exclude_parse_regex => (is => 'rw');
#has include_parse => (is => 'rw');
#has include_parse_regex => (is => 'rw');
#has exclude_merge => (is => 'rw');
#has exclude_merge_regex => (is => 'rw');
#has include_merge => (is => 'rw');
#has include_merge_regex => (is => 'rw');
#has set_prefix => (is => 'rw');
#has readd_prefix => (is => 'rw', default => sub{1});
#has premerge_pair_filter => (is => 'rw');
#has options_key => (is => 'rw', default => sub{''});
#has allow_override => (is => 'rw');
#has disallow_override => (is => 'rw');
#
#sub _config_config {
# state $a = [qw/
# wanted_path
# options_key
# allow_override
# disallow_override
script/_finddo view on Meta::CPAN
#
#sub name {
# die "Subclass must provide name()";
#}
#
#sub precedence_level {
# die "Subclass must provide precedence_level()";
#}
#
#sub default_prefix {
# die "Subclass must provide default_prefix()";
#}
#
#sub default_prefix_re {
# die "Subclass must provide default_prefix_re()";
#}
#
#sub BUILD {
# my ($self) = @_;
# $self->prefix($self->default_prefix);
# $self->prefix_re($self->default_prefix_re);
#}
#
#sub check_prefix {
# my ($self, $hash_key) = @_;
# if ($self->check_prefix_sub) {
# $self->check_prefix_sub->($hash_key);
# } else {
# $hash_key =~ $self->prefix_re;
# }
#}
#
#sub add_prefix {
# my ($self, $hash_key) = @_;
# if ($self->add_prefix_sub) {
# $self->add_prefix_sub->($hash_key);
# } else {
# $self->prefix . $hash_key;
# }
#}
#
#sub remove_prefix {
# my ($self, $hash_key) = @_;
# if ($self->remove_prefix_sub) {
# $self->remove_prefix_sub->($hash_key);
# } else {
# my $re = $self->prefix_re;
# $hash_key =~ s/$re//;
# $hash_key;
# }
#}
#
#sub merge_ARRAY_ARRAY {
# my ($self, $key, $l, $r) = @_;
# my $mm = $self->merger;
# my $c = $mm->config;
# return $self->merge_SCALAR_SCALAR($key, $l, $r) unless $c->recurse_array;
# return if $c->wanted_path && !$mm->_path_is_included($mm->path, $c->wanted_path);
#
# my @res;
# my @backup;
# my $la = @$l;
# my $lb = @$r;
# push @{ $mm->path }, -1;
# for my $i (0..($la > $lb ? $la : $lb)-1) {
# $mm->path->[-1] = $i;
# if ($i < $la && $i < $lb) {
# push @backup, $l->[$i];
# my ($subnewkey, $subres, $subbackup, $is_circular) = $mm->_merge($i, $l->[$i], $r->[$i], $c->default_mode);
# last if @{ $mm->errors };
# if ($is_circular) {
# push @res, undef;
# push @{ $mm->mem->{ $mm->cur_mem_key }{todo} }, sub {
# my ($subnewkey, $subres, $subbackup) = @_;
# $res[$i] = $subres;
# }
# } else {
# push @res, $subres;
# }
# } elsif ($i < $la) {
# push @res, $l->[$i];
# } else {
# push @res, $r->[$i];
# }
# }
# pop @{ $mm->path };
# ($key, \@res, \@backup);
#}
#
#sub _prefilter_hash {
# my ($self, $h, $desc, $sub) = @_;
# my $mm = $self->merger;
#
# if (ref($sub) ne 'CODE') {
# $mm->push_error("$desc failed: filter must be a coderef");
# return;
# }
#
# my $res = {};
# for (keys %$h) {
# my @r = $sub->($_, $h->{$_});
# while (my ($k, $v) = splice @r, 0, 2) {
# next unless defined $k;
# if (exists $res->{$k}) {
# $mm->push_error("$desc failed; key conflict: ".
# "$_ -> $k, but key $k already exists");
# return;
# }
# $res->{$k} = $v;
# }
# }
#
# $res;
#}
#
#sub _gen_left {
# my ($self, $l, $mode, $esub, $ep, $ip, $epr, $ipr) = @_;
# my $mm = $self->merger;
# my $c = $mm->config;
#
#
# if ($c->premerge_pair_filter) {
# $l = $self->_prefilter_hash($l, "premerge filter left hash",
# $c->premerge_pair_filter);
# return if @{ $mm->errors };
# }
#
# my $hl = {};
# if ($c->parse_prefix) {
# for (keys %$l) {
# my $do_parse = 1;
# $do_parse = 0 if $do_parse && $ep && $mm->_in($_, $ep);
# $do_parse = 0 if $do_parse && $ip && !$mm->_in($_, $ip);
# $do_parse = 0 if $do_parse && $epr && /$epr/;
# $do_parse = 0 if $do_parse && $ipr && !/$ipr/;
#
# if ($do_parse) {
# my $old = $_;
# my $m2;
# ($_, $m2) = $mm->remove_prefix($_);
# next if $esub && !$esub->($_);
# if ($old ne $_ && exists($l->{$_})) {
# $mm->push_error("Conflict when removing prefix on left-side ".
# "hash key: $old -> $_ but $_ already exists");
# return;
# }
# $hl->{$_} = [$m2, $l->{$old}];
script/_finddo view on Meta::CPAN
# }
# }
#
# $hl;
#}
#
#sub _gen_right {
# my ($self, $r, $mode, $esub, $ep, $ip, $epr, $ipr) = @_;
# my $mm = $self->merger;
# my $c = $mm->config;
#
#
# if ($c->premerge_pair_filter) {
# $r = $self->_prefilter_hash($r, "premerge filter right hash",
# $c->premerge_pair_filter);
# return if @{ $mm->errors };
# }
#
# my $hr = {};
# if ($c->parse_prefix) {
# for (keys %$r) {
# my $do_parse = 1;
# $do_parse = 0 if $do_parse && $ep && $mm->_in($_, $ep);
# $do_parse = 0 if $do_parse && $ip && !$mm->_in($_, $ip);
# $do_parse = 0 if $do_parse && $epr && /$epr/;
# $do_parse = 0 if $do_parse && $ipr && !/$ipr/;
#
# if ($do_parse) {
# my $old = $_;
# my $m2;
# ($_, $m2) = $mm->remove_prefix($_);
# next if $esub && !$esub->($_);
# if (exists $hr->{$_}{$m2}) {
# $mm->push_error("Conflict when removing prefix on right-side ".
# "hash key: $old($m2) -> $_ ($m2) but $_ ($m2) ".
# "already exists");
# return;
# }
# $hr->{$_}{$m2} = $r->{$old};
# } else {
# next if $esub && !$esub->($_);
# $hr->{$_} = {$mode => $r->{$_}};
# }
# }
# } else {
# for (keys %$r) {
# next if $esub && !$esub->($_);
# $hr->{$_} = {$mode => $r->{$_}}
# }
# }
# $hr;
#}
#
#sub _merge_gen {
# my ($self, $hl, $hr, $mode, $em, $im, $emr, $imr) = @_;
# my $mm = $self->merger;
# my $c = $mm->config;
#
#
# my $res = {};
# my $backup = {};
#
# my %k = map {$_=>1} keys(%$hl), keys(%$hr);
# push @{ $mm->path }, "";
# K:
# for my $k (keys %k) {
# my @o;
# $mm->path->[-1] = $k;
# my $do_merge = 1;
# $do_merge = 0 if $do_merge && $em && $mm->_in($k, $em);
# $do_merge = 0 if $do_merge && $im && !$mm->_in($k, $im);
# $do_merge = 0 if $do_merge && $emr && $k =~ /$emr/;
# $do_merge = 0 if $do_merge && $imr && $k !~ /$imr/;
#
# if (!$do_merge) {
# $res->{$k} = $hl->{$k} if $hl->{$k};
# next K;
# }
#
# $backup->{$k} = $hl->{$k}[1] if $hl->{$k} && $hr->{$k};
# if ($hl->{$k}) {
# push @o, $hl->{$k};
# }
# if ($hr->{$k}) {
# my %m = map {$_=>$mm->modes->{$_}->precedence_level} keys %{ $hr->{$k} };
# push @o, map { [$_, $hr->{$k}{$_}] } sort { $m{$b} <=> $m{$a} } keys %m;
# }
# my $final_mode;
# my $is_circular;
# my $v;
# for my $i (0..$#o) {
# if ($i == 0) {
# my $mh = $mm->modes->{$o[$i][0]};
# if (@o == 1 &&
# (($hl->{$k} && $mh->can("merge_left_only")) ||
# ($hr->{$k} && $mh->can("merge_right_only")))) {
# my $meth = $hl->{$k} ? "merge_left_only" : "merge_right_only";
# my ($subnewkey, $v, $subbackup, $is_circular, $newmode) = $mh->$meth($k, $o[$i][1]);
# next K unless defined($subnewkey);
# $final_mode = $newmode;
# $v = $res;
# } else {
# $final_mode = $o[$i][0];
# $v = $o[$i][1];
# }
# } else {
# my $m = $mm->combine_rules->{"$final_mode+$o[$i][0]"}
# or do {
# $mm->push_error("Can't merge $final_mode + $o[$i][0]");
# return;
# };
# my ($subnewkey, $subbackup);
# ($subnewkey, $v, $subbackup, $is_circular) = $mm->_merge($k, $v, $o[$i][1], $m->[0]);
# return if @{ $mm->errors };
# if ($is_circular) {
# if ($i < $#o) {
# $mm->push_error("Can't handle circular at $i of $#o merges (mode $m->[0]): not the last merge");
# return;
# }
# push @{ $mm->mem->{ $mm->cur_mem_key }{todo} }, sub {
# my ($subnewkey, $subres, $subbackup) = @_;
# my $final_mode = $m->[1];
# $res->{$k} = [$m->[1], $subres];
# if ($c->readd_prefix) {
# $self->_readd_prefix($res, $k, $c->default_mode);
# } else {
# $res->{$k} = $res->{$k}[1];
# }
# };
# delete $res->{$k};
# }
# next K unless defined $subnewkey;
# $final_mode = $m->[1];
# }
# }
# $res->{$k} = [$final_mode, $v] unless $is_circular;
# }
# pop @{ $mm->path };
# ($res, $backup);
#}
#
#sub _readd_prefix {
# my ($self, $hh, $k, $defmode) = @_;
# my $mm = $self->merger;
# my $c = $mm->config;
#
# my $m = $hh->{$k}[0];
# if ($m eq $defmode) {
# $hh->{$k} = $hh->{$k}[1];
# } else {
# my $kp = $mm->modes->{$m}->add_prefix($k);
# if (exists $hh->{$kp}) {
# $mm->push_error("BUG: conflict when re-adding prefix after merge: $kp");
# return;
# }
# $hh->{$kp} = $hh->{$k}[1];
# delete $hh->{$k};
# }
#}
#
#sub merge_HASH_HASH {
# my ($self, $key, $l, $r, $mode) = @_;
# my $mm = $self->merger;
# my $c = $mm->config;
# $mode //= $c->default_mode;
#
# return $self->merge_SCALAR_SCALAR($key, $l, $r) unless $c->recurse_hash;
# return if $c->wanted_path && !$mm->_path_is_included($mm->path, $c->wanted_path);
#
# my $config_replaced;
# my $orig_c = $c;
# my $ok = $c->options_key;
# {
# last unless defined $ok;
#
# my $okl = $self->_gen_left ($l, $mode, sub {$_[0] eq $ok});
# return if @{ $mm->errors };
#
# my $okr = $self->_gen_right($r, $mode, sub {$_[0] eq $ok});
# return if @{ $mm->errors };
#
# push @{ $mm->path }, $ok;
# my ($res, $backup);
# {
# local $c->{readd_prefix} = 0;
# ($res, $backup) = $self->_merge_gen($okl, $okr, $mode);
# }
# pop @{ $mm->path };
# return if @{ $mm->errors };
#
#
# $res = $res->{$ok} ? $res->{$ok}[1] : undef;
# if (defined($res) && ref($res) ne 'HASH') {
# $mm->push_error("Invalid options key after merge: value must be hash");
# return;
# }
# last unless keys %$res;
# my $c2 = bless({ %$c }, ref($c));
#
# for (keys %$res) {
# if ($c->allow_override) {
# my $re = $c->allow_override;
# if (!/$re/) {
# $mm->push_error("Configuration in options key `$_` not allowed by allow_override $re");
# return;
# }
# }
# if ($c->disallow_override) {
# my $re = $c->disallow_override;
# if (/$re/) {
# $mm->push_error("Configuration in options key `$_` not allowed by disallow_override $re");
# return;
# }
# }
# if ($mm->_in($_, $c->_config_config)) {
# $mm->push_error("Configuration not allowed in options key: $_");
# return;
# }
# if ($_ ne $ok && !$mm->_in($_, $c->_config_ok)) {
# $mm->push_error("Unknown configuration in options key: $_");
# return;
# }
# $c2->$_($res->{$_}) unless $_ eq $ok;
# }
# $mm->config($c2);
# $config_replaced++;
# $c = $c2;
# }
#
# my $sp = $c->set_prefix;
# my $saved_prefixes;
# if (defined($sp)) {
# if (ref($sp) ne 'HASH') {
# $mm->push_error("Invalid config value `set_prefix`: must be a hash");
# return;
# }
# $saved_prefixes = {};
# for my $mh (values %{ $mm->modes }) {
# my $n = $mh->name;
# if ($sp->{$n}) {
# $saved_prefixes->{$n} = {
# prefix => $mh->prefix,
# prefix_re => $mh->prefix_re,
# check_prefix_sub => $mh->check_prefix_sub,
# add_prefix_sub => $mh->add_prefix_sub,
# remove_prefix_sub => $mh->remove_prefix_sub,
script/_finddo view on Meta::CPAN
# $mm->push_error("Invalid config value `exclude_parse`: must be an array");
# return;
# }
# if (defined($ip) && ref($ip) ne 'ARRAY') {
# $mm->push_error("Invalid config value `include_parse`: must be an array");
# return;
# }
#
# my $epr = $c->exclude_parse_regex;
# my $ipr = $c->include_parse_regex;
# if (defined($epr)) {
# eval { $epr = qr/$epr/ };
# if ($@) {
# $mm->push_error("Invalid config value `exclude_parse_regex`: invalid regex: $@");
# return;
# }
# }
# if (defined($ipr)) {
# eval { $ipr = qr/$ipr/ };
# if ($@) {
# $mm->push_error("Invalid config value `include_parse_regex`: invalid regex: $@");
# return;
# }
# }
#
# my $hl = $self->_gen_left ($l, $mode, sub {defined($ok) ? $_[0] ne $ok : 1}, $ep, $ip, $epr, $ipr);
# return if @{ $mm->errors };
#
# my $hr = $self->_gen_right($r, $mode, sub {defined($ok) ? $_[0] ne $ok : 1}, $ep, $ip, $epr, $ipr);
# return if @{ $mm->errors };
#
#
# my $em = $c->exclude_merge;
# my $im = $c->include_merge;
# if (defined($em) && ref($em) ne 'ARRAY') {
# $mm->push_error("Invalid config value `exclude_marge`: must be an array");
# return;
# }
# if (defined($im) && ref($im) ne 'ARRAY') {
# $mm->push_error("Invalid config value `include_merge`: must be an array");
# return;
# }
#
# my $emr = $c->exclude_merge_regex;
# my $imr = $c->include_merge_regex;
# if (defined($emr)) {
# eval { $emr = qr/$emr/ };
# if ($@) {
# $mm->push_error("Invalid config value `exclude_merge_regex`: invalid regex: $@");
# return;
# }
# }
# if (defined($imr)) {
# eval { $imr = qr/$imr/ };
# if ($@) {
# $mm->push_error("Invalid config value `include_merge_regex`: invalid regex: $@");
# return;
# }
# }
#
# my ($res, $backup) = $self->_merge_gen($hl, $hr, $mode, $em, $im, $emr, $imr);
# return if @{ $mm->errors };
#
#
# if ($c->readd_prefix) {
# for my $k (keys %$res) {
# $self->_readd_prefix($res, $k, $c->default_mode);
# }
# } else {
# $res->{$_} = $res->{$_}[1] for keys %$res;
# }
#
# if ($saved_prefixes) {
# for (keys %$saved_prefixes) {
# my $mh = $mm->modes->{$_};
# my $s = $saved_prefixes->{$_};
# $mh->prefix($s->{prefix});
# $mh->prefix_re($s->{prefix_re});
# $mh->check_prefix_sub($s->{check_prefix_sub});
# $mh->add_prefix_sub($s->{add_prefix_sub});
# $mh->remove_prefix_sub($s->{remove_prefix_sub});
# }
# }
#
# if ($config_replaced) {
# $mm->config($orig_c);
# }
#
# ($key, $res, $backup);
#}
#
#1;
#
#__END__
#
### Data/ModeMerge/Mode/CONCAT.pm ###
#package Data::ModeMerge::Mode::CONCAT;
#
#our $DATE = '2016-07-22';
#our $VERSION = '0.35';
#
#use 5.010;
#use strict;
#use warnings;
#use Mo qw(build default);
#extends 'Data::ModeMerge::Mode::ADD';
#
#sub name { 'CONCAT' }
#
#sub precedence_level { 2 }
#
#sub default_prefix { '.' }
#
#sub default_prefix_re { qr/^\./ }
#
#sub merge_SCALAR_SCALAR {
# my ($self, $key, $l, $r) = @_;
# ($key, ($l // "") . $r);
#}
#
#1;
#
#__END__
#
### Data/ModeMerge/Mode/DELETE.pm ###
#package Data::ModeMerge::Mode::DELETE;
#
#our $DATE = '2016-07-22';
#our $VERSION = '0.35';
#
#use 5.010;
#use strict;
#use warnings;
#use Mo qw(build default);
#extends 'Data::ModeMerge::Mode::Base';
#
#sub name { 'DELETE' }
#
#sub precedence_level { 1 }
#
#sub default_prefix { '!' }
#
#sub default_prefix_re { qr/^!/ }
#
#sub merge_left_only {
# my ($self, $key, $l) = @_;
# return;
#}
#
( run in 0.762 second using v1.01-cache-2.11-cpan-8f98c5d2c55 )