view release on metacpan or  search on metacpan

lib/DBIx/ObjectMapper/Mapper/Instance.pm  view on Meta::CPAN

    }
    else {
        my $prop = $class_mapper->attributes->property_info($name);
        if( my $getter = $prop->getter ) {
            return $self->instance->$getter();
        }
        else {
            return wantarray
                ? ( $self->instance->{ $prop->name || $name } )
                : $self->instance->{ $prop->name || $name };
        }
    }
}

sub set_val {
    my ( $self, $name, $val ) = @_;
    return unless $self->instance; ## maybe in global destruction.

    local $call = 1;
    my $class_mapper = $self->instance->__class_mapper__;
    if( my $setter = $class_mapper->accessors->generic_setter ) {
        $self->instance->$setter($name => $val);
    }
    else {
        my $prop = $class_mapper->attributes->property_info($name);
        if( my $setter = $prop->setter ) {
            $self->instance->$setter($val);
        }
        else {
            $self->instance->{$prop->name || $name} = $val;
        }
    }

    return $val;
}

sub is_modified   {
    my $self = shift;

    my $is_modified = $self->{is_modified};
    return $is_modified unless $self->instance; ## maybe in global destruction.

    my $class_mapper = $self->instance->__class_mapper__;
    my $modified_data = $self->modified_data;
    for my $prop_name ( $class_mapper->attributes->property_names ) {
        my $prop = $class_mapper->attributes->property_info($prop_name);
        my $col = $prop->name || $prop_name;
        my $val = $self->get_val($prop_name);
        next unless $prop->type eq 'column' and ref $val;
        if( $self->unit_of_work->change_checker->is_changed( $val ) ) {
            $modified_data->{$prop_name} = $val;
            $is_modified = 1;
        }
    }

    return $is_modified;
}

sub modified_data { $_[0]->{modified_data} }

sub update {
    my ( $self ) = @_;
    confess 'it need to be "persistent" status.' unless $self->is_persistent;

    my $reduce_data = $self->reducing;
    my $modified_data = $self->modified_data;
    my $uniq_cond = $self->identity_condition;
    my $class_mapper = $self->instance->__class_mapper__;

    my $result;
    try {
        my @after_cascade;
        for my $prop_name ( $class_mapper->attributes->property_names ) {
            my $prop = $class_mapper->attributes->property_info($prop_name);
            next unless $prop->type eq 'relation';
            if (ref( $prop->{isa} ) eq
                'DBIx::ObjectMapper::Relation::BelongsTo' )
            {
                if ( $prop->{isa}->is_cascade_save_update() ) {
                    $prop->{isa}->cascade_update($self);
                }

                if( $modified_data->{$prop_name} ) {
                    $prop->{isa}->set_val_from_object(
                        $self,
                        $self->get_val($prop_name),
                    );
                }
            }
            elsif ( $prop->{isa}->is_cascade_save_update() ) {
                push @after_cascade, $prop;
            }
        }

        my $new_val;
        if( keys %$modified_data ) {
            my %mod_data;
            for ( keys %$modified_data ) {
                my $prop = $class_mapper->attributes->property_info($_);
                $mod_data{$prop->name} = $modified_data->{$_};
            }

            $result = $class_mapper->update( \%mod_data, $uniq_cond );
            $new_val = DBIx::ObjectMapper::Utils::merge_hashref(
                $reduce_data,
                $modified_data
            );
        }

        for my $c ( @after_cascade ) {
            $c->{isa}->cascade_update( $self );
        }

        $self->_release_many_to_many_event;
        $self->_modify($new_val) if $new_val;
    } catch {
        $self->change_status('detached');
        confess $_[0];
    };

    $self->{is_modified} = 0;