07/07/2022, 14:01
Introduction
Pour faire un résumé assez court; Voici une procédure a placer dans votre namespace parent, et le faire appeler
create_sub_procs va créer a partir du namespace parents des procédures pour explorer les sous namespaces et leurs sous commandes/procédures.
Fonctionnement en bref
Exemple
Voici un exemple de namespaces avec des sous namespaces et des sous procedures; la procedure; et des tests dans cette environnement; tout cela commenter
Le code
Et voici la procédure en elle-même :
Outroduction
Voilà; personnellement je l'ai créer pour mon propre toolkit et ses fonctions. Si ca peut vous servir tant mieux
Je laisse libre droits sur mon thread a tout modérateurs de eggdrop.fr, vous pouvez l'éditer, supprimer, déplacer, critiqué etc a volonté …
Pour faire un résumé assez court; Voici une procédure a placer dans votre namespace parent, et le faire appeler
Quote:create_sub_procs [namespace current]
create_sub_procs va créer a partir du namespace parents des procédures pour explorer les sous namespaces et leurs sous commandes/procédures.
Fonctionnement en bref
- En appelants un namespace comme une procédure, le code va vous dire qu'il nécessite une sous-commande
- En appelants une procédure qui n'existe pas dans un sous-namespace, le code va vous dire que vous essayer d'appeler une procédure inconnue ou que votre commande est ambigu en fournissant la listes des sous-procédures existants
- En appelants un sous(-sous..)-namespace comme une procédure, le code va vous dire qu'il nécessite une sous(-sous..)-commande
- Les sous(-sous..)-namespaces ne nécessite plus de nom complets du style "::monscript::user:add::group <user> <group>" dans votre namespace ::monscript vous pouvez appeler comme ceci : [user add group ZarTeK Developpeur] par exemple.
Exemple
Voici un exemple de namespaces avec des sous namespaces et des sous procedures; la procedure; et des tests dans cette environnement; tout cela commenter
tcl
# Creation d'un namespace nommer ::example pour faire des tests
namespace eval ::example {
# on cree dedans text (::example::text)
namespace eval text {
# dedans on crée 3 proc pour test (::example::text::a, ::example::text::b et ::example::text::c)
proc a { text } { puts $text }
proc B {} {}
proc c {} {}
}
# on crée dedans un deuxième (::example::text2)
namespace eval text2 {
# on crée également des procs dans (::example::text) qui seront (::example::text::e,::example::text::f, ::example::text::g )
proc e { text } { puts $text }
proc f {} {}
proc g {} {}
#dans le namespace (::example::text2) on créer un sous namespace text3 (::example::text2::text3)
namespace eval text3 {
# dedans on creer une proc 123 (::example::text2::text3::123)
proc 123 { text } { puts $text }
}
}
::example::text::a "premier test"
# retourne : premier test
::example::text2::e "test2"
# retourne : test2
# jusque ici, tout est normal on appelle les procs avec leurs namespaces en préfix
#creation des procs dans les namespaces
proc create_sub_procs { namespace } {
# Boucle sur les namespaces enfants de $namespace (::example) retourne -> ::example::text; ::example::text2
foreach child_name [namespace children ${namespace}] {
# Création de procédure portant le nom des namespaces enfants ::example::text, ::example::text2
proc ${child_name} { {subcommand ""} args } {
# tout ce qui fais partie ici, sera executé lors de l'exécution de la proc créer
# les variables, commandes
# le proc_path contient chemin de la proc (lors de sont exécution et non maintenant donc)
set proc_path [lindex [info level 0] 0]
# Si la proc est apeller sans subcommand, nous signalons qu'elle nécessite une
if { ${subcommand} == "" } {
return -code error \
"wrong # args: should be \"${proc_path} subcommand ?arg ...?\""
}
# Si la subcommand n'existe pas dans les procs enfants, ont prévois de retourner la liste des procs existante dans le namespace courant (celle de la proc appelé )
if { [info commands ${proc_path}::${subcommand}] == "" } {
set subcommands_list [join [string map "${proc_path}:: \"\"" [info procs ${proc_path}::*]] ", "]
return -code error \
"wrong ${proc_path} unknown or ambiguous subcommand \"${subcommand}\": must be ${subcommands_list}"
}
# si la subcommand existe, on l'execute avec les valeurs fournis
${proc_path}::${subcommand} {*}${args}
}
# ici nous sommes sorties de la creation de la proc, et de retour dans la boucle enfant, nous allons exporté les proc
namespace export *
# Nous allons répéter ces opérations dans le niveau inferieur/enfants (dans ::example::text et ::example::text2)
create_sub_procs ${child_name}
}
# fin de la boucle
}
# Nous exécutons la recette dans notre namespace courant
create_sub_procs [namespace current]
}
# maintenant quelque petit tests:
#.tcl ::example::text
# > error: wrong # args: should be "::example::text subcommand ?arg ...?"
# ici dessus, nous appelons un namespace, le code accepte, mais retourne une erreur pour dire qu'une sous-commande doit être fournis
#.tcl ::example::text subcommand123
# > error: wrong ::example::text unknown or ambiguous subcommand "subcommand123": must be a, B, c
# ici dessus, nous avons donner une sous-commande qui n'existe pas, il nous retourne une erreur pour ce dire qu'on c'est trompé et fournis la liste des sous-commandes disponibles
# .tcl ::example::text a
# > error: wrong # args: should be "::example::text::a text"
# ci dessus, nous voyons qu'il nous dis que ::example::text::a nécessite un argument "text".
# a noter que nous avons utiliser "::example::text a" qui est en réalité "::example::text::a"
# .tcl ::example::text a coucou
# > coucou
# ici il a bien exécuter la proc a dans ::example::text et l'argument text vaut coucou, et il nous l'affiche bien "coucou"
#.tcl ::example::text2
# > error: wrong # args: should be "::example::text2 subcommand ?arg ...?"
# rien de nouveau avec le text2 a comparer au text pour l'instant
#.tcl ::example::text2 lala
# > error: wrong ::example::text2 unknown or ambiguous subcommand "lala": must be text3, e, f, g
# il nous retourne une erreur comme nous l'avions avec text, sauf que cette fois ci, il nous annonce que le sous namespace text3 est une sous commande !
# .tcl ::example::text2 e coucou2
# > coucou2
# rien de special, il nous affiche bien notre coucou2
# essayons maintenant avec la sous commandes text3 qu'il nous propose et qui est une namespace qu'on avais déclarer
# .tcl ::example::text2 text3
# > error: wrong # args: should be "::example::text2::text3 subcommand ?arg ...?"
# ils nous annonce qui a des sous commandes !
# .tcl ::example::text2 text3 coucou3
# > error: wrong ::example::text2::text3 unknown or ambiguous subcommand "coucou3": must be 123
# Il nous informe que coucou3 n'ai pas une sous commandes, mais qu'il existe 123 comme sous commande
# .tcl ::example::text2 text3 123
# > error: wrong # args: should be "::example::text2::text3::123 text"
# il nous informe que la sous commandes text3 nécessite un argument text, on va lui fournir
#.tcl ::example::text2 text3 123 "voilà !!!"
# > voilà !!!
Le code
Et voici la procédure en elle-même :
tcl
proc create_sub_procs { namespace } {
# Boucle sur les namespaces enfants de $namespace (::example) retourne -> ::example::text; ::example::text2
foreach child_name [namespace children ${namespace}] {
# Création de procédure portant le nom des namespaces enfants ::example::text, ::example::text2
proc ${child_name} { {subcommand ""} args } {
# tout ce qui fais partie ici, sera exécuté lors de l'exécution de la proc créer
# les variables, commandes
# le proc_path contient chemin de la proc (lors de sont exécution et non maintenant donc)
set proc_path [lindex [info level 0] 0]
# Si la proc est appeler sans subcommand, nous signalons qu'elle nécessite une
if { ${subcommand} == "" } {
return -code error \
"wrong # args: should be \"${proc_path} subcommand ?arg ...?\""
}
# Si la subcommand n'existe pas dans les procs enfants, ont prévois de retourner la liste des procs existante dans le namespace courant (celle de la proc appelé )
if { [info commands ${proc_path}::${subcommand}] == "" } {
set subcommands_list [join [string map "${proc_path}:: \"\"" [info procs ${proc_path}::*]] ", "]
return -code error \
"wrong ${proc_path} unknown or ambiguous subcommand \"${subcommand}\": must be ${subcommands_list}"
}
# si la subcommand existe, on l'execute avec les valeurs fournis
${proc_path}::${subcommand} {*}${args}
}
# ici nous sommes sorties de la création de la proc, et de retour dans la boucle enfant, nous allons exporté les proc
namespace export *
# Nous allons répéter ces opérations dans le niveau inferieur/enfants (dans ::example::text et ::example::text2)
create_sub_procs ${child_name}
}
# fin de la boucle
}
# Nous exécutons la recette dans notre namespace courant
create_sub_procs [namespace current]
Outroduction
Voilà; personnellement je l'ai créer pour mon propre toolkit et ses fonctions. Si ca peut vous servir tant mieux
Je laisse libre droits sur mon thread a tout modérateurs de eggdrop.fr, vous pouvez l'éditer, supprimer, déplacer, critiqué etc a volonté …
Retrouvez les dernières modifications de mes scripts TCL (versions Alpha/Bêta) ainsi que d'autres de mes réalisations sur ma page GitHub et les versions stables dans la section scripts de ce site 8-)
