Clover Coverage Report - XWiki Rendering - Parent POM 4.0-SNAPSHOT (Aggregated)
Coverage timestamp: Mon Mar 12 2012 18:03:13 CET
Overview   Package   File
    FRAMES   NO FRAMES     
../../../../../img/srcFileCovDistChart10.png 0% of files have more coverage
155   518   104   2.92
102   429   0.67   53
53     1.96  
1    
 
  AbstractChainingListener       Line # 38 155 0% 104 20 93.5% 0.9354839
 
  (978)
 
1    /*
2    * See the NOTICE file distributed with this work for additional
3    * information regarding copyright ownership.
4    *
5    * This is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU Lesser General Public License as
7    * published by the Free Software Foundation; either version 2.1 of
8    * the License, or (at your option) any later version.
9    *
10    * This software is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13    * Lesser General Public License for more details.
14    *
15    * You should have received a copy of the GNU Lesser General Public
16    * License along with this software; if not, write to the Free
17    * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18    * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
19    */
20    package org.xwiki.rendering.listener.chaining;
21   
22    import java.util.Map;
23   
24    import org.xwiki.rendering.listener.Format;
25    import org.xwiki.rendering.listener.HeaderLevel;
26    import org.xwiki.rendering.listener.ListType;
27    import org.xwiki.rendering.listener.MetaData;
28    import org.xwiki.rendering.listener.reference.ResourceReference;
29    import org.xwiki.rendering.syntax.Syntax;
30   
31    /**
32    * Default and basic implementation of a chaining listener that knows how to delegate event calls to the next listener
33    * in the chain.
34    *
35    * @version $Id: ef1af008435a7140553bbb2de0c46aaaac2f00ed $
36    * @since 1.8RC1
37    */
 
