A la recherche d'un design pattern

Invité · 24/08/2010, 09h32

Bien le bonjour à tous,

Je suis à la recherche éventuelle d'un patron de conception répondant à cette situation ci :

Je travaille sur la conception de pdf et j'utilise à foison la classe FPDF.
Si vous voyez les différents scripts qui sont proposés (protection du pdf, signets, ...), ils sont tous écrit dans des classes à part dont la majorité font appels à des méthodes de la classe parent (donc FPDF).

Premièrement, je me suis construit une classe qui hérite de FPDF afin de me pré-fabriquer des SetFont(), en soit. Puis vient l'intégration des autres classes pour telle ou telle fonctionnalité. Le procédé suivi est que je les fais toutes héritées une à une ce qui fonctionne.

Deuxièmement, ce procédé est lourd car à chaque incorporation il faut modifier le "extends" d'une classe pour le mettre sur la nouvelle (1000 excuses si vous ne saisissez pas complètement, en gros je n'arrive à ajouter vraiment dynamiquement les fonctionnalités représentées par des classes).

Finalement, je cherche ce "mécanisme" qui automatiserait toute cette petite chaine.

En prenant en compte le fait que la classe parent est majoritairement rappelée dans les autres classes, existe-t-il un design pattern qui correspondrait à cette problématique ?

Ne connaissant que très peu d'élément sur le Zend Framework, la méthode des helpers serait-elle appropriée ?

Voici, en espérant une discussion avec vous autre.

Cordialement,

Steve.

Invité · 27/08/2010, 13h35

On se creuse la tête un peu et voilà comment peut-on obtenir ce résultat :

-- 1ère partie --

Tout d'abord, on étend la classe FPDF (pour y ajouter ces propres astuces comme des fonts customisés qui appeleront SetFont()).
Dans cet héritage, on y incorpore un tableau de helpers (mot repris du ZF), la méthode magique __call et la redéfinition de toutes les méthodes protected pour les rendre public.

Code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
<?php
require_once(dirname(realpath(__FILE__)).'/../Fpdf/Fpdf.php');
 
class Fpdf extends FPDF
{
    private $m_customFonts = array();
 
    private $m_helpers = array();
 
    public function addCustomFont($name, $police, $style, $size) {
        $this->m_customFonts[$name] = array(
            'police'    =>  $police,
            'style'     =>  $style,
            'size'      =>  $size
        );
    }
 
    public function setCustomFont($name) {
        $this->SetFont($this->m_customFonts[$name]['police'], $this->m_customFonts[$name]['style'], $this->m_customFonts[$name]['size']);
    }
 
    public function __call($methode, $arguments)
    {
        if(method_exists($this, $methode)) {
            return call_user_func_array(array($this, $methode), $arguments);
        } else {
            if(strpos($methode, '_') !== false) {
                $className = 'Fpdf_'.substr($methode, 0, strpos($methode, '_'));
                $methodName = substr($methode, strpos($methode, '_') + 1);
            } else {
                $className = 'Fpdf_'.$methode;
                $methodName = $methode;
            }
            if(class_exists($className)) {
                $newHelper = null;
                foreach($this->m_helpers as $helper) {
                    if(get_class($helper) == $className) {
                        $newHelper = $helper;
                    }
                }
                if(is_null($newHelper)) {
                    $newHelper = new $className($this);
                    $this->m_helpers[] = $newHelper;
                }
                if(method_exists($newHelper, $methodName)) {
                    return call_user_func_array(array($newHelper, $methodName), $arguments);
                } else {
                    throw new Exception_Fpdf(array('unknown_method', $methodName, $className), __FILE__, __LINE__);
                }
            } else {
                throw new Exception_Fpdf(array('unknown_class', $className), __FILE__, __LINE__);
            }
        }
    }
 
    public function searchAndCallParentIntoHelpers($methodParentName, $arguments = array())
    {
        list($c, $methodParentName) = explode('::', $methodParentName);
        foreach($this->m_helpers as $helper) {
            foreach($helper->correspondanceTableFonctionParent as $methodParent => $functionEnfant) {
                if($methodParent == $methodParentName) {
                    $arguments = call_user_func_array(array($helper, $functionEnfant), $arguments);
                    break;
                }
            }
        }
        return $arguments;
    }
 
