[PHP 5.3] [POO] Objet persistant qui perd la valeur de ces attributs [Résolu]

[Michel Rotta]

Bonjour,

Je cherche à créer un objet persistant. J'utilise symfony 1.4 et doctrine 1.2 ce qui peut expliquer certaines méthodes "bizarres" que je commenterais. Je pense que le problème est lié à mon architecture objet et pas à symfony ou doctrine c'est pourquoi je poste ici. Mais n’ayant pas trouvé l'origine...

Le problème est que les données ne sont pas persistantes. Pire, elle ne le sont même dans dans une même session.

Résumé de la classe parent :

Code :

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
 
abstract class mrParcour implements ArrayAccess, Serializable
{
  /**
  * @var Doctrine_Query
  */
  private $query_liste_base = null;
  ...
 
  public function __construct()
  {
    $this->configure();
  }
 
  abstract public function configure();
 
  public function setNameQueryListeBase( Doctrine_Query $q )
  {
    $this->query_liste_base = $q;
    // un test ici laisse voir que la propriété est initialisée
    return $this;
  }
 
   public function initParcour()
  {
    if ( !is_null( $this->listeParcour ) ) return;
 
    $q = new Doctrine_Query();
    $q->parseDqlQuery( $this->query_liste_base->getDql() );
    ...
    return $this;
    }
}

Le code d'initialisation de l'objet pour l'application. Il est bien exécuté à l'initialisation.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
class PersonneParcour extends mrParcour
{
 
  public function configure()
  {
    $this->setFiltreObjectNom( 'PersonneFormFilter' );
    // Crée une requête doctrine et l'envoie à la méthode setNQLB()
    $this->setNameQueryListeBase(
                    Doctrine_Core::getTable( 'Personne' )->
                    createQuery( 'p' )->
                    select( 'p.id' )
    );
  }
 
}

Un peu particulier à symfony, l'objet user possède un array d'argument qui est automatiquement sérializé dans les données sessions. C'est là qu'est sérialisé l'objet PersonneParcour et qu'il est récupéré

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class myUser extends sfGuardSecurityUser
{
  public function getPersonnesPager()
  {
    // Retourne le pager s'il est en mémoire, si non, le crée
    return $this->getAttribute('personnel_pager', new PersonneParcour());
  }
  public function setPersonnesPager( mrParcour $p)
  {
     $this->setAttribute('personnel_pager');
     return $this;
   }
}

a noter que l'objet mrParcour implémante l'interface serializable.

Enfin le contrôleur

Code :

1
2
3
4
5
6
7
8
 
  public function executeShow( sfWebRequest $request )
  {
    $this->parcour = $this->getUser()->getPersonnesPager();
    $this->parcour->setFilterOffset($request->getParameter('id') );
    $this->getUser()->setPersonnesPager( $this->parcour->initParcour() );
    ....
  }

Avec des echos et autres die j'ai une bonne vision de ce qui se passe :

1. Arrivée dans le contrôleur et récupération d'un objet.
2. Premier passage donc création d'un nouveau
3. - Initialisation du nouveau et méthode configure
4. - Initialisation de la variable interne à l'objet :query_liste_base
5. Imputation d'une autre valeur qui marche (l'imputation, je n'ai pas regardé la récupération).
6. le contrôleur initialise le parcour (initParcour et récupère l'objet pour une mise à jour dans la base
7. Dans l'objet, la variable query_liste_base est nul alors qu'elle contenait l'objet un peu plus tôt

A noter que j'ai essayé avec un champ texte et le résultat est null aussi.

La question est : pourquoi query_liste_base passe-t-il d'un objet lors de l'init à null un peu après ?
A noter que la méthode construct de l'objet n'est exécutée qu'une fois ce qui exclu que l'objet serait ré-instancié.

Quelqu'un a-t-il une idée de test et/ou d'explication ?
D'avance merci

[stealth35]

les classes sont bien serializable ?

[Michel Rotta]

MyUser oui, par héritage.
mrParcour c'est implémenté (je n'ai pas mis le code mais il y est)
le contrôleur non, mais cela n'a pas d'intérêt.

Dans tous les cas je n'essaye même pas de récupérer l'objet sérializé, j'en suis à la première lecture...

[rawsrc]

Bonjour,

Faute de frappe dans la classe myUser

Code :

$this->setAttrubute('personnel_pager');

[Michel Rotta]

Bien vu.

