Subroutine calls über mehrere packages / module (Allgemeines zu Perl)

[thread]14260[/thread]

Subroutine calls über mehrere packages / module

Leser: 23

Articles: hide open all | hide show old branches

+8 replies

Gast Haspasus

2009-11-17 22:15

Hallo!

Mein derzeitiges Projekt besteht aus mehreren Modulen und einer Hauptroutine. Da die einzelnen Module natürlich auch zu anderem Zweck wiederverwendet werden können sollen, möchte ich bei einem der Module die Fehlerbehandlung auslagern. Soll heißen: Ich übergebe dem Modul eine Referenz auf eine Subroutine, die aufgerufen wird, sobald ein Fehler auftritt. Liegt die SUbroutine in meiner Hauptroutine, funktioniert das ganze problemlos.

Aber wie kann ich eine Referenz auf eine Subroutine des Moduls "Modul2" übergeben (siehe hierzu main.pl:Zeile9 und Modul1.pm:Zeilen 14 und 19))?
Ich möchte also, dass die Subroutine "printMessage" aus Modul1.pm die Subroutine "fehlerbehandlung" aus Modul2.pm aufruft.

Ich würde mich freuen, wenn jemand das Problem lösen und auch erläutern kann, denn auch nach etlichen Seiten perldoc konnte ich die Lösung nicht finden.

Der derzeitige (funktionierende) Stand:
main.pl

Code (perl): (dl )

#!/usr/bin/perl -w

use Test::Case::Modul1;
use Test::Case::Modul2;

my $modul1 = new Test::Case::Modul1;
my $modul2 = new Test::Case::Modul2;

$modul1->setzeFehlerbehandlung(\&fehlerbehandlung);
$modul1->printMessage();

$modul2->fehlerbehandlung("asdasd");
sub fehlerbehandlung {
    my $nachricht = shift;

    print "-" x 30;
    print "\n";
    print "Fehlerbehandlung in der Hauptroutine\n";
    print "Aufruf von: ".caller(0)."\n";
    print "Nachricht: $nachricht\n";
    print "-" x 30;
    print "\n";
}

Modul1.pm

Code (perl): (dl )

package Test::Case::Modul1;
my $fehlerHandler;
my $msg = "testfehler";

sub new {
    $self = shift;

    return $self;
}

sub setzeFehlerbehandlung {
    $self = shift;
    $fehlerHandler = shift;
}

sub printMessage {
    $self = shift;
    &$fehlerHandler($msg);
}

1;

Modul2.pm

Code (perl): (dl )

package Test::Case::Modul2;

sub new {
    $self = shift;

    return $self;
}

sub fehlerbehandlung {
    $self = shift;
    $msg  = shift;

    print "O" x 30;
    print "\n";
    print "Error handling in Modul2\n";
    print "Caller was: ".caller(0)."\n";
    print "Message: ".$msg."\n";
    print "O" x 30;
    print "\n";
}

1;

Gruß
Haspasius

+5 replies
pq

2009-11-17 22:25

User since
2003-08-04
12209 Artikel
Admin1

