Référence de la classe Castor::Policy< T > (modèle)

Politique pour différents types. Plus de détails...

Liste de tous les membres

Fonctions membres publiques statiques
static value_type	zero ()
static value_type	unit ()
static void	init (value_type &p_a)
	Initialise La variable donnée à la valeur neutre.
static bool	is_null (param_type p_a)
	Teste si le param donné est égal à la valeur neutre.
static value_type	negate (param_type p_a)
static value_type &	ass_negate (value_type &p_a)
static value_type	parse (String const &p_str)
	Extrait une valeur du type donné à partir d'une chaîne de caractères.
static void	stick (value_type &p_a)
	Si le type est un type flottant, arrondit le paramètre, sinon ne fait rien.
template<typename Ty >
static value_type	convert (Ty const &p_value)
	Convertit un param d'un type donné vers le type template de cette classe.
template<typename Ty >
static bool	equals (param_type p_a, Ty const &p_b)
	Teste l'égalité entre 2 params de type différent, utilise std::numeric_limits::epsilon pour faire le test.
template<typename Ty >
static value_type	add (param_type p_a, Ty const &p_b)
	Additionne 2 param de type différent, retourne le résultat.
template<typename Ty >
static value_type	substract (param_type p_a, Ty const &p_b)
	Soustrait 2 param de type différent, retourne le résultat.
template<typename Ty >
static value_type	multiply (param_type p_a, Ty const &p_b)
	Multiplie 2 param de type différent, retourne le résultat.
template<typename Ty >
static value_type	divide (param_type p_a, Ty const &p_b)
	Divise 2 param de type différent, retourne le résultat.
template<typename Ty >
static value_type &	ass_add (value_type &p_a, Ty const &p_b)
	Additionne 2 param de type différent, retourne le résultat.
template<typename Ty >
static value_type &	ass_substract (value_type &p_a, Ty const &p_b)
	Soustrait 2 param de type différent, retourne le résultat.
template<typename Ty >
static value_type &	ass_multiply (value_type &p_a, Ty const &p_b)
	Multiplie 2 param de type différent, retourne le résultat.
template<typename Ty >
static value_type &	ass_divide (value_type &p_a, Ty const &p_b)
	Divise 2 param de type différent, retourne le résultat.
template<typename Ty >
static value_type &	assign (value_type &p_a, Ty const &p_b)
	Convertit le second param et affecte le résultat au premier.

---

Description détaillée

template<typename T>
class Castor::Policy< T >

Politique pour différents types.

Auteur:

Sylvain DOREMUS

Version:

0.6.1.0

Date:

19/10/2011

Remarques:

Police créée pour utiliser différents types dans les classes template Point, Matrix, ...
Contient des opérateurs, fonctions d'initialisation, de conversion, ...

---

Documentation des fonctions membres

template<typename T >

template<typename Ty >

static value_type Castor::Policy< T >::add	(	param_type	p_a,
		Ty const &	p_b
	)			[inline, static]

Additionne 2 param de type différent, retourne le résultat.

Paramètres:

[in]	p_a	Le premier param
[in]	p_b	Le second param, converti dans le type de p_a avant l'addition

Renvoie:

Le résultat de l'addition

template<typename T >

template<typename Ty >

static value_type& Castor::Policy< T >::ass_add	(	value_type &	p_a,
		Ty const &	p_b
	)			[inline, static]

Additionne 2 param de type différent, retourne le résultat.

Remarques:

Le premier param reçoit le résultat

Paramètres:

[in,out]	p_a	Le premier param, reçoit le résultat
[in]	p_b	Le second param, converti dans le type de p_a avant l'addition

Renvoie:

La référence sur le premier param

Voici le graphe d'appel pour cette fonction :

template<typename T >

template<typename Ty >

static value_type& Castor::Policy< T >::ass_divide	(	value_type &	p_a,
		Ty const &	p_b
	)			[inline, static]

Divise 2 param de type différent, retourne le résultat.

Remarques:

Le premier param reçoit le résultat

Paramètres:

[in,out]	p_a	Le premier param, reçoit le résultat
[in]	p_b	Le second param, converti dans le type de p_a avant la division

Renvoie:

La référence sur le premier param

Voici le graphe d'appel pour cette fonction :

template<typename T >

template<typename Ty >

static value_type& Castor::Policy< T >::ass_multiply	(	value_type &	p_a,
		Ty const &	p_b
	)			[inline, static]

Multiplie 2 param de type différent, retourne le résultat.

Remarques:

Le premier param reçoit le résultat

Paramètres:

[in,out]	p_a	Le premier param, reçoit le résultat
[in]	p_b	Le second param, converti dans le type de p_a avant la multiplication

Renvoie:

La référence sur le premier param

Voici le graphe d'appel pour cette fonction :

template<typename T >

static value_type& Castor::Policy< T >::ass_negate

(

value_type &

p_a

)

[inline, static]

Paramètres:

[in,out]

p_a

La valeur à négativer, reçoit la valeur négativée

Renvoie:

Référence sur le paramètre

Voici le graphe d'appel pour cette fonction :

template<typename T >