Mais une rapide vérification m'a confirmé ce que je craignais, c'est une faute de rédaction, je ne sais pas comment un copié collé peut transformer un i en u, mais je soupçonne fortement mes doigts d'avoirs trainés là où il n'auraient pas eu.

Le code comporte le bon nom de fonction. Et l'erreur aurait été facilement identifiable.

Je soupçonne plutôt une erreur dans la logique de l'objet mrParcour et/ou de son implémentation. Mais je n'ai toujours pas trouvé où.

[rawsrc]

Bonjour,

Serait-ce possible d'avoir le code complet de mrParcour ?

[Benjamin Delespierre]

Salut.

J'aimerai bien savoir si Doctrine_Query implémente sérializable. Et jeter un oeil à
mrParcour::__sleep et mrParcour::__wakeUp si possible.

[Michel Rotta]

Si dessous.

Je travail actuellement dessus, il n'est donc pas stable.
Les die() et autre echo sont du code lié au débug et n'entre pas dans la logique de l'objet.
L'objectif est d'avoir une zone navigation sur une partie des enregistrements d'une table avec la possibilité de passer au suivant, précédant premier, dernier courant dans le lot sans afficher de numéro d'enregistrement sur la page. De récupérer le sql du filtre et du tris pour afficher une liste. De limiter les recherches à une vue partiel de la base pour un quidam qui n'aurait accès qu'aux fiches de son bureau, immeuble, magasin, entrepôts, service, équipe...

Code php :

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
//mrParcour.class.php
/**
 * Description de mrParcour
 *
 * Cette classe est destinée à faciliter le parcours d'une table dans tous les
 * besoins d'accès possibles.
 *
 * Il est possible de définir :
 * - des filtres temporaires et permanents.
 * - trois select pour :
 *   - le parcours (parcourir les enregistrements sélectionnés, premier, dernier
 *     précédant, suivant, nombre d'enregistrement, position de l'enregistrement
 *     courant)
 *   - la liste (récupération d'une liste pour l'affichage d'un tableau de
 *     sélection d'un enregistrement)
 *   - le détail (récupération des informations nécessaires à l'édition d'un
 *     enregistrement
 * - les options de tris
 * - l'enregistrement courant
 *
 * Les données sont stockées pour partie dans la gestion de la session (filtre,
 * tris). Les données permettant le parcours sont stockées dans le cache pour
 * accélérer l'accès
 *
 * @author Michel Rotta pour Diag
 */
abstract class mrParcour implements ArrayAccess, Serializable
{
 
  /**
   * @var array()
   * Tableau des Id pour le parcour
   * non serializé
   */
  private $listeParcour = null;
  /**
   * offset du parcour (enregistrement courant)
   * @var integer
   */
  private $offSetActu = null;
  /**
   * Id de l'enregistrement actuel, null si non défini
   * @var integer
   */
  private $CurrentId = null;
  // ********** Gestion des données du filtre
  /**
   * @var sfFilter
   * objet filtre (non serializé)
   */
  private $filtre_object = null;
  /**
   * le nom du filtre. non attribué = null
   * @var string
   */
  private $filtre_nom = null;
  /**
   * @var string
   * le query du filtre (ou le querry généré par l'objet filtre
   * non attribué = null
   */
  private $filtre_query = null;
  /**
   * Les objets ayant permis au filtre de générer le query
   * non attribué = null
   * @var array
   */
  private $filtre_data = null;
  /**
   * Le query obligatoire pour tous les filtres (en plus du query généré)
   * non attribué = null
   * @var string
   */
  private $filtre_master_query = null;
  /**
   * le champ pour le tris
   * @var string
   */
  private $filtre_tris_champ = null;
  /**
   * l'ordre de tris
   * @var string
   */
  private $filtre_tris_ordre = null;
  /**
   * @var Doctrine_Query
   * l'objet de base pour le query permettant de peupler la liste. Positionne le
   * from et le select. Ne doit retourner qu'un champ clef. Il est possible de
   * prépositioner des conditions et des tris (le tris ont de forte chance d'être
   * remplacés.
   */
  private $query_liste_base = null;
  private $test = "aie";
 
  public function __construct()
  {
    echo 'construc object<br />';
    $this->configure();
  }
 
  /** configure
   * méthode appelée à l'initialisation de l'objet pour configurer son comportement
   */
  abstract public function configure();
 
