package Mouse::Meta::TypeConstraint;
-use strict;
-use warnings;
+use Mouse::Util qw(:meta); # enables strict and warnings
use overload
- '""' => sub { shift->{name} }, # stringify to tc name
+ '""' => sub { $_[0]->name }, # stringify to tc name
fallback => 1;
use Carp qw(confess);
use Scalar::Util qw(blessed reftype);
-use Mouse::Util qw(:meta);
-
my $null_check = sub { 1 };
sub new {
my $check = delete $args{optimized};
if($args{_compiled_type_constraint}){
- Carp::cluck("'_compiled_type_constraint' has been deprecated, use 'optimized' instead");
- $check = $args{_compiled_type_constraint};
+ Carp::cluck("'_compiled_type_constraint' has been deprecated, use 'optimized' instead")
+ if _MOUSE_VERBOSE;
- if(blessed($check)){
- Carp::cluck("Constraint must be a CODE reference");
- $check = $check->{compiled_type_constraint};
- }
+ $check = $args{_compiled_type_constraint};
}
if($check){
$check = $args{constraint};
- if(blessed($check)){
- Carp::cluck("Constraint for $args{name} must be a CODE reference");
- $check = $check->{compiled_type_constraint};
- }
-
if(defined($check) && ref($check) ne 'CODE'){
confess("Constraint for $args{name} is not a CODE reference");
}
my $self = bless \%args, $class;
$self->compile_type_constraint() if !$self->{hand_optimized_type_constraint};
+ if($self->{type_constraints}){ # Union
+ my @coercions;
+ foreach my $type(@{$self->{type_constraints}}){
+ if($type->has_coercion){
+ push @coercions, $type;
+ }
+ }
+ if(@coercions){
+ $self->{_compiled_type_coercion} = sub {
+ my($thing) = @_;
+ foreach my $type(@coercions){
+ my $value = $type->coerce($thing);
+ return $value if $self->check($value);
+ }
+ return $thing;
+ };
+ }
+ }
+
return $self;
}
);
}
-sub name { $_[0]->{name} }
-sub parent { $_[0]->{parent} }
-sub message { $_[0]->{message} }
-
-sub _compiled_type_constraint{ $_[0]->{compiled_type_constraint} }
-
sub compile_type_constraint{
my($self) = @_;
my @checks;
for(my $parent = $self->parent; defined $parent; $parent = $parent->parent){
if($parent->{hand_optimized_type_constraint}){
- push @checks, $parent->{hand_optimized_type_constraint};
+ unshift @checks, $parent->{hand_optimized_type_constraint};
last; # a hand optimized constraint must include all the parents
}
elsif($parent->{constraint}){
- push @checks, $parent->{constraint};
+ unshift @checks, $parent->{constraint};
}
}
return;
}
+sub _add_type_coercions{
+ my $self = shift;
+
+ my $coercions = ($self->{_coercion_map} ||= []);
+ my %has = map{ $_->[0] => undef } @{$coercions};
+
+ for(my $i = 0; $i < @_; $i++){
+ my $from = $_[ $i];
+ my $action = $_[++$i];
+
+ if(exists $has{$from}){
+ confess("A coercion action already exists for '$from'");
+ }
+
+ my $type = Mouse::Util::TypeConstraints::find_or_parse_type_constraint($from)
+ or confess("Could not find the type constraint ($from) to coerce from");
+
+ push @{$coercions}, [ $type => $action ];
+ }
+
+ # compile
+ if(exists $self->{type_constraints}){ # union type
+ confess("Cannot add additional type coercions to Union types");
+ }
+ else{
+ $self->{_compiled_type_coercion} = sub {
+ my($thing) = @_;\r
+ foreach my $pair (@{$coercions}) {\r
+ #my ($constraint, $converter) = @$pair;\r
+ if ($pair->[0]->check($thing)) {\r
+ local $_ = $thing;
+ return $pair->[1]->($thing);
+ }\r
+ }\r
+ return $thing;\r
+ };
+ }
+ return;
+}
+
sub check {
my $self = shift;
- $self->_compiled_type_constraint->(@_);
+ return $self->_compiled_type_constraint->(@_);
+}
+
+sub coerce {
+ my $self = shift;
+
+ return $_[0] if $self->_compiled_type_constraint->(@_);
+
+ my $coercion = $self->_compiled_type_coercion;
+ return $coercion ? $coercion->(@_) : $_[0];
}
sub get_message {
Mouse::Meta::TypeConstraint - The Mouse Type Constraint metaclass
+=head1 VERSION
+
+This document describes Mouse version 0.40_01
+
=head1 DESCRIPTION
For the most part, the only time you will ever encounter an