SPIP

criteres.php

SPIP, Système de publication pour l'internet

Ce programme est un logiciel libre distribué sous licence GNU/GPL.

Constants

_CODE_QUOTE = ",^(\n//[^\n]*\n)? *'(.*)' *\$,": Une Regexp repérant une chaine produite par le compilateur, souvent utilisée pour faire de la concaténation lors de la compilation plutôt qu'à l'exécution, i.e. pour remplacer 'x'.'y' par 'xy'

Functions

critere_racine_dist() : mixed: Compile le critère {racine}
critere_exclus_dist() : void|array<string|int, mixed>: Compile le critère {exclus}
critere_doublons_dist() : void|array<string|int, mixed>: Compile le critère {doublons} ou {unique}
critere_lang_select_dist() : mixed: Compile le critère {lang_select}
critere_debut_dist() : mixed: Compile le critère {debut_xxx}
critere_pagination_dist() : mixed: Compile le critère `pagination` qui demande à paginer une boucle.
critere_recherche_dist() : mixed: Compile le critère `recherche` qui permet de sélectionner des résultats d'une recherche.
critere_traduction_dist() : mixed: Compile le critère `traduction`
critere_origine_traduction_dist() : mixed: Compile le critère {origine_traduction}
critere_meme_parent_dist() : void|array<string|int, mixed>: Compile le critère {meme_parent}
critere_branche_dist() : mixed: Compile le critère `branche` qui sélectionne dans une boucle les éléments appartenant à une branche d'une rubrique.
critere_logo_dist() : mixed: Compile le critère `logo` qui liste les objets qui ont un logo
critere_groupby_dist() : void|array<string|int, mixed>: Compile le critère `groupby` qui regroupe les éléments selon une colonne.
critere_groupby_supprimer_dist() : void: Compile le critère `groupby_supprimer` qui supprime toutes les fusions qui le précèdent
critere_fusion_dist() : void|array<string|int, mixed>: Compile le critère `fusion` qui regroupe les éléments selon une colonne.
critere_fusion_supprimer_dist() : void: Compile le critère `fusion_supprimer` qui supprime toutes les fusions qui le précèdent
critere_collate_dist() : void|array<string|int, mixed>: Compile le critère `{collate}` qui permet de spécifier l'interclassement à utiliser pour les tris de la boucle.
critere_collecte_dist() : void|array<string|int, mixed>: Compile le critère `{collecte}` qui permet de spécifier l'interclassement à utiliser pour les tris de la boucle.
calculer_critere_arg_dynamique() : mixed
critere_par_dist() : mixed: Compile le critère `{par}` qui permet d'ordonner les résultats d'une boucle
critere_parinverse() : mixed: Calculs pour le critère `{par}` ou `{inverse}` pour ordonner les résultats d'une boucle
calculer_critere_par_hasard() : string: Calculs pour le critère `{par hasard}`
calculer_critere_par_expression_num() : string|array<string|int, mixed>: Calculs pour le critère `{par num champ}` qui extrait le numéro préfixant un texte
calculer_critere_par_expression_sinum() : string|array<string|int, mixed>: Calculs pour le critère `{par sinum champ}` qui ordonne les champs avec numéros en premier
calculer_critere_par_expression_multi() : string|array<string|int, mixed>: Calculs pour le critère `{par multi champ}` qui extrait la langue en cours dans les textes ayant des balises `<multi>` (polyglottes)
calculer_critere_par_champ() : array<string|int, mixed>|string: Retourne le champ de tri demandé en ajoutant éventuellement les jointures nécessaires à la boucle.
critere_inverse_dist() : mixed: Compile le critère `{inverse}` qui inverse l'ordre utilisé par le précédent critère `{par}`
critere_par_ordre_liste_dist() : void|array<string|int, mixed>: {par_ordre_liste champ,#LISTE{...}} pour trier selon une liste en retournant en premier les éléments de la liste
critere_agenda_dist() : mixed
calculer_critere_parties() : mixed: Compile les critères {i,j} et {i/j}
calculer_parties() : mixed: Compile certains critères {i,j} et {i/j}
calculer_critere_parties_aux() : array<string|int, mixed>: Analyse un des éléments des critères {a,b} ou {a/b}
calculer_criteres() : string|array<string|int, mixed>: Compile les critères d'une boucle
kwote() : string: Désemberlificote les guillements et échappe (ou fera échapper) le contenu... Madeleine de Proust, revision MIT-1958 sqq, revision CERN-1989 hum, c'est kwoi cette fonxion ? on va dire qu'elle desemberlificote les guillemets.
critere_IN_dist() : void|array<string|int, mixed>: Compile un critère possédant l'opérateur IN : {xx IN yy}
critere_IN_cas() : mixed
critere_where_dist() : mixed: Compile le critère {where}
critere_having_dist() : mixed: Compile le critère {having}
critere_id__dist() : mixed: Compile le critère `{id_?}`
lister_champs_id_conditionnel() : array<string|int, mixed>: Liste les champs qui peuvent servir de selection conditionnelle à une table SQL
critere_tri_dist() : mixed: Compile le critère `{tri}` permettant le tri dynamique d'un champ
calculer_critere_DEFAUT_dist() : void|array<string|int, mixed>: Compile un critère non déclaré explicitement
calculer_critere_DEFAUT_args() : mixed: Compile un critère non déclaré explicitement, dont on reçoit une analyse
calculer_critere_infixe() : array<string|int, mixed>|string: Décrit un critère non déclaré explicitement
calculer_critere_infixe_externe() : array<string|int, mixed>|string: Décrit un critère non déclaré explicitement, sur un champ externe à la table
primary_doublee() : array<string|int, string>: Calcule une condition WHERE entre un nom du champ et une valeur
calculer_critere_externe_init() : string: Champ hors table, ça ne peut être qu'une jointure.
calculer_lien_externe_init() : string: Générer directement une jointure via une table de lien spip_xxx_liens pour un critère {id_xxx}
trouver_champ() : bool: Recherche la présence d'un champ dans une valeur de tableau
calculer_critere_infixe_ops() : array<string|int, mixed>: Détermine l'operateur et les opérandes d'un critère non déclaré
calculer_vieux_in() : mixed
calculer_critere_infixe_date() : string|array<string|int, mixed>: Calcule les cas particuliers de critères de date
calculer_param_date() : string: Calcule l'expression SQL permettant de trouver un nombre de jours écoulés.
critere_DATA_source_dist() : mixed: Compile le critère {source} d'une boucle DATA
critere_DATA_datacache_dist() : mixed: Compile le critère {datacache} d'une boucle DATA
critere_php_args_dist() : mixed: Compile le critère {args} d'une boucle PHP
critere_DATA_liste_dist() : mixed: Compile le critère {liste} d'une boucle DATA
critere_DATA_enum_dist() : mixed: Compile le critère {enum} d'une boucle DATA
critere_DATA_datapath_dist() : mixed: Compile le critère {datapath} d'une boucle DATA
critere_si_dist() : mixed: Compile le critère {si}
critere_noeud_dist() : mixed: Compile le critère {noeud}
critere_feuille_dist() : mixed: Compile le critère {feuille}

_CODE_QUOTE

Une Regexp repérant une chaine produite par le compilateur, souvent utilisée pour faire de la concaténation lors de la compilation plutôt qu'à l'exécution, i.e. pour remplacer 'x'.'y' par 'xy'


    public
        mixed
    _CODE_QUOTE
    = ",^(\n//[^\n]*\n)? *'(.*)' *\$,"

critere_racine_dist()

Compile le critère {racine}


    
                    critere_racine_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Ce critère sélectionne les éléments à la racine d'une hiérarchie, c'est à dire ayant id_parent=0

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_exclus_dist()

Compile le critère {exclus}


    
                    critere_exclus_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : void|array<string|int, mixed>

Exclut du résultat l’élément dans lequel on se trouve déjà

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Return values

void|array<string|int, mixed>

critere_doublons_dist()

Compile le critère {doublons} ou {unique}


    
                    critere_doublons_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : void|array<string|int, mixed>

Ce critères enlève de la boucle les éléments déjà sauvegardés dans un précédent critère {doublon} sur une boucle de même table.

Il est possible de spécifier un nom au doublon tel que {doublons sommaire}

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Return values

void|array<string|int, mixed>

critere_lang_select_dist()

Compile le critère {lang_select}


    
                    critere_lang_select_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Ce critère indique d'utiliser la langue de l'objet de la boucle comme langue du contexte intérieur de la boucle.

Cela revient à faire [(#LANG|lang_select)] en tout début de boucle.

En conséquence, , <:idiome_langue:> et _T utiliseront la langue de l'objet au lieu de la langue du contexte global.

Certaines boucles telles que articles et rubriques ont ce comportement par défaut.

Le critère accepte un paramètre optionnel :

'' ou 'oui' pour activer ce comportement.
'non' pour désactiver ce comportement.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Tags

example

Ici #LANG est celle du contexte global, par exemple le français.
<BOUCLE(ARTICLES) {lang_select} {lang=en} {0,1}>
Ici les balises <multi> et cie sont en anglais, idem article.
</BOUCLE>
<BOUCLE(ARTICLES) {lang_select=non} {lang=en} {0,1}>
Ici les balises <multi> et cie sont en français, idem contexte global.
</BOUCLE>
Ici #LANG est le français.

critere_debut_dist()

Compile le critère {debut_xxx}


    
                    critere_debut_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Limite le nombre d'éléments affichés.

Ce critère permet de faire commencer la limitation des résultats par une variable passée dans l’URL et commençant par 'debut_' tel que {debut_page,10}. Le second paramètre est le nombre de résultats à afficher.

Note : il est plus simple d'utiliser le critère pagination.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_pagination_dist()

Compile le critère `pagination` qui demande à paginer une boucle.


    
                    critere_pagination_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Demande à paginer la boucle pour n'afficher qu'une partie des résultats, et gère l'affichage de la partie de page demandée par debut_xx dans dans l'environnement du squelette.

Le premier paramètre indique le nombre d'éléments par page, le second, rarement utilisé permet de définir le nom de la variable désignant la page demandée (debut_xx), qui par défaut utilise l'identifiant de la boucle.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Tags

critere

see

balise_PAGINATION_dist()

link

Le système de pagination

link

Le critère pagination

example

{pagination}
{pagination 20}
{pagination #ENV{pages,5}} etc
{pagination 20 #ENV{truc,chose}} pour utiliser la variable debut_#ENV{truc,chose}

critere_recherche_dist()

Compile le critère `recherche` qui permet de sélectionner des résultats d'une recherche.


    
                    critere_recherche_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Le texte cherché est pris dans le premier paramètre {recherche xx} ou à défaut dans la clé recherche de l'environnement du squelette.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_traduction_dist()

Compile le critère `traduction`


    
                    critere_traduction_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Sélectionne toutes les traductions de l'élément courant (la boucle englobante) en différentes langues (y compris l'élément englobant)

Équivalent à (id_trad>0 AND id_trad=id_trad(precedent)) OR id_xx=id_xx(precedent)

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_origine_traduction_dist()

Compile le critère {origine_traduction}


    
                    critere_origine_traduction_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Sélectionne les éléments qui servent de base à des versions traduites (par exemple les articles "originaux" sur une boucle articles)

Équivalent à (id_trad>0 AND id_xx=id_trad) OR (id_trad=0)

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_meme_parent_dist()

Compile le critère {meme_parent}


    
                    critere_meme_parent_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : void|array<string|int, mixed>

Sélectionne les éléments ayant le même parent que la boucle parente, c'est à dire les frères et sœurs.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Return values

void|array<string|int, mixed>

critere_branche_dist()

Compile le critère `branche` qui sélectionne dans une boucle les éléments appartenant à une branche d'une rubrique.


    
                    critere_branche_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Cherche l'identifiant de la rubrique en premier paramètre du critère {branche XX} s'il est renseigné, sinon, sans paramètre ({branche} tout court) dans les boucles parentes. On calcule avec lui la liste des identifiants de rubrique de toute la branche.

La boucle qui possède ce critère cherche une liaison possible avec la colonne id_rubrique, et tentera de trouver une jointure avec une autre table si c'est nécessaire pour l'obtenir.

Ce critère peut être rendu optionnel avec {branche ?} en remarquant cependant que le test s'effectue sur la présence d'un champ 'id_rubrique' sinon d'une valeur 'id_rubrique' dans l'environnement (et non 'branche' donc).

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_logo_dist()

Compile le critère `logo` qui liste les objets qui ont un logo


    
                    critere_logo_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_groupby_dist()

Compile le critère `groupby` qui regroupe les éléments selon une colonne.


    
                    critere_groupby_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : void|array<string|int, mixed>

C'est la commande SQL «GROUP BY»

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Tags

critere

link

https://www.spip.net/5166

example

 <BOUCLE_a(articles){groupby lang}>

note

Remplace {fusion}.

Return values

void|array<string|int, mixed>

critere_groupby_supprimer_dist()

Compile le critère `groupby_supprimer` qui supprime toutes les fusions qui le précèdent


    
                    critere_groupby_supprimer_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : void

Ce critère retire toutes les définitions de «GROUP BY» qui le précèdent. Par exemple pour en ajouter d'autres ensuite.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Tags

critere

example

 <BOUCLE_a(ARTICLES){gis}{groupby_supprimer}{groupby ville}

note

Remplace {fusion_supprimer}.

critere_fusion_dist()

Compile le critère `fusion` qui regroupe les éléments selon une colonne.

Utiliser {groupby}


    
                    critere_fusion_dist(mixed ...$args) : void|array<string|int, mixed>

Parameters

$args : mixed

Return values

void|array<string|int, mixed>

critere_fusion_supprimer_dist()

Compile le critère `fusion_supprimer` qui supprime toutes les fusions qui le précèdent

Utiliser {groupby_supprimer}


    
                    critere_fusion_supprimer_dist(mixed ...$args) : void

Parameters

$args : mixed

critere_collate_dist()

Compile le critère `{collate}` qui permet de spécifier l'interclassement à utiliser pour les tris de la boucle.


    
                    critere_collate_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : void|array<string|int, mixed>

Cela permet avec le critère {par} de trier un texte selon l'interclassement indiqué. L'instruction s'appliquera sur les critères {par} qui succèdent ce critère, ainsi qu'au critère {par} précédent si aucun interclassement ne lui est déjà appliqué.

Techniquement, c'est la commande SQL "COLLATE" qui utilisée. (elle peut être appliquée sur les order by, group by, where, like ...)

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Return values

void|array<string|int, mixed>

critere_collecte_dist()

Compile le critère `{collecte}` qui permet de spécifier l'interclassement à utiliser pour les tris de la boucle.

Utiliser {collate}


    
                    critere_collecte_dist(mixed ...$args) : void|array<string|int, mixed>

Parameters

$args : mixed

Return values

void|array<string|int, mixed>

calculer_critere_arg_dynamique()


    
                    calculer_critere_arg_dynamique(mixed $idb, mixed &$boucles, mixed $crit[, mixed $suffix = '' ]) : mixed

Parameters

$idb : mixed
$boucles : mixed
$crit : mixed
$suffix : mixed = ''

critere_par_dist()

Compile le critère `{par}` qui permet d'ordonner les résultats d'une boucle


    
                    critere_par_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Demande à trier la boucle selon certains champs (en SQL, la commande ORDER BY). Si plusieurs tris sont demandés (plusieurs fois le critère {par x}{par y} dans une boucle ou plusieurs champs séparés par des virgules dans le critère {par x, y, z}), ils seront appliqués dans l'ordre.

Quelques particularités :

{par hasard} : trie par hasard
{par num titre} : trie par numéro de titre
{par multi titre} : trie par la langue extraite d'une balise polyglotte <multi> sur le champ titre
{!par date} : trie par date inverse en utilisant le champ date principal déclaré pour la table (si c'est un objet éditorial).
{!par points} : trie par pertinence de résultat de recherche (avec le critère {recherche})
{par FUNCTION_SQL(n)} : trie en utilisant une fonction SQL (peut dépendre du moteur SQL utilisé). Exemple : {par SUBSTRING_INDEX(titre, ".", -1)} (tri ~ alphabétique en ignorant les numéros de titres (exemple erroné car faux dès qu'un titre possède un point.)).
{par table.champ} : trie en effectuant une jointure sur la table indiquée.
{par #BALISE} : trie sur la valeur retournée par la balise (doit être un champ de la table, ou 'hasard').

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_parinverse()

Calculs pour le critère `{par}` ou `{inverse}` pour ordonner les résultats d'une boucle


    
                    critere_parinverse(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Les expressions intermédiaires {par expr champ} sont calculées dans des fonctions calculer_critere_par_expression_{expr}() notamment {par num champ} ou {par multi champ}.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

calculer_critere_par_hasard()

Calculs pour le critère `{par hasard}`


    
                    calculer_critere_par_hasard(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : string

Ajoute le générateur d'aléatoire au SELECT de la boucle.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Return values

string —

Clause pour le Order by

calculer_critere_par_expression_num()

Calculs pour le critère `{par num champ}` qui extrait le numéro préfixant un texte


    
                    calculer_critere_par_expression_num(string $idb, array<string|int, mixed> &$boucles, Critere $crit, array<string|int, mixed> $tri, string $champ) : string|array<string|int, mixed>

Tri par numéro de texte (tel que "10. titre"). Le numéro calculé est ajouté au SELECT de la boucle. L'écriture {par num #ENV{tri}} est aussi prise en compte.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle
$tri : array<string|int, mixed>: Paramètre en cours du critère
$champ : string: texte suivant l'expression ('titre' dans {par num titre})

Return values

string|array<string|int, mixed> —

Clause pour le Order by (array si erreur)

calculer_critere_par_expression_sinum()

Calculs pour le critère `{par sinum champ}` qui ordonne les champs avec numéros en premier


    
                    calculer_critere_par_expression_sinum(string $idb, array<string|int, mixed> &$boucles, Critere $crit, array<string|int, mixed> $tri, string $champ) : string|array<string|int, mixed>

Ajoute au SELECT la valeur 'sinum' qui vaut 0 si le champ a un numéro, 1 s'il n'en a pas. Ainsi {par sinum titre, num titre, titre} mettra les éléments sans numéro en fin de liste, contrairement à {par num titre, titre} seulement.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle
$tri : array<string|int, mixed>: Paramètre en cours du critère
$champ : string: texte suivant l'expression ('titre' dans {par sinum titre})

Return values

string|array<string|int, mixed> —

Clause pour le Order by (array si erreur)

calculer_critere_par_expression_multi()

Calculs pour le critère `{par multi champ}` qui extrait la langue en cours dans les textes ayant des balises `<multi>` (polyglottes)


    
                    calculer_critere_par_expression_multi(string $idb, array<string|int, mixed> &$boucles, Critere $crit, array<string|int, mixed> $tri, string $champ) : string|array<string|int, mixed>

Ajoute le calcul du texte multi extrait dans le SELECT de la boucle. Il ne peut y avoir qu'un seul critère de tri multi par boucle.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle
$tri : array<string|int, mixed>: Paramètre en cours du critère
$champ : string: texte suivant l'expression ('titre' dans {par multi titre})

Return values

string|array<string|int, mixed> —

Clause pour le Order by (array si erreur)

calculer_critere_par_champ()

Retourne le champ de tri demandé en ajoutant éventuellement les jointures nécessaires à la boucle.


    
                    calculer_critere_par_champ(string $idb, array<string|int, mixed> &$boucles, Critere $crit, string $par[, bool $raw = false ]) : array<string|int, mixed>|string

si le champ existe dans la table, on l'utilise
si c'est une exception de jointure, on l'utilise (et crée la jointure au besoin)
si c'est un champ dont la jointure est déjà présente on la réutilise
si c'est un champ dont la jointure n'est pas présente, on la crée.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle
$par : string: Nom du tri à analyser ('champ' ou 'table.champ')
$raw : bool = false: Retourne le champ pour le compilateur ("'alias.champ'") ou brut ('alias.champ')

Return values

array<string|int, mixed>|string

critere_inverse_dist()

Compile le critère `{inverse}` qui inverse l'ordre utilisé par le précédent critère `{par}`


    
                    critere_inverse_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Accèpte un paramètre pour déterminer le sens : {inverse #X} utilisera un tri croissant (ASC) si la valeur retournée par #X est considérée vrai (true), le sens contraire (DESC) sinon.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_par_ordre_liste_dist()

{par_ordre_liste champ,#LISTE{...}} pour trier selon une liste en retournant en premier les éléments de la liste


    
                    critere_par_ordre_liste_dist(string $idb, array<string, Boucle> &$boucles, Critere $crit) : void|array<string|int, mixed>

Parameters

$idb : string
$boucles : array<string, Boucle>
$crit : Critere

Return values

void|array<string|int, mixed>

critere_agenda_dist()


    
                    critere_agenda_dist(mixed $idb, mixed &$boucles, mixed $crit) : mixed

Parameters

$idb : mixed
$boucles : mixed
$crit : mixed

calculer_critere_parties()

Compile les critères {i,j} et {i/j}


    
                    calculer_critere_parties(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Le critère {i,j} limite l'affiche de la boucle en commançant l'itération au i-ème élément, et pour j nombre d'éléments. Le critère {n-i,j} limite en commençant au n moins i-ème élément de boucle Le critère {i,n-j} limite en terminant au n moins j-ème élément de boucle.

Le critère {i/j} affiche une part d'éléments de la boucle. Commence à i*n/j élément et boucle n/j éléments. {2/4} affiche le second quart des éléments d'une boucle.

Traduit si possible (absence de n dans {i,j}) la demande en une expression LIMIT du gestionnaire SQL

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

calculer_parties()

Compile certains critères {i,j} et {i/j}


    
                    calculer_parties(array<string|int, mixed> &$boucles, string $id_boucle, string $debut, string $mode[, string $total_parties = null ]) : mixed

Calcule une expression déterminant $debut_boucle et $fin_boucle (le début et la fin des éléments de la boucle qui doivent être affichés) et les déclare dans la propriété «mode_partie» de la boucle, qui se charge également de déplacer le pointeur de boucle sur le premier élément à afficher.

Place dans la propriété partie un test vérifiant que l'élément de boucle en cours de lecture appartient bien à la plage autorisée. Trop tôt, passe à l'élément suivant, trop tard, sort de l'itération de boucle.

Parameters

$boucles : array<string|int, mixed>

AST du squelette

$id_boucle : string

Identifiant de la boucle

$debut : string

Valeur ou code pour trouver le début (i dans {i,j})

$mode : string

Mode (++, p+, +- ...) : 2 signes début & fin

le signe - indique -- qu'il faut soustraire debut du total {n-3,x}. 3 étant $debut -- qu'il faut raccourcir la fin {x,n-3} de 3 elements. 3 étant $total_parties
le signe p indique une pagination

$total_parties : string = null

Valeur ou code pour trouver la fin (j dans {i,j})

calculer_critere_parties_aux()

Analyse un des éléments des critères {a,b} ou {a/b}


    
                    calculer_critere_parties_aux(string $idb, array<string|int, mixed> &$boucles, array<string|int, mixed> $param) : array<string|int, mixed>

Pour l'élément demandé (a ou b) retrouve la valeur de l'élément, et de combien il est soustrait si c'est le cas comme dans {a-3,b}

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$param : array<string|int, mixed>: Paramètre à analyser (soit a, soit b dans {a,b} ou {a/b})

Return values

array<string|int, mixed> —

Valeur de l'élément (peut être une expression PHP), Nombre soustrait

calculer_criteres()

Compile les critères d'une boucle


    
                    calculer_criteres(string $idb, array<string|int, mixed> &$boucles) : string|array<string|int, mixed>

Cette fonction d'aiguillage cherche des fonctions spécifiques déclarées pour chaque critère demandé, dans l'ordre ci-dessous :

critere_{serveur}{table}{critere}, sinon avec _dist
critere_{serveur}_{critere}, sinon avec _dist
critere_{table}_{critere}, sinon avec _dist
critere_{critere}, sinon avec _dist
calculer_critere_defaut, sinon avec _dist

Émet une erreur de squelette si un critère retourne une erreur.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette

Return values

string|array<string|int, mixed> —

string : Chaine vide sans erreur array : Erreur sur un des critères

kwote()

Désemberlificote les guillements et échappe (ou fera échapper) le contenu... Madeleine de Proust, revision MIT-1958 sqq, revision CERN-1989 hum, c'est kwoi cette fonxion ? on va dire qu'elle desemberlificote les guillemets.


    
                    kwote(string $lisp[, string $serveur = '' ][, string $type = '' ]) : string

Parameters

$lisp : string: Code compilé
$serveur : string = '': Connecteur de bdd utilisé
$type : string = '': Type d'échappement (char, int...)

Return values

string —

Code compilé rééchappé

critere_IN_dist()

Compile un critère possédant l'opérateur IN : {xx IN yy}


    
                    critere_IN_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : void|array<string|int, mixed>

Permet de restreindre un champ sur une liste de valeurs tel que {id_article IN 3,4} {id_article IN #LISTE{3,4}}

Si on a une liste de valeurs dans #ENV{x}, utiliser la double etoile pour faire par exemple {id_article IN #ENV**{liste_articles}}

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Return values

void|array<string|int, mixed>

critere_IN_cas()


    
                    critere_IN_cas(mixed $idb, mixed &$boucles, mixed $crit2, mixed $arg, mixed $op, mixed $val, mixed $col) : mixed

Parameters

$idb : mixed
$boucles : mixed
$crit2 : mixed
$arg : mixed
$op : mixed
$val : mixed
$col : mixed

critere_where_dist()

Compile le critère {where}


    
                    critere_where_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Ajoute une contrainte sql WHERE, tout simplement pour faire le pont entre php et squelettes, en utilisant la syntaxe attendue par la propriété $where d'une Boucle.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_having_dist()

Compile le critère {having}


    
                    critere_having_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Ajoute une contrainte sql HAVING, pour faire le pont entre php et squelettes, en utilisant la syntaxe attendue par la propriété $having d'une Boucle.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_id__dist()

Compile le critère `{id_?}`


    
                    critere_id__dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Ajoute automatiquement à la boucle des contraintes (nommées sélections conditionnelles) équivalentes à {id_article ?}{id_rubrique ?}..., adaptées à la table en cours d’utilisation.

Les champs sélectionnés par défaut sont :

chaque champ id_xx de la table en cours d’utilisation (par exemple id_secteur sur la boucle ARTICLES)
un champ 'objet', si cette table en dispose
chaque clé primaire des tables des objets éditoriaux, s’ils sont éditables et liables (par exemple id_mot).

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Tags

example

 <BOUCLE_liste_articles(ARTICLES){id_?}{tout}> ...
 Est équivalent (selon les plugins actifs) à :
 <BOUCLE_liste_articles(ARTICLES){id_article?}{id_rubrique?}{id_secteur?}{id_trad?}{id_mot?}{id_document?} ... {tout}> ...

uses

lister_champs_id_conditionnel()

Liste les champs qui peuvent servir de selection conditionnelle à une table SQL


    
                    lister_champs_id_conditionnel(string $table[, array<string|int, mixed>|null $desc = null ][, string $serveur = '' ]) : array<string|int, mixed>

Retourne, pour la table demandée :

chaque champ id_xx de la table en cours d’utilisation (par exemple id_secteur sur la boucle ARTICLES)
un champ 'objet' si la table le contient (pour les tables avec objet / id_objet par exemple)
chaque clé primaire des tables des objets éditoriaux qui peuvent se lier facilement à cette table, -- soit parce que sa clé primaire de la table demandée est un champ dans la table principale -- soit parce qu’une table de liaison existe, d’un côté ou de l’autre

Parameters

$table : string: Nom de la table SQL
$desc : array<string|int, mixed>|null = null: Description de la table SQL, si connu
$serveur : string = '': Connecteur sql a utiliser

Return values

array<string|int, mixed> —

Liste de nom de champs (tel que id_article, id_mot, id_parent ...)

critere_tri_dist()

Compile le critère `{tri}` permettant le tri dynamique d'un champ


    
                    critere_tri_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Le critère {tri} gère un champ de tri qui peut être modifié dynamiquement par la balise #TRI. Il s'utilise donc conjointement avec la balise #TRI dans la même boucle pour génerér les liens qui permettent de changer le critère de tri et le sens du tri

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Tags

syntaxe

{tri [champ_par_defaut][,sens_par_defaut][,nom_variable]}

champ_par_defaut : un champ de la table sql
sens_par_defaut : -1 ou inverse pour décroissant, 1 ou direct pour croissant peut être un tableau pour préciser des sens par défaut associés à chaque champ exemple : array('titre' => 1, 'date' => -1) pour trier par défaut les titre croissants et les dates décroissantes dans ce cas, quand un champ est utilisé pour le tri et n'est pas présent dans le tableau c'est la première valeur qui est utilisée
nom_variable : nom de la variable utilisée (par defaut tri_{nomboucle})

{tri titre} {tri titre,inverse} {tri titre,-1} {tri titre,-1,truc}

Exemple d'utilisation :

<B_articles>
<p>#TRI{titre,'Trier par titre'} | #TRI{date,'Trier par date'}</p>
<ul>
<BOUCLE_articles(ARTICLES){tri titre}>
 <li>#TITRE - [(#DATE|affdate_jourcourt)]</li>
</BOUCLE_articles>
</ul>
</B_articles>

note

Contraitement à {par ...}, {tri} ne peut prendre qu'un seul champ, mais il peut être complété avec {par ...} pour indiquer des criteres secondaires

Exemble : {tri num titre}{par titre} permet de faire un tri sur le rang (modifiable dynamiquement) avec un second critère sur le titre en cas d'égalité des rangs

link

https://www.spip.net/5429

see

critere_par_dist()

Le critère {par ...}

see

balise_TRI_dist()

La balise #TRI

calculer_critere_DEFAUT_dist()

Compile un critère non déclaré explicitement


    
                    calculer_critere_DEFAUT_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : void|array<string|int, mixed>

Compile les critères non déclarés, ainsi que les parties de boucles avec les critères {0,1} ou {1/2}

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Return values

void|array<string|int, mixed>

calculer_critere_DEFAUT_args()

Compile un critère non déclaré explicitement, dont on reçoit une analyse


    
                    calculer_critere_DEFAUT_args(string $idb, array<string|int, mixed> &$boucles, Critere $crit, array<string|int, mixed> $args) : mixed

Ajoute en fonction des arguments trouvés par calculer_critere_infixe() les conditions WHERE à appliquer sur la boucle.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle
$args : array<string|int, mixed>: Description du critère Cf. retour de calculer_critere_infixe()

calculer_critere_infixe()

Décrit un critère non déclaré explicitement


    
                    calculer_critere_infixe(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : array<string|int, mixed>|string

Décrit un critère non déclaré comme {id_article} {id_article>3} en retournant un tableau de l'analyse si la colonne (ou l'alias) existe vraiment.

Ajoute au passage pour chaque colonne utilisée (alias et colonne véritable) un modificateur['criteres'][colonne].

S'occupe de rechercher des exceptions, tel que

les id_parent, id_enfant, id_secteur,
des colonnes avec des exceptions déclarées,
des critères de date (jour_relatif, ...),
des critères sur tables jointes explicites (mots.titre),
des critères sur tables de jointure non explicite (id_mot sur une boucle articles...)

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Return values

array<string|int, mixed>|string —

Liste si on trouve le champ :

string $arg Opérande avant l'opérateur : souvent la colonne d'application du critère, parfois un calcul plus complexe dans le cas des dates.
string $op L'opérateur utilisé, tel que '='
string[] $val Liste de codes PHP obtenant les valeurs des comparaisons (ex: id_article sur la boucle parente) Souvent (toujours ?) un tableau d'un seul élément.
$col_alias
$where_complement

Chaîne vide si on ne trouve pas le champ...

calculer_critere_infixe_externe()

Décrit un critère non déclaré explicitement, sur un champ externe à la table


    
                    calculer_critere_infixe_externe(Boucle $boucle, Critere $crit, string $op, array<string|int, mixed> $desc, string $col, string $col_alias, string $table) : array<string|int, mixed>|string

Décrit un critère non déclaré comme {id_article} {id_article>3} qui correspond à un champ non présent dans la table, et donc à retrouver par jointure si possible.

Parameters

$boucle : Boucle: Description de la boucle
$crit : Critere: Paramètres du critère dans cette boucle
$op : string: L'opérateur utilisé, tel que '='
$desc : array<string|int, mixed>: Description de la table
$col : string: Nom de la colonne à trouver (la véritable)
$col_alias : string: Alias de la colonne éventuel utilisé dans le critère ex: id_enfant
$table : string: Nom de la table SQL de la boucle

Return values

array<string|int, mixed>|string —

Liste si jointure possible :

string $col
string $col_alias
string $table
array $where
array $desc

Chaîne vide si on ne trouve pas le champ par jointure...

primary_doublee()

Calcule une condition WHERE entre un nom du champ et une valeur


    
                    primary_doublee(array<string|int, mixed> $decompose, string $table) : array<string|int, string>

Ne pas appliquer sql_quote lors de la compilation, car on ne connait pas le serveur SQL

Parameters

$decompose : array<string|int, mixed>: Liste nom du champ, code PHP pour obtenir la valeur
$table : string: Nom de la table

Return values

array<string|int, string> —

Liste de 3 éléments pour une description where du compilateur :

operateur (=),
table.champ,
valeur

calculer_critere_externe_init()

Champ hors table, ça ne peut être qu'une jointure.


    
                    calculer_critere_externe_init(Boucle &$boucle, array<string|int, mixed> $joints, string $col, array<string|int, mixed> $desc, bool $cond[, bool|string $checkarrivee = false ]) : string

On cherche la table du champ et on regarde si elle est déjà jointe Si oui et qu'on y cherche un champ nouveau, pas de jointure supplementaire Exemple: criteres {titre_mot=...}{type_mot=...} Dans les 2 autres cas ==> jointure (Exemple: criteres {type_mot=...}{type_mot=...} donne 2 jointures pour selectioner ce qui a exactement ces 2 mots-cles.

Parameters

$boucle : Boucle: Description de la boucle
$joints : array<string|int, mixed>: Liste de jointures possibles (ex: $boucle->jointures ou $boucle->jointures_explicites)
$col : string: Colonne cible de la jointure
$desc : array<string|int, mixed>: Description de la table
$cond : bool: Flag pour savoir si le critère est conditionnel ou non
$checkarrivee : bool|string = false: string : nom de la table jointe où on veut trouver le champ. n'a normalement pas d'appel sans $checkarrivee.

Return values

string —

Alias de la table de jointure (Lx) Vide sinon.

calculer_lien_externe_init()

Générer directement une jointure via une table de lien spip_xxx_liens pour un critère {id_xxx}


    
                    calculer_lien_externe_init(Boucle &$boucle, array<string|int, mixed> $joints, string $col, array<string|int, mixed> $desc, bool $cond[, bool|string $checkarrivee = false ]) : string

Parameters

$boucle : Boucle: Description de la boucle
$joints : array<string|int, mixed>: Liste de jointures possibles (ex: $boucle->jointures ou $boucle->jointures_explicites)
$col : string: Colonne cible de la jointure
$desc : array<string|int, mixed>: Description de la table
$cond : bool: Flag pour savoir si le critère est conditionnel ou non
$checkarrivee : bool|string = false: string : nom de la table jointe où on veut trouver le champ. n'a normalement pas d'appel sans $checkarrivee.

Return values

string —

Alias de la table de jointure (Lx)

trouver_champ()

Recherche la présence d'un champ dans une valeur de tableau


    
                    trouver_champ(string $champ, array<string|int, mixed> $where) : bool

Parameters

$champ : string: Expression régulière pour trouver un champ donné. Exemple : /\barticles.titre\b/
$where : array<string|int, mixed>: Tableau de valeurs dans lesquels chercher le champ.

Return values

bool —

true si le champ est trouvé quelque part dans $where false sinon.

calculer_critere_infixe_ops()

Détermine l'operateur et les opérandes d'un critère non déclaré


    
                    calculer_critere_infixe_ops(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : array<string|int, mixed>

Lorsque l'opérateur n'est pas explicite comme sur {id_article>0} c'est l'opérateur '=' qui est utilisé.

Traite les cas particuliers id_parent, id_enfant, date, lang

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

Return values

array<string|int, mixed> —

Liste :

string $fct Nom d'une fonction SQL sur le champ ou vide (ex: SUM)
string $col Nom de la colonne SQL utilisée
string $op Opérateur
string[] $val Liste de codes PHP obtenant les valeurs des comparaisons (ex: id_article sur la boucle parente) Souvent un tableau d'un seul élément.
string $args_sql Suite des arguments du critère. ?

calculer_vieux_in()


    
                    calculer_vieux_in(mixed $params) : mixed

Parameters

$params : mixed

calculer_critere_infixe_date()

Calcule les cas particuliers de critères de date


    
                    calculer_critere_infixe_date(string $idb, array<string|int, mixed> &$boucles, string $col) : string|array<string|int, mixed>

Lorsque la colonne correspond à un critère de date, tel que jour, jour_relatif, jour_x, age, age_relatif, age_x...

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$col : string: Nom du champ demandé

Return values

string|array<string|int, mixed> —

chaine vide si ne correspond pas à une date, sinon liste

expression SQL de calcul de la date,
nom de la colonne de date (si le calcul n'est pas relatif)

calculer_param_date()

Calcule l'expression SQL permettant de trouver un nombre de jours écoulés.


    
                    calculer_param_date(string $date_compare, string $date_orig) : string

Le calcul SQL retournera un nombre de jours écoulés entre la date comparée et la colonne SQL indiquée

Parameters

$date_compare : string: Code PHP permettant d'obtenir le timestamp référent. C'est à partir de lui que l'on compte les jours
$date_orig : string: Nom de la colonne SQL qui possède la date

Return values

string —

Expression SQL calculant le nombre de jours écoulé entre une valeur de colonne SQL et une date.

critere_DATA_source_dist()

Compile le critère {source} d'une boucle DATA


    
                    critere_DATA_source_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Permet de déclarer le mode d'obtention des données dans une boucle DATA (premier argument) et les données (la suite).

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_DATA_datacache_dist()

Compile le critère {datacache} d'une boucle DATA


    
                    critere_DATA_datacache_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Permet de transmettre une durée de cache (time to live) utilisée pour certaines sources d'obtention des données (par exemple RSS), indiquant alors au bout de combien de temps la donnée est à réobtenir.

La durée par défaut est 1 journée.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_php_args_dist()

Compile le critère {args} d'une boucle PHP


    
                    critere_php_args_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Permet de passer des arguments à un iterateur non-spip (PHP:xxxIterator){args argument1, argument2, argument3}

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_DATA_liste_dist()

Compile le critère {liste} d'une boucle DATA


    
                    critere_DATA_liste_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Passe une liste de données à l'itérateur DATA

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_DATA_enum_dist()

Compile le critère {enum} d'une boucle DATA


    
                    critere_DATA_enum_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Passe les valeurs de début et de fin d'une énumération, qui seront vues comme une liste d'autant d'éléments à parcourir pour aller du début à la fin.

Cela utilisera la fonction range() de PHP.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_DATA_datapath_dist()

Compile le critère {datapath} d'une boucle DATA


    
                    critere_DATA_datapath_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Extrait un chemin d'un tableau de données

(DATA){datapath query.results}

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_si_dist()

Compile le critère {si}


    
                    critere_si_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Le critère {si condition} est applicable à toutes les boucles et conditionne l'exécution de la boucle au résultat de la condition. La partie alternative de la boucle est alors affichée si une condition n'est pas remplie (comme lorsque la boucle ne ramène pas de résultat). La différence étant que si la boucle devait réaliser une requête SQL (par exemple une boucle ARTICLES), celle ci n'est pas réalisée si la condition n'est pas remplie.

Les valeurs de la condition sont forcément extérieures à cette boucle (sinon il faudrait l'exécuter pour connaître le résultat, qui doit tester si on exécute la boucle !)

Si plusieurs critères {si} sont présents, ils sont cumulés : si une seule des conditions n'est pas vérifiée, la boucle n'est pas exécutée.

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_noeud_dist()

Compile le critère {noeud}


    
                    critere_noeud_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Trouver tous les objets qui ont des enfants (les noeuds de l'arbre) {noeud} {!noeud} retourne les feuilles

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

critere_feuille_dist()

Compile le critère {feuille}


    
                    critere_feuille_dist(string $idb, array<string|int, mixed> &$boucles, Critere $crit) : mixed

Trouver tous les objets qui n'ont pas d'enfants (les feuilles de l'arbre) {feuille} {!feuille} retourne les noeuds

Parameters

$idb : string: Identifiant de la boucle
$boucles : array<string|int, mixed>: AST du squelette
$crit : Critere: Paramètres du critère dans cette boucle

criteres.php

Table of Contents

Constants

Functions

Constants

_CODE_QUOTE

Functions

critere_racine_dist()

Parameters

Tags

critere_exclus_dist()

Parameters

Tags

Return values

critere_doublons_dist()

Parameters

Tags

Return values

critere_lang_select_dist()

Parameters

Tags

critere_debut_dist()

Parameters

critere_pagination_dist()

Parameters

Tags

critere_recherche_dist()

Parameters

Tags

critere_traduction_dist()

Parameters

critere_origine_traduction_dist()

Parameters

critere_meme_parent_dist()

Parameters

Return values

critere_branche_dist()

Parameters

Tags

critere_logo_dist()

Parameters

Tags

critere_groupby_dist()

Parameters

Tags

Return values

critere_groupby_supprimer_dist()

Parameters

Tags

critere_fusion_dist()

Parameters

Return values

critere_fusion_supprimer_dist()

Parameters

critere_collate_dist()

Parameters

Tags

Return values

critere_collecte_dist()

Parameters

Return values

calculer_critere_arg_dynamique()

Parameters

critere_par_dist()

Parameters

Tags

critere_parinverse()

Parameters

Tags

calculer_critere_par_hasard()

Parameters

Tags

Return values

calculer_critere_par_expression_num()

Parameters

Tags

Return values

calculer_critere_par_expression_sinum()

Parameters

Tags