  /**
   * Renseigne le query a utiliser pour récupérer les données nécessaire à la
   * construction de la liste de parcour.
   * @param Doctrine_Query $q Objet de départ pour la création du query.
   *                          Générallement avec un select et un form.
   *                          Il ne doit sélectioner qu'un champs.
   * @return object This object
   */
  public function setNameQueryListeBase( Doctrine_Query $q )
  {
    $this->query_liste_base = $q;
    echo('initialisé');
    $this->test = $this->query_liste_base->getDql();
    var_dump( $this->test );
    return $this;
  }
 
  /*   * *********************************************************************
   *   * Méthodes pour l'accès au parcour
   */
 
  /** findCurentId
   * @return mixed Retourne l'Id de l'enregistrement courant
   *               null si l'enregistrement courant n'est pas défini
   */
  public function findCurrentId()
  {
    return $this->CurrentId;
  }
 
  /** findPrecedId
   * Retourne l'Id de l'enregistrement précédant l'enregistrement courant.
   * Retourne null si l'enregistrement courant ne fait pas partie du scop de
   * parcour ou qu ele scop n'est pas défini
   * Retourne null si l'enregistrement courrant est le premier du scop
   * @return mixed l'Id de l'enregistrement précédant ou null
   */
  public function findPrecedId()
  {
    if ( $this->CurrentId or !$this->offSetActu or 0 == $this->offSetActu )
    {
      return null;
    }
    return $this[ $this->offSetActu - 1 ];
  }
 
  /** findSuivId
   * Retourne l'Id de l'enregistrement suivant l'enregistrement courant.
   * Retourne null si l'enregistrement courant ne fait pas partie du scop de
   * parcour ou que le scop n'est pas défini.
   * Retourne null si l'enregistrement courant est le dernier du scop
   * @return mixed l'Id de l'enregistrement suivant ou null
   */
  public function findSuivId()
  {
    if ( !$this->CurrentId or !$this->offSetActu or $this->offsetLast() == $this->offSetActu )
    {
      return null;
    }
    return $this[ $this->offSetActu + 1 ];
  }
 
  /** findPremsId
   * Retourne l'Id du premier enregistrement dans le scop
   * Retourne null si le scop n'est pas défini
   */
  public function findPremsId()
  {
    return ($this->offSetActu) ? $this[ 0 ] : null;
  }
 
  /** findDerId
   * Returne l'Id du dernier enregistrement dans le scop
   * Retourne null si le scop n'est aps défini
   */
  public function findDerId()
  {
    return ($this->offSetActu) ? $this[ $this->offsetLast() ] : null;
  }
 
  /** offsetLast
   * Retourne l'Id du dernier enregistrement du scop.
   * Retourne null si le scop n'est pas défini
   */
  public function offsetLast()
  {
    return (end( $this->listeParcour )) ? key( $this->listeParcour ) : null;
  }
 
  /** initParcour
   * @return void
   * 
   * Initialise la liste des parcour si elle n'existe pas elle est créé et les
   * données de positionnnement sont initialisées.
   */
  public function initParcour()
  {
    if ( !is_null( $this->listeParcour ) ) return;
 
    echo ('<br />test: ' . $this->test);
    var_dump( $this->query_liste_base );
    return $this;
    $q = new Doctrine_Query();
    // Initialisation de la liste
    $q->parseDqlQuery( $this->query_liste_base->getDql() );
    if ( $this->filtre_master_query )
        $q->andWhere( $this->filtre_master_query );
    if ( $this->filtre_query ) $q->andWhere( $this->filtre_query );
    if ( $this->filtre_tris_champ ) $q->orderBy( $this->getFiltreTris() );
    $this->listeParcour = $q->execute( array( ), Doctrine_Core::HYDRATE_SINGLE_SCALAR );
 
    // Vérifie que l'offset en mémoire correspond bien à l'offset de la liste
    // si non réattribue l'offset. Idem si l'offset n'est pas défini.
    if (
            is_null( $this->offSetActu ) or
            !($this->listeParcour[ $this->offSetActu ] == $this->CurrentId)
    )
    {
      if ( !($this->offSetActu = array_search( $this->CurrentId, $this->listeParcour )) )
      {
        $this->offSetActu = null;
      }
    }
  }
 
  /*   * **********************************************************************
   *   * Méthodes pour la gestion des filtres et tris
   */
 