template<typename Ty >

static value_type& Castor::Policy< T >::ass_substract	(	value_type &	p_a,
		Ty const &	p_b
	)			[inline, static]

Soustrait 2 param de type différent, retourne le résultat.

Remarques:

Le premier param reçoit le résultat

Paramètres:

[in,out]	p_a	Le premier param, reçoit le résultat
[in]	p_b	Le second param, converti dans le type de p_a avant la soustraction

Renvoie:

La référence sur le premier param

Voici le graphe d'appel pour cette fonction :

template<typename T >

template<typename Ty >

static value_type& Castor::Policy< T >::assign	(	value_type &	p_a,
		Ty const &	p_b
	)			[inline, static]

Convertit le second param et affecte le résultat au premier.

Paramètres:

[in,out]	p_a	Le premier param, reçoit le second param converti
[in]	p_b	Le second param

Renvoie:

La référence sur le premier param

Voici le graphe d'appel pour cette fonction :

template<typename T >

template<typename Ty >

static value_type Castor::Policy< T >::convert

(

Ty const &

p_value

)

[inline, static]

Convertit un param d'un type donné vers le type template de cette classe.

Paramètres:

[in]

p_value

La valeur à convertir

Renvoie:

La valeur convertie (static_cast)

template<typename T >

template<typename Ty >

static value_type Castor::Policy< T >::divide	(	param_type	p_a,
		Ty const &	p_b
	)			[inline, static]

Divise 2 param de type différent, retourne le résultat.

Paramètres:

[in]	p_a	Le premier param
[in]	p_b	Le second param, converti dans le type de p_a avant la division

Renvoie:

Le résultat de la division

template<typename T >

template<typename Ty >

static bool Castor::Policy< T >::equals	(	param_type	p_a,
		Ty const &	p_b
	)			[inline, static]

Teste l'égalité entre 2 params de type différent, utilise std::numeric_limits::epsilon pour faire le test.

Paramètres:

[in]	p_a	Le premier param, dont le type est pris comme argument template de std::numeric_limits
[in]	p_b	Le second param, converti dans le type de \ p_a avant la comparaison

Renvoie:

Le résultat de la comparaison

Voici le graphe d'appel pour cette fonction :

Voici le graphe d'appel pour cette fonction :

template<typename T >

static void Castor::Policy< T >::init

(

value_type &

p_a

)

[inline, static]

Initialise La variable donnée à la valeur neutre.

Paramètres:

[in]

p_a

La variable à initialiser

Voici le graphe d'appel pour cette fonction :

Voici le graphe d'appel pour cette fonction :

template<typename T >

static bool Castor::Policy< T >::is_null

(

param_type

p_a

)

[inline, static]

Teste si le param donné est égal à la valeur neutre.

Paramètres:

[in]

p_a

La valeur à tester

Renvoie:

Le résultat du test

Voici le graphe d'appel pour cette fonction :

Voici le graphe d'appel pour cette fonction :

template<typename T >

template<typename Ty >

static value_type Castor::Policy< T >::multiply	(	param_type	p_a,
		Ty const &	p_b
	)			[inline, static]

Multiplie 2 param de type différent, retourne le résultat.

Paramètres:

[in]	p_a	Le premier param
[in]	p_b	Le second param, converti dans le type de p_a avant la multiplication

Renvoie:

Le résultat de la multiplication

template<typename T >

static value_type Castor::Policy< T >::negate

(

param_type

p_a

)

[inline, static]

Paramètres:

[in]

p_a

La valeur à négativer

Renvoie:

La valeur négativée du param (opposé de la valeur, relativement à la valeur neutre)

Voici le graphe d'appel pour cette fonction :

template<typename T >

static value_type Castor::Policy< T >::parse

(

String const &

p_str

)

[inline, static]

Extrait une valeur du type donné à partir d'une chaîne de caractères.

Paramètres:

[in]

p_str

La chaîne de caractères contenant la valeur à extraire

Renvoie:

La valeur récupérée, neutre si invalide

template<typename T >

static void Castor::Policy< T >::stick

(

value_type &

p_a

)

[inline, static]

Si le type est un type flottant, arrondit le paramètre, sinon ne fait rien.

Paramètres:

[in]

p_a

La valeur à arrondir

Voici le graphe d'appel pour cette fonction :

template<typename T >

template<typename Ty >

static value_type Castor::Policy< T >::substract	(	param_type	p_a,
		Ty const &	p_b
	)			[inline, static]

Soustrait 2 param de type différent, retourne le résultat.

Paramètres:

[in]	p_a	Le premier param
[in]	p_b	Le second param, converti dans le type de p_a avant la soustraction

Renvoie:

Le résultat de la soustraction

template<typename T >

static value_type Castor::Policy< T >::unit

(

)

[inline, static]

Renvoie:

La valeur unitaire pour le type

template<typename T >

static value_type Castor::Policy< T >::zero

(

)

[inline, static]

Renvoie:

La valeur neutre pour le type

Voici le graphe d'appel pour cette fonction :

---

La documentation de cette classe a été générée à partir du fichier suivant :

• include/CastorUtils/Templates.hpp