    public function _dochecks()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_dochecks();
    }
 
    public function _getpageformat($format)
    {
        list($format) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($format));
        return parent::_getpageformat($format);
    }
 
    public function _getfontpath()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        return parent::_getfontpath();
    }
 
    public function _beginpage($orientation, $format)
    {
        list($orientation, $format) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($orientation, $format));
        parent::_beginpage($orientation, $format);
    }
 
    public function _endpage()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        return parent::_endpage();
    }
 
    public function _escape($s)
    {
        list($s) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($s));
        return parent::_escape($s);
    }
 
    public function _textstring($s)
    {
        list($s) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($s));
        return parent::_textstring($s);
    }
 
    public function _UTF8toUTF16($s)
    {
        list($s) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($s));
        return parent::_UTF8toUTF16($s);
    }
 
    public function _dounderline($x, $y, $txt)
    {
        list($x, $y, $txt) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($x, $y, $txt));
        return parent::_dounderline($x, $y, $txt);
    }
 
    public function _parsejpg($file)
    {
        list($file) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($file));
        return parent::_parsejpg($file);
    }
 
    public function _parsepng($file)
    {
        list($file) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($file));
        return parent::_parsepng($file);
    }
 
    public function _readstream($f, $n)
    {
        list($f, $n) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($f, $n));
        return parent::_readstream($f, $n);
    }
 
    public function _readint($f)
    {
        list($f) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($f));
        return parent::_readint($f);
    }
 
    public function _parsegif($file)
    {
        list($file) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($file));
        return parent::_parsegif($file);
    }
 
    public function _newobj()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_newobj();
    }
 
    public function _putstream($s)
    {
        list($s) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($s));
        parent::_putstream($s);
    }
 
    public function _out($s)
    {
        list($s) = $this->searchAndCallParentIntoHelpers(__METHOD__, array($s));
        parent::_out($s);
    }
 
    public function _putpages()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_putpages();
    }
 
    public function _putfonts()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_putfonts();
    }
 
    public function _putimages()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_putimages();
    }
 
    public function _putxobjectdict()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_putxobjectdict();
    }
 
    public function _putresourcedict()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_putresourcedict();
    }
 
    public function _putresources()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_putresources();
    }
 
    public function _putinfo()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_putinfo();
    }
 
    public function _putcatalog()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_putcatalog();
    }
 
    public function _putheader()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_putheader();
    }
 
    public function _puttrailer()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_puttrailer();
    }
 
    public function _enddoc()
    {
        $this->searchAndCallParentIntoHelpers(__METHOD__);
        parent::_enddoc();
    }
}

-- 2ème partie --

Ensuite sur toutes les fonctionnalités (les classes à part qui gèrent les signets, les rectangles arrondis, ...), il faut enlever tous les appels à parent:: (c'est la classe du dessus qui les gèrent), renommer les méthodes protégées en enlevant le _ devant le nom et y ajouter le nom de la fonctionnalité, ajouter un contructeur qui reprend l'objet Fpdf (le notre), renommer tous les $this en $this->m_fpdf (sauf si la méthode appelée fais partie de la class elle-même, hein !) et enfin ajouter un tableau de correspondance des méthodes protégées. En aparté, je ré-écris les classes en version 5 en rajoutant les public / protected / private et un petit nom différent pour les variables de classe.

Ce qui donne, en exemple la classe Rotation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
<?php
 
class Fpdf_Rotation
{
    private $m_angle=0;
 
    public $correspondanceTableFonctionParent = array(
        '_endpage' => 'endpageRotation'
    );
 
    private $m_fpdf;
 
    public function __construct($fpdf) 
    {
        $this->m_fpdf = $fpdf;
    }
 
    public function Rotation($angle,$x=-1,$y=-1)
    {        
        if($x == -1)
            $x = $this->m_fpdf->x;
        if($y == -1)
            $y = $this->m_fpdf->y;
        if($this->m_angle != 0)
            $this->m_fpdf->_out('Q');
        $this->m_angle = $angle;
        if($angle != 0)
        {
            $angle *= M_PI/180;
            $c = cos($angle);
            $s = sin($angle);
            $cx = $x * $this->m_fpdf->k;
            $cy = ($this->m_fpdf->h - $y) * $this->m_fpdf->k;
            $this->m_fpdf->_out(sprintf('q %.5F %.5F %.5F %.5F %.2F %.2F cm 1 0 0 1 %.2F %.2F cm', $c, $s, -$s, $c, $cx, $cy, -$cx, -$cy));
        }
    }
 
    public function endpageRotation()
    {
        if($this->m_angle != 0)
        {
            $this->m_angle = 0;
            $this->m_fpdf->_out('Q');
        }
    }
}

Voilà, une petite retouche à chaque fichier et l'on peut ajouter dynamiquement des fonctionnalités en appelant de cette manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
$this->m_pdf->Signet_BookmarkUTF8($tab['init']['caption'], 1, -1);

J'emmétrai simplement une impasse. Le texte circulaire a besoin du script transformation alors le test n'a pas été fait une couche d'héritage en plus donc j'ai placé la méthode du texte circulaire dans les transformations.

Une dernière chose : j'ai un spl_autoload qui se charge d'appeler les classes de fonctionnalités.

À la votre et bonne prog !

Cordialement,

Steve.

A la recherche d'un design pattern [PHP 5.1]

Langage PHP

Discussions similaires

Partager

Partager