  /** setFiltreQuery
   * Permet d'indiquer la chaine de filtre à utiliser
   * @param string $query_string Chaine de query a utiliser, null si le query
   *                             doit être réinitialisé
   * @return object Cet objet
   */
  public function setFiltreQuery( $query_string )
  {
    if ( $query_string )
    {
      $this->filtre_query = ( string ) $query_string;
    }
    else
    {
      $this->filtre_query = null;
      $this->filtre_data = null;
    }
    $this->listeParcour = null;
    return $this;
  }
 
  /** getFiltreQuery
   * Récupération de la chaine de filtre à utiliser
   * @return string/mixed La chaine ou null si non initialisé
   */
  public function getFiltreQuery()
  {
    return $this->filtre_query;
  }
 
  /** setFiltreMasterQuery
   * Permet de positionner le filtre principal de tris
   * @param string $query_string Chaine de query a utiliser en priorité, nul si
   *                             pour annuler le query master
   * @return object Cet objet
   */
  public function setFiltreMasterQuery( $query_string )
  {
    if ( $query_string )
    {
      $this->filtre_master_query = ( string ) $query_string;
    }
    else
    {
      $this->filtre_master_query = null;
    }
    $this->listeParcour = null;
    return $this;
  }
 
  /** getFiltreMasterQuery
   * Récupère la chaîne de filtre principale
   * @return string le query principal ou null
   */
  public function getFiltreMasterQuery()
  {
    return $this->filtre_master_query;
  }
 
  /** setFiltreObjectNom
   * Permet d'indiquer le nom du filtre a utiliser pour générer le query a partir
   * des objets.
   * @param string $filtre_nom Nom du filtre
   * @return object Cet objet
   */
  public function setFiltreObjectNom( $filtre_nom )
  {
    $this->filtre_nom = ( string ) $filtre_nom;
    $this->filtre_query = null;
    return $this;
  }
 
  /** getFiltreObjectNom
   * Retourne le nom défini pour l'objet filtre a utiliser pour calculer la
   * chaine de query
   * @return string Le nom ou null
   */
  public function getFiltreObjectNom()
  {
    return $this->filtre_nom;
  }
 
  /** setFiltreData
   * Permet de sauvegarder les données du filtre (généralement retournées par
   * le formulaire filtre), de les testées, de les sauvegarder sous la forme
   * d'une chaine avec un setFiltreQuery.
   * @param array $filtre_data Un tableau des paramètres de filtre
   * @return boolean Retourne vrai si les paramètres données ont pu retourner
   *                 un filtre valide. Faux si non.
   */
  public function setFiltreData( $filtre_data )
  {
    $filtre = $this->getFiltreObject();
    $filtre->bind( $filtre_data );
    if ( $filtre->isValid() )
    {
      $this->setFiltreQuery( $filtre->getQuery() );
      return true;
    }
    return FALSE;
  }
 
  /** makeQueryFromQuery
   * Rajoute à un objet query les deux query partiel et master ainsi que
   * la chaine de tris définie
   * @param Doctrine_Query $q Le query a compléter
   * @param array $options_tris Les options pour l'ordre de tris
   *   - champ : le nom du champs si le tris n'est pas défini
   *   - ordre : l'ordre de tris si non défini (ASC par défaut)
   *   - prioritaire : si vrai, les deux options primes sur ce qui est défini
   * @return Doctrine_Query L'objet query complété
   */
  public function makeQueryFromQuery( Doctrine_Query $q )
  {
    if ( $this->getFiltreMasterQuery() )
    {
      $q->andWhere( $this->getFiltreMasterQuery() );
    }
    if ( $this->getFiltreQuery() )
    {
      $q->andWhere( $this->getFiltreQuery() );
    }
    $q->orderBy( '' );
    return $q;
  }
 
  /** getFiltreObject
   * Récupère l'object filtre courant
   * @return object L'object filtre
   */
  public function getFiltreObject()
  {
    if ( !$this->filtre_object )
    {
      $filtreNom = $this->filtre_nom;
      $this->filtre_object = new $filtreNom;
    }
    return $this->filtre_object;
  }
 
  /** setFiltreTris
   * Positione les valeurs pour le tris. Si nul annule les données pour le tris.
   * @param string $champ nom du champ pour le tris ou null pour annuler
   * @param string $ordre ASC (défaut) ou DESC, null si le champ est null
   * @return object Cet objet
   */
  public function setFiltreTris( $champ = null, $ordre = 'ASC' )
  {
    if ( !$this->filtre_tris_champ = $champ )
    {
      $this->filtre_tris_ordre = NULL;
    }
    else
    {
      $this->filtre_tris_ordre = mrParcour::valideTrisOrdre( $ordre );
    }
  }
 
