X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMoose%2FMeta%2FTypeConstraint.pm;h=054e7fe77c36bdc6449d730152adf3894a474c52;hb=b17a3035c66fc43b00413edf83882b2ceebfcff1;hp=8d0f28a2b3ec707062731f32fba02466dc2098ae;hpb=8ee73eeb7e76858f1dbe56f69101a2dc1e096559;p=gitmo%2FMoose.git diff --git a/lib/Moose/Meta/TypeConstraint.pm b/lib/Moose/Meta/TypeConstraint.pm index 8d0f28a..054e7fe 100644 --- a/lib/Moose/Meta/TypeConstraint.pm +++ b/lib/Moose/Meta/TypeConstraint.pm @@ -5,17 +5,25 @@ use strict; use warnings; use metaclass; +use overload '""' => sub { shift->name }, # stringify to tc name + fallback => 1; + use Sub::Name 'subname'; use Carp 'confess'; use Scalar::Util 'blessed'; -our $VERSION = '0.06'; - -use Moose::Meta::TypeConstraint::Union; +our $VERSION = '0.09'; +our $AUTHORITY = 'cpan:STEVAN'; -__PACKAGE__->meta->add_attribute('name' => (reader => 'name' )); -__PACKAGE__->meta->add_attribute('parent' => (reader => 'parent' )); -__PACKAGE__->meta->add_attribute('constraint' => (reader => 'constraint')); +__PACKAGE__->meta->add_attribute('name' => (reader => 'name')); +__PACKAGE__->meta->add_attribute('parent' => ( + reader => 'parent', + predicate => 'has_parent', +)); +__PACKAGE__->meta->add_attribute('constraint' => ( + reader => 'constraint', + writer => '_set_constraint', +)); __PACKAGE__->meta->add_attribute('message' => ( accessor => 'message', predicate => 'has_message' @@ -24,69 +32,32 @@ __PACKAGE__->meta->add_attribute('coercion' => ( accessor => 'coercion', predicate => 'has_coercion' )); +__PACKAGE__->meta->add_attribute('hand_optimized_type_constraint' => ( + init_arg => 'optimized', + accessor => 'hand_optimized_type_constraint', + predicate => 'has_hand_optimized_type_constraint', +)); + +# private accessors -# private accessor __PACKAGE__->meta->add_attribute('compiled_type_constraint' => ( - accessor => '_compiled_type_constraint' + accessor => '_compiled_type_constraint', + predicate => '_has_compiled_type_constraint' +)); +__PACKAGE__->meta->add_attribute('package_defined_in' => ( + accessor => '_package_defined_in' )); sub new { my $class = shift; my $self = $class->meta->new_object(@_); - $self->compile_type_constraint(); + $self->compile_type_constraint() + unless $self->_has_compiled_type_constraint; return $self; } -sub coerce { - ((shift)->coercion || confess "Cannot coerce without a type coercion")->coerce(@_) -} - -sub _collect_all_parents { - my $self = shift; - my @parents; - my $current = $self->parent; - while (defined $current) { - unshift @parents => $current; - $current = $current->parent; - } - return @parents; -} - -sub compile_type_constraint { - my $self = shift; - my $check = $self->constraint; - (defined $check) - || confess "Could not compile type constraint '" . $self->name . "' because no constraint check"; - my $parent = $self->parent; - if (defined $parent) { - # we have a subtype ... - # so we gather all the parents in order - # and grab their constraints ... - my @parents = map { $_->constraint } $self->_collect_all_parents; - # then we compile them to run without - # having to recurse as we did before - $self->_compiled_type_constraint(subname $self->name => sub { - local $_ = $_[0]; - foreach my $parent (@parents) { - return undef unless $parent->($_[0]); - } - return undef unless $check->($_[0]); - 1; - }); - - } - else { - # we have a type .... - $self->_compiled_type_constraint(subname $self->name => sub { - local $_ = $_[0]; - return undef unless $check->($_[0]); - 1; - }); - } -} - -sub check { $_[0]->_compiled_type_constraint->($_[1]) } - +sub coerce { ((shift)->coercion || confess "Cannot coerce without a type coercion")->coerce(@_) } +sub check { $_[0]->_compiled_type_constraint->($_[1]) } sub validate { my ($self, $value) = @_; if ($self->_compiled_type_constraint->($value)) { @@ -103,6 +74,8 @@ sub validate { } } +## type predicates ... + sub is_a_type_of { my ($self, $type_name) = @_; ($self->name eq $type_name || $self->is_subtype_of($type_name)); @@ -118,18 +91,98 @@ sub is_subtype_of { return 0; } -sub union { - my ($class, @type_constraints) = @_; - (scalar @type_constraints >= 2) - || confess "You must pass in at least 2 Moose::Meta::TypeConstraint instances to make a union"; - (blessed($_) && $_->isa('Moose::Meta::TypeConstraint')) - || confess "You must pass in only Moose::Meta::TypeConstraint instances to make unions" - foreach @type_constraints; - return Moose::Meta::TypeConstraint::Union->new( - type_constraints => \@type_constraints, - ); +## compiling the type constraint + +sub compile_type_constraint { + my $self = shift; + $self->_compiled_type_constraint($self->_actually_compile_type_constraint); } +## type compilers ... + +sub _actually_compile_type_constraint { + my $self = shift; + + return $self->_compile_hand_optimized_type_constraint + if $self->has_hand_optimized_type_constraint; + + my $check = $self->constraint; + (defined $check) + || confess "Could not compile type constraint '" + . $self->name + . "' because no constraint check"; + + return $self->_compile_subtype($check) + if $self->has_parent; + + return $self->_compile_type($check); +} + +sub _compile_hand_optimized_type_constraint { + my $self = shift; + + my $type_constraint = $self->hand_optimized_type_constraint; + + return sub { + return undef unless $type_constraint->($_[0]); + return 1; + }; +} + +sub _compile_subtype { + my ($self, $check) = @_; + + # so we gather all the parents in order + # and grab their constraints ... + my @parents; + foreach my $parent ($self->_collect_all_parents) { + if ($parent->has_hand_optimized_type_constraint) { + unshift @parents => $parent->hand_optimized_type_constraint; + last; + } + else { + unshift @parents => $parent->constraint; + } + } + + # then we compile them to run without + # having to recurse as we did before + return subname $self->name => sub { + local $_ = $_[0]; + foreach my $parent (@parents) { + return undef unless $parent->($_[0]); + } + return undef unless $check->($_[0]); + 1; + }; +} + +sub _compile_type { + my ($self, $check) = @_; + return subname $self->name => sub { + local $_ = $_[0]; + return undef unless $check->($_[0]); + 1; + }; +} + +## other utils ... + +sub _collect_all_parents { + my $self = shift; + my @parents; + my $current = $self->parent; + while (defined $current) { + push @parents => $current; + $current = $current->parent; + } + return @parents; +} + +## this should get deprecated actually ... + +sub union { die "DEPRECATED" } + 1; __END__ @@ -188,6 +241,8 @@ the C will be used to construct a custom error message. =item B +=item B + =item B =item B @@ -198,11 +253,20 @@ the C will be used to construct a custom error message. =item B +=item B + +=item B + =back +=head2 DEPRECATED METHOD + =over 4 -=item B +=item B + +This was just bad idea on my part,.. use the L +itself instead. =back @@ -218,11 +282,11 @@ Stevan Little Estevan@iinteractive.comE =head1 COPYRIGHT AND LICENSE -Copyright 2006 by Infinity Interactive, Inc. +Copyright 2006, 2007 by Infinity Interactive, Inc. L This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself. -=cut \ No newline at end of file +=cut