call_traits.txt

                 
   CALL_TRAITS   
                 

USAGE GENERAL ==>       #Initialise les traits d'une classe à template ou trait class.
                        #Les typedefs peuvent ensuite être utilisés dans la classe avec la fonction attendue :
                        #  - reference : attend une rvalue modifiable, par exemple type renvoyé par operator[]
                        #  - const reference : attend une référence const, par exemple type renvoyé par const getters (const
                        #    overload)
                        #  - value : là où veut une copie, par exemple type renvoyé par getters, ou les CLASSDT de la classe.
                        #  - param_type : à passer aux getters qu'on appelle dans la classe.
                        #Plus safe que d'utiliser des typedef T& reference, etc. car :
                        #  - value_type évite erreur si utilisé comme return value et que T est un type d'array statique
                        #  - reference et const_reference évitent double références
                        #  - param_type permet d'avoir le type le plus efficient pour les getters quel que soit T
                        #Préférer renommer les typedefs avec mêmes noms.

call_traits<T>::        #Typedef depuis T sauf :
value_type              #  - si T est array statique, devient pointeur, ce qui permet :
                        #    - de l'utiliser en return value
                        #    - de faire une copy construction (interdite pour les arrays statiques)
call_traits<T>::        #Typedef depuis T& sauf :
reference               #  - si T est déjà une référence, évite une double référence (compile-time error)
call_traits<T>::        #Typedef depuis T const& sauf :
const_reference         #  - même chose que dessus pour référence
call_traits<T>::        #Typedef depuis un bon type pour une fonction getter :
param_type              #  - si non-const reference -> comme ...::reference
                        #  - sinon : T const&, sauf pour les types builtins, ou c'est juste T const (car & ne fait pas gagner 
                        #    de temps)
                        #S'agit donc du type préférable pour passer les fonctions getter : 
                        #  - si template avec référence, cela signifie que l'on souhaite passer par référence
                        #  - pour les arrays statiques, applique aussi la même correction que value_type, avec un const en
                        #    plus : [non-const] array -> TYPE const* const (passage par adresse)
                        #  - sinon, cela signifie que l'on a un type convertible vers const&, qui est le meilleur type possible
                        #    pour un getter (hors builtins, où & est inutile, et est même moins performant car empêche 
                        #    le CPU aliasing)