  /** valideTrisOrdre
   * Valide l'ordre de tris demandé.
   * @param string $ordre Ordre de tris demandé
   * @return string Ordre de tris retenu
   */
  static function valideTrisOrdre( $ordre )
  {
    return (in_array( $ordre, array( 'ASC', 'DESC' ) )) ?
            $ordre :
            'ASC';
  }
 
  /** getFiltreTris
   * Retourne la chaine de tris a prendre en compte
   * @param array Voir makeQueryFromQuery pour les options
   * @return string La chaine de tris ou une chaine vide
   */
  public function getFiltreTris( $options_tris )
  {
    if ( $tris = $this->getFiltreTrisData( $options_tris ) )
    {
      return '';
    }
    return $tris[ 'champ' ] . ' ' . $tris[ 'ordre' ];
  }
 
  /** getFiltreTrisData
   * Returne le tableau d'option de tris à prendre en compte
   * @param array Voir makeQueryFromQuery pour les options
   * @return array Le tableau effectif de tris à utiliser, null si pas de tris
   *               définis
   */
  public function getFiltreTrisData( $options_tris )
  {
    $tris = array( );
    $tris[ 'champ' ] = $this->filtre_tris_champ;
    $tris[ 'ordre' ] = $this->filtre_tris_ordre;
    if ( $options_tris[ 'prioritaire' ] == true or !$tris[ 'champ' ] )
    {
      $tris[ 'champ' ] = $options_tris[ 'champ' ];
      $tris[ 'ordre' ] = $options_tris[ 'ordre' ];
    }
    if ( $tris[ 'champ' ] )
    {
      return NULL;
    }
    $tris[ 'ordre' ] = mrParcour::valideTrisOrdre( $tris[ 'ordre' ] );
    return $tris;
  }
 
  /*   * *********************************************************************
   *   * Méthode pour l'interface Serializable
   */
 
  public function serialize()
  {
    return serialize( array(
        $this->offSetActu,
        $this->CurrentId,
        $this->filtre_query,
        $this->filtre_data,
        $this->filtre_master_query,
        $this->filtre_tris_champ,
        $this->filtre_tris_ordre
            ) );
  }
 
  public function unserialize( $serialized )
  {
    list (
            $this->offSetActu,
            $this->CurrentId,
            $this->filtre_query,
            $this->filtre_data,
            $this->filtre_master_query,
            $this->filtre_tris_champ,
            $this->filtre_tris_ordre
            )
            = $serialized;
  }
 
  /*   * *********************************************************************
   *   * Méthodes pour l'interface ArrayAccess
   */
 
  /* offsetExists
   * @param mixed $offset Le numéro d'offset de l'enregistrement recherché
   * @return boolean Vrais si le numéro existe
   */
 
  public function offsetExists( $offset )
  {
    return isset( $this->listeParcour[ $offset ] );
  }
 
  /* offsetGet
   * @param mixed $offset Le numéro d'offset de l'enregistrement dont on veut 
   *                      récupérer l'Id
   * @return integer Le numéro d'Id
   */
 
  public function offsetGet( $offset )
  {
    return $this->offsetExists( $offset ) ? $this->listeParcour( $offset ) : null;
  }
 
  /* offsetSet
   * Impossible de définir un élément, la fonction ne traite pas la demande et
   * retourne toujours null
   * @param mixed $offset Le numéro d'offset à modifier
   * @param mixed $value La valeur à implémenter
   * @return null Retourne toujours la valeur null
   */
 
  public function offsetSet( $offset, $value )
  {
    return null;
  }
 
  /* offsetUnset
   * Impossible de supprimer un élémnet du tableau, la fonction ne traite pas la
   * demande et retourne toujours null
   * @param mixed $offSet Le numéro d'offset à supprimer
   * @return null Retourne toujours la valeur null
   */
 
  public function offsetUnset( $offset )
  {
    return null;
  }
}

[Benjamin Delespierre]

Dans l'objet, la variable query_liste_base est nul alors qu'elle contenait l'objet un peu plus tôt

Tu es sûr que Doctrine n'est pas en cause ? ça ressemble à un problème dû à une inversion de contrôle...

Y-a-t'il un mécanisme de Singleton sous-jascent ? Cela pourrait alors venir du fait que la méthode myUser::getPersonnePager exécute un new qui remplacerait les attributs de l'instance existante...

