Hallo,
ich mache das ganz anders, die Hooks über die Signale könnte man noch ändern, das muss ich mal anschauen, wie man das am besten implementiert, die Tempalte-Plugins laufen so
while ( $tmpl_line =~ /\[OS_TMPLPLUGIN:(\w+):(\w+):(.*?)\]/g ) {
my ($tpath,$tfunc,$tfval,$tpvalue) = ($1,$2,$3,'') ;
if ( -e "pfad/Tmpl/$tpath/$tfunc.pm" ) {
eval "require Tmpl::$tpath\::$tfunc" ;
die "Fehler bei Einbindung Template-Plugin : Tmpl::$tpath\::$tfunc : $@\n" if ($@) ;
my $tplg = $tfunc->new(\%CONFIG,\%PARA,$tfval);
$tpvalue = $tplg->out ;
}
dann muss man nicht den Code evaluieren. Und die Plugins an sich sehen alles gleich aus vom Aufbau.
Das andere habe ich jetzt noch etwas anders gelöst und zwar über AUTOLOAD, meine Frage dabei ist jetzt, dass man immer liest, dass AUTOLOAD teuer ist - ist das aber immer noch so - in der jetztigen Lösung würden quasi die Funktionen immer über AUTOLOAD laufen.
Siehst Du ein Problem, was die Performance angeht? Die Lösung ist nämlich wirlich genial. Ist nur ein bisschen viel zum Posten, aber jetzt gibt es die Möglichkeit, ein Plugin vor und nach der Funktion auszuführen und die Funktion selber zu überschreiben.
Hier mal das Autoload
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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
sub AUTOLOAD {
my ($self,$arg1) = @_ ;
my @func = split(/\:\:/,$AUTOLOAD) ;
my $f = $func[-1] ;
my $fb = $f . "_beforeEvent" ;
my $fa = $f . "_afterEvent" ;
my $fo = $f . "_overEvent" ;
print "FUNC : @func ($func[-1]) \n" ;
print "Obj : " , $self->{'modclass'} , " ( $self->{'modobj'} ) \n" ;
print "AUTOL : $AUTOLOAD | @_ \n\n" ;
###
#Ausgabe vorher
if ( $self->{'plugclass'}->can($fb) ) {
print "Methode $self -> $fb vorhanden\n" ;
$self->{'plugclass'}->($f . "_beforeEvent")($arg1) ;
}
###
#Eigentliche Funktion
if ( $self->{'plugclass'}->can($fo) ) {
print "Ausgabe OVERfunktion\n" ;
$self->{'plugclass'}->$fo($arg1) ;
} elsif ( $self->{'modobj'} && $func[-1] ) {
print "Ausgabe Standardfunktion\n" ;
$self->{'modobj'}->$f($arg1) ;
}
###
#Ausgabe nachher
if ( $self->{'plugclass'}->can($fa) ) {
print "Methode $self -> $fa vorhanden\n" ;
$self->{'plugclass'}->$fa($arg1) ;
}
print "\n-----------\n\n" ;
}
sub DESTROY {}
1 ;
Aufruf wäre so
my $pobj = Plugin->new('TestClass','TestClassPlug') ;
$pobj->t1('T1T1T1') ;
$pobj->t2('T2T2T2') ;
Das ist mal wirklich eine sehr sehr flexible Lösung, aber halt mit AUTOLOAD erkauft, die alternative wäre nur, dass man eine exec-Funktion macht, dann muss aber jede Funktion über die exec aufrufen, was vom Code her nicht so transparent aussehen würde, anstelle von
$pobj->t1('T1T1T1') ;
dann
$pobj->exec('t1','T1T1T1') ;
und man könnte auf das AUTOLOAD verzichten, das scheint mir aber ein bisschen exotisch zu sein.
Gruss Marky
Jemand zu Hause?![[twitter]](/battie/theme/default/icons/twitter.gif){kind=icon}
+4 replies![[Homepage]](/battie/theme/default/homepage.gif)
![[default_avatar]](/battie/theme/default/default_avatar.gif){kind=avatar}
Schrift
Tipp zum Debugging
Blog
Einstellungen![[feed]](/battie/theme/default/icons/feed.png){kind=icon}
Tags:
![[Powered by Battie]](/battie/img/powered.png)
