use warnings;
use strict;
-use constant SPURIOUS_VERSION_CHECK_WARNINGS => ( "$]" < 5.010 ? 1 : 0);
-
-my $mro_recursor_stack;
+# For the love of everything that is crab-like: DO NOT reach into this
+# The entire thing is really fragile and should not be screwed with
+# unless absolutely and unavoidably necessary
+our $__describe_class_query_cache;
BEGIN {
package # hide from pause
use Config;
use constant {
+ PERL_VERSION => "$]",
+ OS_NAME => "$^O",
+ };
+
+ use constant {
# but of course
- BROKEN_FORK => ($^O eq 'MSWin32') ? 1 : 0,
+ BROKEN_FORK => (OS_NAME eq 'MSWin32') ? 1 : 0,
- BROKEN_GOTO => ( "$]" < 5.008003 ) ? 1 : 0,
+ BROKEN_GOTO => ( PERL_VERSION < 5.008003 ) ? 1 : 0,
# perl -MScalar::Util=weaken -e 'weaken( $hash{key} = \"value" )'
- BROKEN_WEAK_SCALARREF_VALUES => ( "$]" < 5.008003 ) ? 1 : 0,
+ BROKEN_WEAK_SCALARREF_VALUES => ( PERL_VERSION < 5.008003 ) ? 1 : 0,
HAS_ITHREADS => $Config{useithreads} ? 1 : 0,
- UNSTABLE_DOLLARAT => ( "$]" < 5.013002 ) ? 1 : 0,
+ UNSTABLE_DOLLARAT => ( PERL_VERSION < 5.013002 ) ? 1 : 0,
( map
#
),
IV_SIZE => $Config{ivsize},
-
- OS_NAME => $^O,
};
- if ( "$]" < 5.009_005) {
+ if ( PERL_VERSION < 5.009_005) {
require MRO::Compat;
constant->import( OLD_MRO => 1 );
require Digest::MD5;
require Math::BigInt;
+ my $cur_class;
+ no strict 'refs';
+
# the non-assign-unless-there-is-a-hash is deliberate
- ( $mro_recursor_stack->{cache} || {} )->{$_[0]}{gen} ||= (
+ ( $__describe_class_query_cache->{'!internal!'} || {} )->{$_[0]}{gen} ||= (
Math::BigInt->new( '0x' . ( Digest::MD5::md5_hex( join "\0", map {
- ( $mro_recursor_stack->{cache} || {} )->{$_}{methlist} ||= do {
+ ( $__describe_class_query_cache->{'!internal!'} || {} )->{$_}{methlist} ||= (
+
+ $cur_class = $_
- my $class = $_;
- no strict 'refs';
+ and
# RV to be hashed up and turned into a number
join "\0", (
- $class,
+ $cur_class,
map
{(
# stringification should be sufficient, ignore names/refaddr entirely
map
{(
# skip dummy C::C3 helper crefs
- ! ( ( $Class::C3::MRO{$class} || {} )->{methods}{$_} )
+ ! ( ( $Class::C3::MRO{$cur_class} || {} )->{methods}{$_} )
and
(
- ref(\ "${class}::"->{$_} ) ne 'GLOB'
+ ref(\ "${cur_class}::"->{$_} ) ne 'GLOB'
or
- defined( *{ "${class}::"->{$_} }{CODE} )
+ defined( *{ "${cur_class}::"->{$_} }{CODE} )
)
)
- ? ( \&{"${class}::$_"} )
+ ? ( \&{"${cur_class}::$_"} )
: ()
}
- keys %{ "${class}::" }
- );
- }
+ keys %{ "${cur_class}::" }
+ )
+ )
} (
@{
- ( $mro_recursor_stack->{cache} || {} )->{$_[0]}{linear_isa}
+ ( $__describe_class_query_cache->{'!internal!'} || {} )->{$_[0]}{linear_isa}
||=
mro::get_linear_isa($_[0])
},
((
- ( $mro_recursor_stack->{cache} || {} )->{$_[0]}{is_universal}
+ ( $__describe_class_query_cache->{'!internal!'} || {} )->{$_[0]}{is_universal}
||=
mro::is_universal($_[0])
) ? () : @{
- ( $mro_recursor_stack->{cache} || {} )->{UNIVERSAL}{linear_isa}
+ ( $__describe_class_query_cache->{'!internal!'} || {} )->{UNIVERSAL}{linear_isa}
||=
mro::get_linear_isa("UNIVERSAL")
} ),
sub PEEPEENESS () { &$sigh }
}
+use constant SPURIOUS_VERSION_CHECK_WARNINGS => ( DBIx::Class::_ENV_::PERL_VERSION < 5.010 ? 1 : 0);
+
# FIXME - this is not supposed to be here
# Carp::Skip to the rescue soon
use DBIx::Class::Carp '^DBIx::Class|^DBICTest';
fail_on_internal_wantarray fail_on_internal_call
refdesc refcount hrefaddr set_subname describe_class_methods
scope_guard detected_reinvoked_destructor
+ true false
is_exception dbic_internal_try visit_namespaces
quote_sub qsub perlstring serialize deep_clone dump_value uniq
parent_dir mkdir_p
$dump_str;
}
+###
+### This is *NOT* boolean.pm - deliberately not using a singleton
+###
+{
+ package # hide from pause
+ DBIx::Class::_Util::_Bool;
+ use overload
+ bool => sub { ${$_[0]} },
+ fallback => 1,
+ ;
+}
+sub true () { my $x = 1; bless \$x, "DBIx::Class::_Util::_Bool" }
+sub false () { my $x = 0; bless \$x, "DBIx::Class::_Util::_Bool" }
+
sub scope_guard (&) {
croak 'Calling scope_guard() in void context makes no sense'
if ! defined wantarray;
}
{
- # FIXME - should be a private my(), but I'm too uncertain whether
- # all bases are covered
- our $describe_class_query_cache;
sub describe_class_methods {
- my ($class, $requested_mro) = @_;
+ my $args = (
+ ref $_[0] eq 'HASH' ? $_[0]
+ : ( @_ == 1 and ! length ref $_[0] ) ? { class => $_[0] }
+ : { @_ }
+ );
+
+ my ($class, $requested_mro) = @{$args}{qw( class use_mro )};
- croak "Expecting a class name"
+ croak "Expecting a class name either as the sole argument or a 'class' option"
if not defined $class or $class !~ $module_name_rx;
$requested_mro ||= mro::get_mro($class);
# mro::set_mro() does not bump pkg_gen - WHAT THE FUCK?!
my $query_cache_key = "$class|$requested_mro";
- my $stack_cache_key =
+ my $internal_cache_key =
( mro::get_mro($class) eq $requested_mro )
? $class
: $query_cache_key
# we use the cache for linear_isa lookups on new MRO as well - it adds
# a *tiny* speedup, and simplifies the code a lot
#
- local $mro_recursor_stack->{cache} = {}
- unless $mro_recursor_stack->{cache};
+ local $__describe_class_query_cache->{'!internal!'} = {}
+ unless $__describe_class_query_cache->{'!internal!'};
my $my_gen = 0;
$my_gen += get_real_pkg_gen($_) for ( my @full_ISA = (
@{
- $mro_recursor_stack->{cache}{$stack_cache_key}{linear_isa}
+ $__describe_class_query_cache->{'!internal!'}{$internal_cache_key}{linear_isa}
||=
mro::get_linear_isa($class, $requested_mro)
},
((
- $mro_recursor_stack->{cache}{$class}{is_universal}
+ $__describe_class_query_cache->{'!internal!'}{$class}{is_universal}
||=
mro::is_universal($class)
) ? () : @{
- $mro_recursor_stack->{cache}{UNIVERSAL}{linear_isa}
+ $__describe_class_query_cache->{'!internal!'}{UNIVERSAL}{linear_isa}
||=
mro::get_linear_isa("UNIVERSAL")
}),
));
- my $slot = $describe_class_query_cache->{$query_cache_key} ||= {};
+ my $slot = $__describe_class_query_cache->{$query_cache_key} ||= {};
unless ( ($slot->{cumulative_gen}||0) == $my_gen ) {
- # remove ourselves from ISA
- shift @full_ISA;
-
# reset
%$slot = (
class => $class,
- isa => [
- @{ $mro_recursor_stack->{cache}{$stack_cache_key}{linear_isa} }
- [ 1 .. $#{$mro_recursor_stack->{cache}{$stack_cache_key}{linear_isa}} ]
+ isa => { map { $_ => 1 } @full_ISA },
+ linear_isa => [
+ @{ $__describe_class_query_cache->{'!internal!'}{$internal_cache_key}{linear_isa} }
+ [ 1 .. $#{$__describe_class_query_cache->{'!internal!'}{$internal_cache_key}{linear_isa}} ]
],
mro => {
type => $requested_mro,
cumulative_gen => $my_gen,
);
+ # remove ourselves from ISA
+ shift @full_ISA;
+
# ensure the cache is populated for the parents, code below can then
# efficiently operate over the query_cache directly
describe_class_methods($_) for reverse @full_ISA;
# what describe_class_methods for @full_ISA produced above
( map { values %{
- $describe_class_query_cache->{$_}{methods_defined_in_class} || {}
+ $__describe_class_query_cache->{$_}{methods_defined_in_class} || {}
} } map { "$_|" . mro::get_mro($_) } reverse @full_ISA ),
# our own non-cleaned subs + their attributes
projects / dbsrgits/DBIx-Class.git / blobdiff