deine benutzung von modulen ist etwas ungewöhnlich. du erstellst zwar instanzen der klassen, aber nennst diese instanzen "modul1" etc., wobei sie eher "object1" etc. heissen sollt.
ausserdem benutzt du die instanz selbst nirgendwo.
objektorientierung ist gerade dazu da, um methoden zu kapseln und eben nicht von überall aus aufrufbar zu machen. wenn du also in einer methode von Modul1 eine methode von Modul2 aufrufen willst, brauchst du an der stelle eben eine instanz von Modul2. die müsstest du an die methode von Modul1 als parameter übergeben. ohne $modul2 kommst du an die methode nicht (sauber) ran, es sei denn, du benutzt sie als klassenmethode.
als beispiel für klassenmethoden siehe File::Spec
Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
lesen: Wie frage ich & perlintro brian's Leitfaden für jedes Perl-Problem
- +4 replies
- Gast Haspasus
  
  2009-11-17 22:51
  Hallo!
  
  Ersteinmal "Danke" für deine Antwort.
  
  Ich arbeite noch nicht lange mit Perl, insofern ist es gut möglich, dass ich Module falsch einsetze.
  
  Ich habe nun den Code etwas angepasst, sodass ich dem Modul1 (bzw einem Objekt der Klasse Modul1), eine Referenz auf das Modul2 und deen Methodennamen übergebe:
  
  main.pl
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
  
  #!/usr/bin/perl -w use Test::Case::Modul1; use Test::Case::Modul2; my $modul1 = new Test::Case::Modul1; my $modul2 = new Test::Case::Modul2; $modul1->setzeNachricht("super duper hyper fehler text!"); $modul1->setzeFehlerbehandlung($modul2,"fehlerbehandlung"); $modul1->printMessage(); sub fehlerbehandlung { my $nachricht = shift; print "-" x 30; print "\n"; print "Fehlerbehandlung in der Hauptroutine\n"; print "Aufruf von: ".caller(0)."\n"; print "Nachricht: $nachricht\n"; print "-" x 30; print "\n"; }
  
  Modul1.pm
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
  
  package Test::Case::Modul1; my $fehlerHandler; my $fehlerfunc; my $msg = "testfehler"; sub new { my $self = shift; return $self; } sub setzeFehlerbehandlung { my $self = shift; $fehlerHandler = shift; $fehlerfunc = shift; } sub printMessage { my $self = shift; $fehlerHandler->${fehlerfunc}($msg); } sub getError { my $self = shift; return $msg; } sub setzeNachricht { my $self = shift; my $text = shift; $msg = $text; } 1;
  
  So funktioniert das ganze.
  
  Aber ist das so sauber? Oder habe ich das mit der Instanzübergabe falsch verstanden?
  
  Gruß
  Haspasus
  - +3 replies
  - pq
    
    2009-11-17 22:59
    
    User since
    2003-08-04
    12209 Artikel
    Admin1
    
    ich finde es wiederum merkwürdig, dass du $fehlerfunc und $fehlerHandler als "globale" variablen im modul setzt. wenn das beabsichtigt ist, ok, aber bisher nutzt du die objektorientierung nicht wirklich.
    so wie du es jetzt machst, sind für jede instanz des moduls die genannten variablen gleich.
    
    nebenbei bemerkt solltest du unbedingt strict und warnings benutzen: UseStrict (warnings ist der ersatz für das veraltete -w)
    Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
    lesen: Wie frage ich & perlintro brian's Leitfaden für jedes Perl-Problem
    - +2 replies
    - Gast Haspasus
      
      2009-11-17 23:46
      
      Ich habe nun in allen Dateien das "-w" aus dem Shebang entfernt und überall
      
      Code (perl): (dl )
      
      1 2
      
      use strict; use warnings;
      
      hinzugefügt.
      
      Desweiteren habe ich nun versucht, das Modul1 mit Instanzen (?) umzusetzen.
      
      Nun klappts aber nicht mehr. Ich bekomme einen Kompilierfehler:
      
      Quote
      Global symbol "%self" requires explicit package name at Test/Case/Modul1.pm line 37.
      syntax error at Test/Case/Modul1.pm line 37, near "$self{FEHLERFUNC"
      Global symbol "$self" requires explicit package name at Test/Case/Modul1.pm line 37.
      syntax error at Test/Case/Modul1.pm line 38, near "}"
      Compilation failed in require at ./main.pl line 6.
      BEGIN failed--compilation aborted at ./main.pl line 6.
      
      Hier die geänderte Modul1.pm:
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
      
      package Test::Case::Modul1; use strict; use warnings; sub new { my $self = shift; my $ref = {}; bless($ref, $self); $ref->{FEHLERHANDLER}=undef; $ref->{FEHLERFUNC}=undef; $ref->{FEHLERMSG}="standardfehler"; $ref; } sub setzeFehlerbehandlung { my $self = shift; $self->{FEHLERHANDLER} = shift; $self->{FEHLERFUNC} = shift; } sub getError { my $self = shift; return $self->{FEHLERMSG}; } sub setzeNachricht { my $self = shift; $self->{FEHLERMSG} = shift; } sub printMessage { my $self = shift; $self->{FEHLERHANDLER}->$self{FEHLERFUNC}($self->{FEHLERMSG}); } 1;
      - Dubu
        
        2009-11-17 23:57
        
        User since
        2003-08-04
        2145 Artikel
        ModeratorIn + EditorIn
        
        In Zeile 37 fehlt ein Pfeil nach dem zweiten self.
+2 replies

topeg

2009-11-18 00:29

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Ich habe es mal überarbeitet.

So würde ich es machen, da man damit sehr flexible ist.
main.pl

Code (perl): (dl )

#!/usr/bin/perl
use strict:
use warnings;
use Test::Case::Modul1;
use Test::Case::Modul2;