38    public abstract class AbstractChainingListener implements ChainingListener
39    {
40    /**
41    * The chain to use to know the next listener to call on events.
42    */
43    private ListenerChain listenerChain;
44   
45    /**
46    * @param listenerChain see {@link #getListenerChain()}
47    * @since 2.0M3
48    */
 
49  5315 toggle public void setListenerChain(ListenerChain listenerChain)
50    {
51  5315 this.listenerChain = listenerChain;
52    }
53   
 
54  65909 toggle @Override
55    public ListenerChain getListenerChain()
56    {
57  65909 return this.listenerChain;
58    }
59   
 
60  199 toggle @Override
61    public void beginDefinitionDescription()
62    {
63  199 ChainingListener next = getListenerChain().getNextListener(getClass());
64  199 if (next != null) {
65  199 next.beginDefinitionDescription();
66    }
67    }
68   
 
69  216 toggle @Override
70    public void beginDefinitionList(Map<String, String> parameters)
71    {
72  216 ChainingListener next = getListenerChain().getNextListener(getClass());
73  216 if (next != null) {
74  216 next.beginDefinitionList(parameters);
75    }
76    }
77   
 
78  159 toggle @Override
79    public void beginDefinitionTerm()
80    {
81  159 ChainingListener next = getListenerChain().getNextListener(getClass());
82  159 if (next != null) {
83  159 next.beginDefinitionTerm();
84    }
85    }
86   
 
87  3713 toggle @Override
88    public void beginDocument(MetaData metaData)
89    {
90  3713 ChainingListener next = getListenerChain().getNextListener(getClass());
91  3713 if (next != null) {
92  3052 next.beginDocument(metaData);
93    }
94    }
95   
 
96  282 toggle @Override
97    public void beginGroup(Map<String, String> parameters)
98    {
99  282 ChainingListener next = getListenerChain().getNextListener(getClass());
100  282 if (next != null) {
101  281 next.beginGroup(parameters);
102    }
103    }
104   
 
105  879 toggle @Override
106    public void beginFormat(Format format, Map<String, String> parameters)
107    {
108  879 ChainingListener next = getListenerChain().getNextListener(getClass());
109  879 if (next != null) {
110  865 next.beginFormat(format, parameters);
111    }
112    }
113   
 
114  516 toggle @Override
115    public void beginHeader(HeaderLevel level, String id, Map<String, String> parameters)
116    {
117  516 ChainingListener next = getListenerChain().getNextListener(getClass());
118  516 if (next != null) {
119  516 next.beginHeader(level, id, parameters);
120    }
121    }
122   
 
123  868 toggle @Override
124    public void beginLink(ResourceReference reference, boolean isFreeStandingURI, Map<String, String> parameters)
125    {
126  868 ChainingListener next = getListenerChain().getNextListener(getClass());
127  868 if (next != null) {
128  860 next.beginLink(reference, isFreeStandingURI, parameters);
129    }
130    }
131   
 
132  590 toggle @Override
133    public void beginList(ListType listType, Map<String, String> parameters)
134    {
135  590 ChainingListener next = getListenerChain().getNextListener(getClass());
136  590 if (next != null) {
137  590 next.beginList(listType, parameters);
138    }
139    }
140   
 
141  737 toggle @Override
142    public void beginListItem()
143    {
144  737 ChainingListener next = getListenerChain().getNextListener(getClass());
145  737 if (next != null) {
146  737 next.beginListItem();
147    }
148    }
149   
 
150  1393 toggle @Override
151    public void beginMacroMarker(String name, Map<String, String> parameters, String content, boolean isInline)
152    {
153  1393 ChainingListener next = getListenerChain().getNextListener(getClass());
154  1393 if (next != null) {
155  1363 next.beginMacroMarker(name, parameters, content, isInline);
156    }
157    }
158   
 
159  2530 toggle @Override
160    public void beginParagraph(Map<String, String> parameters)
161    {
162  2530 ChainingListener next = getListenerChain().getNextListener(getClass());
163  2530 if (next != null) {
164  2528 next.beginParagraph(parameters);
165    }
166    }
167   
 
168  91 toggle @Override
169    public void beginQuotation(Map<String, String> parameters)
170    {
171  91 ChainingListener next = getListenerChain().getNextListener(getClass());
172  91 if (next != null) {
173  88 next.beginQuotation(parameters);
174    }
175    }
176   
 
177  149 toggle @Override
178    public void beginQuotationLine()
179    {
180  149 ChainingListener next = getListenerChain().getNextListener(getClass());
181  149 if (next != null) {
182  149 next.beginQuotationLine();
183    }
184    }
185   
 
186  692 toggle @Override
187    public void beginSection(Map<String, String> parameters)
188    {
189  692 ChainingListener next = getListenerChain().getNextListener(getClass());
190  692 if (next != null) {
191  582 next.beginSection(parameters);
192    }
193    }
194   
 
195  176 toggle @Override
196    public void beginTable(Map<String, String> parameters)
197    {
198  176 ChainingListener next = getListenerChain().getNextListener(getClass());
199  176 if (next != null) {
200  176 next.beginTable(parameters);
201    }
202    }
203   
 
204  444 toggle @Override
205    public void beginTableCell(Map<String, String> parameters)
206    {
207  444 ChainingListener next = getListenerChain().getNextListener(getClass());
208  444 if (next != null) {
209  444 next.beginTableCell(parameters);
210    }
211    }
212   
 
213  268 toggle @Override
214    public void beginTableHeadCell(Map<String, String> parameters)
215    {
216  268 ChainingListener next = getListenerChain().getNextListener(getClass());
217  268 if (next != null) {
218  268 next.beginTableHeadCell(parameters);
219    }
220    }
221   
 
222  337 toggle @Override
223    public void beginTableRow(Map<String, String> parameters)
224    {
225  337 ChainingListener next = getListenerChain().getNextListener(getClass());
226  337 if (next != null) {
227  337 next.beginTableRow(parameters);
228    }
229    }
230   
 
231  28 toggle @Override
232    public void beginMetaData(MetaData metadata)
233    {
234  28 ChainingListener next = getListenerChain().getNextListener(getClass());
235  28 if (next != null) {
236  20 next.beginMetaData(metadata);
237    }
238    }
239   
 
240  207 toggle @Override
241    public void endDefinitionDescription()
242    {
243  207 ChainingListener next = getListenerChain().getNextListener(getClass());
244  207 if (next != null) {
245  199 next.endDefinitionDescription();
246    }
247    }
248   
 
249  243 toggle @Override
250    public void endDefinitionList(Map<String, String> parameters)
251    {
252  243 ChainingListener next = getListenerChain().getNextListener(getClass());
253  243 if (next != null) {
254  216 next.endDefinitionList(parameters);
255    }
256    }
257   
 
258  167 toggle @Override
259    public void endDefinitionTerm()
260    {
261  167 ChainingListener next = getListenerChain().getNextListener(getClass());
262  167 if (next != null) {
263  159 next.endDefinitionTerm();
264    }
265    }
266   
 
267  3315 toggle @Override
268    public void endDocument(MetaData metaData)
269    {
270  3315 ChainingListener next = getListenerChain().getNextListener(getClass());
271  3315 if (next != null) {
272  3052 next.endDocument(metaData);
273    }
274    }
275   
 
276  282 toggle @Override
277    public void endGroup(Map<String, String> parameters)
278    {
279  282 ChainingListener next = getListenerChain().getNextListener(getClass());
280  282 if (next != null) {
281  281 next.endGroup(parameters);
282    }
283    }
284   
 
285  879 toggle @Override
286    public void endFormat(Format format, Map<String, String> parameters)
287    {
288  879 ChainingListener next = getListenerChain().getNextListener(getClass());
289  879 if (next != null) {
290  865 next.endFormat(format, parameters);
291    }
292    }
293   
 
294  522 toggle @Override
295    public void endHeader(HeaderLevel level, String id, Map<String, String> parameters)
296    {
297  522 ChainingListener next = getListenerChain().getNextListener(getClass());
298  522 if (next != null) {
299  516 next.endHeader(level, id, parameters);
300    }
301    }
302   
 
303  860 toggle @Override
304    public void endLink(ResourceReference reference, boolean isFreeStandingURI, Map<String, String> parameters)
305    {
306  860 ChainingListener next = getListenerChain().getNextListener(getClass());
307  860 if (next != null) {
308  860 next.endLink(reference, isFreeStandingURI, parameters);
309    }
310    }
311   
 
312  601 toggle @Override
313    public void endList(ListType listType, Map<String, String> parameters)
314    {
315  601 ChainingListener next = getListenerChain().getNextListener(getClass());
316  601 if (next != null) {
317  590 next.endList(listType, parameters);
318    }
319    }
320   
 
321  753 toggle @Override
322    public void endListItem()
323    {
324  753 ChainingListener next = getListenerChain().getNextListener(getClass());
325  753 if (next != null) {
326  737 next.endListItem();
327    }
328    }
329   
 
330  1393 toggle @Override
331    public void endMacroMarker(String name, Map<String, String> parameters, String content, boolean isInline)
332    {
333  1393 ChainingListener next = getListenerChain().getNextListener(getClass());
334  1393 if (next != null) {
335  1363 next.endMacroMarker(name, parameters, content, isInline);
336    }
337    }
338   
 
339  2552 toggle @Override
340    public void endParagraph(Map<String, String> parameters)
341    {
342  2552 ChainingListener next = getListenerChain().getNextListener(getClass());
343  2552 if (next != null) {
344  2528 next.endParagraph(parameters);
345    }
346    }
347   
 
348  100 toggle @Override
349    public void endQuotation(Map<String, String> parameters)
350    {
351  100 ChainingListener next = getListenerChain().getNextListener(getClass());
352  100 if (next != null) {
353  88 next.endQuotation(parameters);
354    }
355    }
356   
 
357  165 toggle @Override
358    public void endQuotationLine()
359    {
360  165 ChainingListener next = getListenerChain().getNextListener(getClass());
361  165 if (next != null) {
362  149 next.endQuotationLine();
363    }
364    }
365   
 
366  692 toggle @Override
367    public void endSection(Map<String, String> parameters)
368    {
369  692 ChainingListener next = getListenerChain().getNextListener(getClass());
370  692 if (next != null) {
371  582 next.endSection(parameters);
372    }
373    }
374   
 
375  199 toggle @Override
376    public void endTable(Map<String, String> parameters)
377    {
378  199 ChainingListener next = getListenerChain().getNextListener(getClass());
379  199 if (next != null) {
380  176 next.endTable(parameters);
381    }
382    }
383   
 
384  452 toggle @Override
385    public void endTableCell(Map<String, String> parameters)
386    {
387  452 ChainingListener next = getListenerChain().getNextListener(getClass());
388  452 if (next != null) {
389  444 next.endTableCell(parameters);
390    }
391    }
392   
 
393  272 toggle @Override
394    public void endTableHeadCell(Map<String, String> parameters)
395    {
396  272 ChainingListener next = getListenerChain().getNextListener(getClass());
397  272 if (next != null) {
398  268 next.endTableHeadCell(parameters);
399    }
400    }
401   
 
402  382 toggle @Override
403    public void endTableRow(Map<String, String> parameters)
404    {
405  382 ChainingListener next = getListenerChain().getNextListener(getClass());
406  382 if (next != null) {
407  337 next.endTableRow(parameters);
408    }
409    }
410   
 
411  28 toggle @Override
412    public void endMetaData(MetaData metadata)
413    {
414  28 ChainingListener next = getListenerChain().getNextListener(getClass());
415  28 if (next != null) {
416  20 next.endMetaData(metadata);
417    }
418    }
419   
 
420  78 toggle @Override
421    public void onEmptyLines(int count)
422    {
423  78 ChainingListener next = getListenerChain().getNextListener(getClass());
424  78 if (next != null) {
425  78 next.onEmptyLines(count);
426    }
427    }
428   
 
429  118 toggle @Override
430    public void onHorizontalLine(Map<String, String> parameters)
431    {
432  118 ChainingListener next = getListenerChain().getNextListener(getClass());
433  118 if (next != null) {
434  118 next.onHorizontalLine(parameters);
435    }
436    }
437   
 
438  39 toggle @Override
439    public void onId(String name)
440    {
441  39 ChainingListener next = getListenerChain().getNextListener(getClass());
442  39 if (next != null) {
443  39 next.onId(name);
444    }
445    }
446   
 
447  352 toggle @Override
448    public void onImage(ResourceReference reference, boolean isFreeStandingURI, Map<String, String> parameters)
449    {
450  352 ChainingListener next = getListenerChain().getNextListener(getClass());
451  352 if (next != null) {
452  352 next.onImage(reference, isFreeStandingURI, parameters);
453    }
454    }
455   
 
456  598 toggle @Override
457    public void onMacro(String id, Map<String, String> parameters, String content, boolean isInline)
458    {
459  598 ChainingListener next = getListenerChain().getNextListener(getClass());
460  598 if (next != null) {
461  577 next.onMacro(id, parameters, content, isInline);
462    }
463    }
464   
 
465  967 toggle @Override
466    public void onNewLine()
467    {
468  967 ChainingListener next = getListenerChain().getNextListener(getClass());
469  967 if (next != null) {
470  967 next.onNewLine();
471    }
472    }
473   
 
474  5784 toggle @Override
475    public void onSpace()
476    {
477  5784 ChainingListener next = getListenerChain().getNextListener(getClass());
478  5784 if (next != null) {
479  5784 next.onSpace();
480    }
481    }
482   
 
483  2730 toggle @Override
484    public void onSpecialSymbol(char symbol)
485    {
486  2730 ChainingListener next = getListenerChain().getNextListener(getClass());
487  2730 if (next != null) {
488  2730 next.onSpecialSymbol(symbol);
489    }
490    }
491   
 
492  210 toggle @Override
493    public void onVerbatim(String protectedString, boolean isInline, Map<String, String> parameters)
494    {
495  210 ChainingListener next = getListenerChain().getNextListener(getClass());
496  210 if (next != null) {
497  210 next.onVerbatim(protectedString, isInline, parameters);
498    }
499    }
500   
 
501  11057 toggle @Override
502    public void onWord(String word)
503    {
504  11057 ChainingListener next = getListenerChain().getNextListener(getClass());
505  11057 if (next != null) {
506  11056 next.onWord(word);
507    }
508    }
509   
 
510  91 toggle @Override
511    public void onRawText(String text, Syntax syntax)
512    {
513  91 ChainingListener next = getListenerChain().getNextListener(getClass());
514  91 if (next != null) {
515  86 next.onRawText(text, syntax);
516    }
517    }
518    }
 
CloverReport generated by Clover Code Coverage v3.1.4
Mon Mar 12 2012 18:03:37 CET.		   Clover: Open Source License registered to XWiki.