Ligne 207, pourquoi y-a-t'il

Code :

return $this;

, si le code suivant n'est pas nécéssaire alors pourquoi il est là ?

Je pense pas sérieusement que mes hypothèses tiennent la route... Je vais continuer de chercher.

[Michel Rotta]

Je ne crois pas trop à un problème doctrine mais c'est une piste que je vais approfondir.

le

Code :

return $this

de la ligne 207 n'a aucun intérêt, si ce n'est de couper le traitement là et de me permettre de tester autre chose... Hier soir l'ordi serait passé un peu vite par la fenêtre sans !

Le code est "sale", plein de code de débug dedans, j'avais prévenu, désolé

[Benjamin Delespierre]

Pas de souci. Tu sais que les breakpoints ça marche aussi avec Eclipse et XDebug

[Michel Rotta]

Avec netbans aussi.

Mais je n'ai pas mieux compris hier.

Je vais tenter de me refaire le coup là.

[Michel Rotta]

Le problème du debug en PHP c'est qu'il n'est presque pas possible de consulter la valeur des variables. Et cela limite plutôt la portée du debug

Reste que je pense avoir trouvé (c'est cela qui est bien en objet, on n'est jamais sur de rien) !

Le problème est que, la majeur partie du temps, l'objet est récupéré par un unserialize. Hors certaines données ne sont pas sérialisée vu qu'elle sont "presque" des constantes, initiée dans la méthode configure de l'objet.

J'ai donc rajouté un traitement de configure() dans la méthode unserialize et tout semble fonctionner (du moins j'ai pu avancer dans le traitement des autres bugs, plus identifiable).

Il me reste un problème à la génération de la requête mais là, je pense que je vais trouver, dés que j'aurais le temps de chercher

Merci à tous.

[Benjamin Delespierre]

Le problème du debug en PHP c'est qu'il n'est presque pas possible de consulter la valeur des variables

J'ai pas ce problème avec Eclipse...

Pourtant tu ne déclare aucune constante ni attribut statique, c'est Doctrine qui t'en mets ?

[Michel Rotta]

Il y a des attributs statics (FiltreObjectNom) et NameQueryListBase. Celui justement qui disparaissait...

Le problème de la consultation du contenu des variable en xdebug vient d'une instabilité de xdebug à ce niveau. Ceci entraine un risque plus élevé (beaucoup plus) de plantage du serveur apache. Ce n'est pas lié à l'EDI utilisé. C'est un problème connu et, hélas, récurent à xdebug apparemment.

[rawsrc]

Bonjour Michel,

Pour le debug, je te conseille d'essayer l'EDI de NuSphere PhpEd. Leur module de debug est absolument génial. Enfin, après y avoir goûté je ne te cache pas que revenir sur xdebug me parait impossible.

[Michel Rotta]

Ceci à l'air plus qu'inintéressant. Par contre, le prix est plus élevé aussi

[Benjamin Delespierre]

Le var_dump c'est moins cher

-- Edit, j'espère que tout le monde avait compris que je suis pas sérieux 5 minutes quand je dis ça. J'ai en horreur les fragments de code commentés pour des raisons de débug laissé dans un produit taggé.

[Michel Rotta]

Pas sur...
Si tu comptes le temps passé à le mettre en place, a le retirer, a ne pas l'avoir fait sur la bonne variable, a afficher réafficher la même page. Possible que l'autre soit moins cher.

Et pouvoir modifier la valeur d'une variable en directe, j'aime.

[rawsrc]

+1 Michel :-)

Bon on s'éloigne de la problématique posée. De toute façon avec les éléments fournis je ne vois pas trop où ça pêche Michel. Désolé.

Après moults tests d'EDI, j'ai à un moment fait cette comparaison (var_dump et vrai mode debug). Et finalement, j'ai opté pour la soluce PHPEd. Sur des projets conséquents, le debug est essentiel et le gain de temps appréciable. Sans parler du confort de pouvoir inspecter et même de changer toutes les valeurs des variables à l'exécution. Et puis après coup quand un problème survient, tu te pointes chez ton client et tu peux tout tracer devant lui ligne par ligne, variable par variable et là j'ai vu des développeurs PHP littéralement baver. Donc c'est un calcul à faire mais en fonction de ce qui est visé je pense que c'est une opération rentable, enfin dans mon cas cela a été vrai.