my $modul1 = new Test::Case::Modul1;
my $modul2 = new Test::Case::Modul2;

$modul1->setzeFehlerbehandlung( sub{ $modul2->fehlerbehandlung(@_); });
$modul1->printMessage("testfehler");

Modul1.pm

Code (perl): (dl )

package Test::Case::Modul1;
use strict;
use warnings;

sub new {
    my $class = shift;
    my $self  = {};
    my $self->{FehlerHandler} = sub{warn("$_[0]\n"); 1};
    bless($self,$class);
    return $self;
}

sub setzeFehlerbehandlung {
    my $self    = shift;
    my $handler = shift;
    if(ref($handler) eq 'CODE'){
      $self->{FehlerHandler}=$handler;
      return 1;
    }
    return 0;
}

sub printMessage {
    my $self = shift;
    my $msg  = shift || ''; 
    return $self->{FehlerHandler}->($msg);
}

1;

Modul2.pm

Code (perl): (dl )

package Test::Case::Modul2;
use strict;
use warnings;

sub new {
    my $class = shift;
    my $self  = {};
    bless($self,$class);
    return $self;
}

sub fehlerbehandlung {
    my $self = shift;
    my $msg  = shift;

    print "O" x 30;
    print "\n";
    print "Error handling in Modul2\n";
    print "Caller was: ".caller(0)."\n";
    print "Message: ".$msg."\n";
    print "O" x 30;
    print "\n";

    return 1;
}

1;

####################################################################
oder etwas anders:
Das wäre ähnlich dem was Java als "Interface" kennt

main.pl

Code (perl): (dl )

#!/usr/bin/perl
use strict:
use warnings;
use Test::Case::Modul1;
use Test::Case::Modul2;

my $modul1 = new Test::Case::Modul1;
my $modul2 = new Test::Case::Modul2;

$modul1->setzeFehlerbehandlung( $modul2 );
$modul1->printMessage("testfehler");

Modul1.pm

Code (perl): (dl )

package Test::Case::Modul1;
use strict;
use warnings;

sub new {
    my $class = shift;
    my $self  = {};
    my $self->{FehlerHandler} = $self;
    bless($self,$class);
    return $self;
}

sub setzeFehlerbehandlung {
    my $self    = shift;
    my $handler = shift;
    if($handler->can('fehlerbehandlung')){
      $self->{FehlerHandler}=$handler;
      return 1;
    }
    return 0;
}

sub printMessage {
    my $self = shift;
    my $msg  = shift || '';
    return $self->{FehlerHandler}->fehlerbehandlung($msg);
}

sub fehlerbehandlung {
    my $self = shift;
    my $msg  = shift;
    warn("$msg");
    return 1;
}


1;

Modul2.pm

Code (perl): (dl )

package Test::Case::Modul2;
use strict;
use warnings;

sub new {
    my $class = shift;
    my $self  = {};
    bless($self,$class);
    return $self;
}

sub fehlerbehandlung {
    my $self = shift;
    my $msg  = shift;

    print "O" x 30;
    print "\n";
    print "Error handling in Modul2\n";
    print "Caller was: ".caller(0)."\n";
    print "Message: ".$msg."\n";
    print "O" x 30;
    print "\n";

    return 1;
}

1;

Beides ungetestet.

MatthiasW

2009-11-18 20:10
User since
2008-01-27
367 Artikel
BenutzerIn
2009-11-17T23:29:34 topeg
...[Zweite Variante, Modul1:]

Code (perl): (dl )

1 2 3 4 5 6 7

sub new { my $class = shift; my $self = {}; my $self->{FehlerHandler} = $self; # <-- bless($self,$class); return $self; }
An dieser Stelle (Z. 4) erzeugst du eine zirkuläre Referenz. Damit habe ich mich aber noch nicht wirklich auseinandergesetzt, also weiß ich nicht ob weaken() hier angebracht wäre? (Ein kleiner Test meinte: Ja.)
Bei deinem Beispiel spielt es keine Rolle, da der FehlerHandler überschrieben wird, aber ansonsten würde ein Objekt erst freigegeben, wenn das Skript beendet wird, oder?

MfG
perl -E'*==*",s;;%ENV=~m,..$,,$&+42;e,$==f;$"++for+ab..an;@"=qw,u t,,print+chr;sub f{split}say"@{=} me"'

View all threads created 2009-11-17 22:15.