File Coverage

blib/lib/RPC/Simple/ObjectHandler.pm

Criterion	Covered	Total	%
statement	9	61	14.7
branch	0	14	0.0
condition			n/a
subroutine	3	9	33.3
pod	4	6	66.6
total	16	90	17.7

package RPC::Simple::ObjectHandler;

use strict;
use vars qw($VERSION);

use RPC::Simple::CallHandler ;

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

( $VERSION ) = '$Revision: 1.7 $ ' =~ /\$Revision:\s+([^\s]+)/;

sub new
  {
    my $type = shift ;
    my $self = {} ;
    bless $self,$type ;

    $self->{server} = shift ;
    my $objName = shift ;
    $self->{handle} = shift ;
    my $args = shift ;
    my $reqId = shift ;

    my $result = 1 ;

    #We can remove the .pm off the object name if
    #it exists.  This will allow us to be called
    #as an object name and even a fully qualified
    #object name ie.(Object.pm, Ojbect, Some::Object)
    $objName =~ s/\.\w*$// ;
    eval "require $objName; $objName->import()" ;

    if ($@)
      {
        print "Can't load $objName: $@\n" ;
        $result = 0 ;
      }
    else
      {
        print "Creating object controller for $objName\n" if $main::verbose ;
        eval { $self->{objRef} = $objName -> new ($self, @$args) };

        if ($@)
          {
            print "Can't create $objName: $@\n" ;
            $result = 0 ;
          }
      }

    $self->{slaveClass} = $objName ;

    $self->callbackDone($reqId,$result,$@) ;
    return $self ;
  }

sub destroy
  {
    my $self=shift;
    delete $self->{objRef} ;

    if (defined $self->{requestTab})
      {
        foreach (values %{$self->{requestTab}})
          {
            $_->destroy ;
          }
      }
    print "ObjectHandler for $self->{slaveClass} destroyed\n";
  }

sub remoteCall
  {
    my $self = shift ;
    my $reqId = shift ; # optionnal
    my $method = shift ;
    my $args = shift ;

    if (defined $reqId)
      {
        # call back required
        $self->{requestTab}{$reqId} =
          RPC::Simple::CallHandler ->
            new ($self,$self->{objRef}, $reqId, $method, $args) ;
      }
    else
      {
        $self->{objRef} -> $method (@$args);
      }
  }

sub close
  {
    my $self = shift ;

    print "Closing ",ref($self),"\n" ;

    map( undef $self->{requestTab}{$_}  , keys %{$self->{requestTab}}) ;
    $self->{objRef} -> close ;
    undef $self ;
  }

sub delegate
  {
    my $self = shift ;
    my $method = shift ;
    my $args = \@_ ;

    print "delegate called by real object for $method\n" if $main::verbose ;
    $self->{server}-> writeSock($self->{handle},$method,undef,$args) ;
  }

sub callbackDone
  {
    my $self = shift ;
    my $reqId = shift ;

    print "callbackDone called\n" if $main::verbose ;
    $self->{server}->writeSock($self->{handle},undef,$reqId,[@_]) ;
  }

# Preloaded methods go here.

# Autoload methods go after =cut, and are processed by the autosplit program.

1;
__END__