cleanup
[jalview.git] / forester / java / src / org / forester / analysis / TaxonomyDataManager.java
1 // $Id:
2 //
3 // forester -- software libraries and applications
4 // for genomics and evolutionary biology research.
5 //
6 // Copyright (C) 2010 Christian M Zmasek
7 // Copyright (C) 2010 Sanford-Burnham Medical Research Institute
8 // All rights reserved
9 //
10 // This library is free software; you can redistribute it and/or
11 // modify it under the terms of the GNU Lesser General Public
12 // License as published by the Free Software Foundation; either
13 // version 2.1 of the License, or (at your option) any later version.
14 //
15 // This library is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 // Lesser General Public License for more details.
19 //
20 // You should have received a copy of the GNU Lesser General Public
21 // License along with this library; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 //
24 // Contact: phylosoft @ gmail . com
25 // WWW: https://sites.google.com/site/cmzmasek/home/software/forester
26
27 package org.forester.analysis;
28
29 import java.io.IOException;
30 import java.net.UnknownHostException;
31 import java.util.ArrayList;
32 import java.util.HashMap;
33 import java.util.List;
34 import java.util.SortedSet;
35 import java.util.TreeSet;
36
37 import javax.swing.JOptionPane;
38
39 import org.forester.archaeopteryx.MainFrameApplication;
40 import org.forester.archaeopteryx.TreePanel;
41 import org.forester.archaeopteryx.tools.AncestralTaxonomyInferrer;
42 import org.forester.archaeopteryx.tools.RunnableProcess;
43 import org.forester.io.parsers.phyloxml.PhyloXmlDataFormatException;
44 import org.forester.phylogeny.Phylogeny;
45 import org.forester.phylogeny.PhylogenyNode;
46 import org.forester.phylogeny.data.Identifier;
47 import org.forester.phylogeny.data.Taxonomy;
48 import org.forester.phylogeny.iterators.PhylogenyNodeIterator;
49 import org.forester.util.ForesterUtil;
50 import org.forester.ws.seqdb.SequenceDbWsTools;
51 import org.forester.ws.seqdb.UniProtTaxonomy;
52
53 public final class TaxonomyDataManager extends RunnableProcess {
54
55     enum QUERY_TYPE {
56         CODE, SN, CN, ID, LIN;
57     }
58     private static final int                              MAX_CACHE_SIZE           = 100000;
59     private static final int                              MAX_TAXONOMIES_TO_RETURN = 10;
60     private static final HashMap<String, UniProtTaxonomy> _sn_up_cache_map         = new HashMap<String, UniProtTaxonomy>();
61     private static final HashMap<String, UniProtTaxonomy> _lineage_up_cache_map    = new HashMap<String, UniProtTaxonomy>();
62     private static final HashMap<String, UniProtTaxonomy> _code_up_cache_map       = new HashMap<String, UniProtTaxonomy>();
63     private static final HashMap<String, UniProtTaxonomy> _cn_up_cache_map         = new HashMap<String, UniProtTaxonomy>();
64     private static final HashMap<String, UniProtTaxonomy> _id_up_cache_map         = new HashMap<String, UniProtTaxonomy>();
65     private final Phylogeny                               _phy;
66     private final MainFrameApplication                    _mf;
67     private final TreePanel                               _treepanel;
68     private final boolean                                 _delete;
69     private final boolean                                 _allow_simple_names;
70
71     public TaxonomyDataManager( final MainFrameApplication mf, final TreePanel treepanel, final Phylogeny phy ) {
72         _phy = phy;
73         _mf = mf;
74         _treepanel = treepanel;
75         _delete = false;
76         _allow_simple_names = false;
77     }
78
79     public TaxonomyDataManager( final MainFrameApplication mf,
80                                 final TreePanel treepanel,
81                                 final Phylogeny phy,
82                                 final boolean delete,
83                                 final boolean allow_simple_name ) {
84         _phy = phy;
85         _mf = mf;
86         _treepanel = treepanel;
87         _delete = delete;
88         _allow_simple_names = allow_simple_name;
89     }
90
91     synchronized static void clearCachesIfTooLarge() {
92         if ( getSnTaxCacheMap().size() > MAX_CACHE_SIZE ) {
93             getSnTaxCacheMap().clear();
94         }
95         if ( getLineageTaxCacheMap().size() > MAX_CACHE_SIZE ) {
96             getLineageTaxCacheMap().clear();
97         }
98         if ( getCnTaxCacheMap().size() > MAX_CACHE_SIZE ) {
99             getCnTaxCacheMap().clear();
100         }
101         if ( getCodeTaxCacheMap().size() > MAX_CACHE_SIZE ) {
102             getCodeTaxCacheMap().clear();
103         }
104         if ( getIdTaxCacheMap().size() > MAX_CACHE_SIZE ) {
105             getIdTaxCacheMap().clear();
106         }
107     }
108
109     synchronized final static HashMap<String, UniProtTaxonomy> getCnTaxCacheMap() {
110         return _cn_up_cache_map;
111     }
112
113     synchronized final static HashMap<String, UniProtTaxonomy> getCodeTaxCacheMap() {
114         return _code_up_cache_map;
115     }
116
117     synchronized final static HashMap<String, UniProtTaxonomy> getIdTaxCacheMap() {
118         return _id_up_cache_map;
119     }
120
121     synchronized final static HashMap<String, UniProtTaxonomy> getLineageTaxCacheMap() {
122         return _lineage_up_cache_map;
123     }
124
125     synchronized final static HashMap<String, UniProtTaxonomy> getSnTaxCacheMap() {
126         return _sn_up_cache_map;
127     }
128
129     private final static UniProtTaxonomy obtainTaxonomy( final HashMap<String, UniProtTaxonomy> cache,
130                                                          final Object query,
131                                                          final QUERY_TYPE qt ) throws IOException,
132             AncestralTaxonomyInferenceException {
133         if ( cache.containsKey( query ) ) {
134             return cache.get( query ).copy();
135         }
136         else {
137             List<UniProtTaxonomy> up_taxonomies = null;
138             switch ( qt ) {
139                 case ID:
140                     up_taxonomies = getTaxonomiesFromId( ( String ) query );
141                     break;
142                 case CODE:
143                     up_taxonomies = getTaxonomiesFromTaxonomyCode( ( String ) query );
144                     break;
145                 case SN:
146                     up_taxonomies = getTaxonomiesFromScientificName( ( String ) query );
147                     break;
148                 case CN:
149                     up_taxonomies = getTaxonomiesFromCommonName( ( String ) query );
150                     break;
151                 case LIN:
152                     return obtainUniProtTaxonomyFromLineage( ( List<String> ) query );
153                 default:
154                     throw new RuntimeException();
155             }
156             if ( ( up_taxonomies != null ) && ( up_taxonomies.size() == 1 ) ) {
157                 final UniProtTaxonomy up_tax = up_taxonomies.get( 0 );
158                 if ( !ForesterUtil.isEmpty( up_tax.getScientificName() ) ) {
159                     TaxonomyDataManager.getSnTaxCacheMap().put( up_tax.getScientificName(), up_tax );
160                 }
161                 if ( !ForesterUtil.isEmpty( up_tax.getCode() ) ) {
162                     TaxonomyDataManager.getCodeTaxCacheMap().put( up_tax.getCode(), up_tax );
163                 }
164                 if ( !ForesterUtil.isEmpty( up_tax.getCommonName() ) ) {
165                     TaxonomyDataManager.getCnTaxCacheMap().put( up_tax.getCommonName(), up_tax );
166                 }
167                 if ( !ForesterUtil.isEmpty( up_tax.getId() ) ) {
168                     TaxonomyDataManager.getIdTaxCacheMap().put( up_tax.getId(), up_tax );
169                 }
170                 return up_tax;
171             }
172             else {
173                 return null;
174             }
175         }
176     }
177
178     private final static List<UniProtTaxonomy> getTaxonomiesFromCommonName( final String query ) throws IOException {
179         return SequenceDbWsTools.getTaxonomiesFromCommonNameStrict( query, MAX_TAXONOMIES_TO_RETURN );
180     }
181
182     private final static List<UniProtTaxonomy> getTaxonomiesFromId( final String query ) throws IOException {
183         return SequenceDbWsTools.getTaxonomiesFromId( query, MAX_TAXONOMIES_TO_RETURN );
184     }
185
186     private final static List<UniProtTaxonomy> getTaxonomiesFromScientificName( final String query ) throws IOException {
187         return SequenceDbWsTools.getTaxonomiesFromScientificNameStrict( query, MAX_TAXONOMIES_TO_RETURN );
188     }
189
190     private final static List<UniProtTaxonomy> getTaxonomiesFromTaxonomyCode( final String query ) throws IOException {
191         return SequenceDbWsTools.getTaxonomiesFromTaxonomyCode( query, MAX_TAXONOMIES_TO_RETURN );
192     }
193
194     static final boolean isHasAppropriateId( final Taxonomy tax ) {
195         return ( ( tax.getIdentifier() != null ) && ( !ForesterUtil.isEmpty( tax.getIdentifier().getValue() ) && ( tax
196                 .getIdentifier().getProvider().equalsIgnoreCase( "ncbi" )
197                 || tax.getIdentifier().getProvider().equalsIgnoreCase( "uniprot" ) || tax.getIdentifier().getProvider()
198                 .equalsIgnoreCase( "uniprotkb" ) ) ) );
199     }
200
201     synchronized final private static SortedSet<String> obtainDetailedTaxonomicInformation( final Phylogeny phy,
202                                                                                             final boolean delete,
203                                                                                             final boolean allow_to_use_basic_node_names )
204             throws IOException, AncestralTaxonomyInferenceException {
205         clearCachesIfTooLarge();
206         final SortedSet<String> not_found = new TreeSet<String>();
207         List<PhylogenyNode> not_found_external_nodes = null;
208         if ( delete ) {
209             not_found_external_nodes = new ArrayList<PhylogenyNode>();
210         }
211         for( final PhylogenyNodeIterator iter = phy.iteratorPostorder(); iter.hasNext(); ) {
212             final PhylogenyNode node = iter.next();
213             final QUERY_TYPE qt = null;
214             Taxonomy tax = null;
215             if ( node.getNodeData().isHasTaxonomy() ) {
216                 tax = node.getNodeData().getTaxonomy();
217             }
218             else if ( allow_to_use_basic_node_names && !ForesterUtil.isEmpty( node.getName() ) ) {
219                 // Nothing to be done.
220             }
221             else if ( node.isExternal() ) {
222                 if ( !ForesterUtil.isEmpty( node.getName() ) ) {
223                     not_found.add( node.getName() );
224                 }
225                 else {
226                     not_found.add( node.toString() );
227                 }
228                 if ( delete ) {
229                     not_found_external_nodes.add( node );
230                 }
231             }
232             UniProtTaxonomy uniprot_tax = null;
233             if ( ( ( tax != null ) && ( isHasAppropriateId( tax ) || !ForesterUtil.isEmpty( tax.getScientificName() )
234                     || !ForesterUtil.isEmpty( tax.getTaxonomyCode() ) || !ForesterUtil.isEmpty( tax.getCommonName() ) ) )
235                     || ( allow_to_use_basic_node_names && !ForesterUtil.isEmpty( node.getName() ) ) ) {
236                 if ( tax != null ) {
237                     uniprot_tax = obtainUniProtTaxonomy( tax, null, qt );
238                 }
239                 else {
240                     uniprot_tax = obtainUniProtTaxonomy( node.getName(), qt );
241                 }
242                 if ( uniprot_tax != null ) {
243                     if ( tax == null ) {
244                         tax = new Taxonomy();
245                         node.getNodeData().addTaxonomy( tax );
246                         node.setName( "" );
247                     }
248                     updateTaxonomy( qt, node, tax, uniprot_tax );
249                 }
250                 else {
251                     if ( tax != null ) {
252                         not_found.add( tax.toString() );
253                     }
254                     else {
255                         not_found.add( node.getName() );
256                     }
257                     if ( delete && node.isExternal() ) {
258                         not_found_external_nodes.add( node );
259                     }
260                 }
261             }
262         }
263         if ( delete ) {
264             for( final PhylogenyNode node : not_found_external_nodes ) {
265                 phy.deleteSubtree( node, true );
266             }
267             phy.externalNodesHaveChanged();
268             phy.clearHashIdToNodeMap();
269             phy.recalculateNumberOfExternalDescendants( true );
270         }
271         return not_found;
272     }
273
274     public final static UniProtTaxonomy obtainUniProtTaxonomy( final Taxonomy tax, Object query, QUERY_TYPE qt )
275             throws IOException, AncestralTaxonomyInferenceException {
276         if ( tax == null ) {
277             throw new IllegalArgumentException( "illegal attempt to use empty taxonomy object" );
278         }
279         if ( TaxonomyDataManager.isHasAppropriateId( tax ) ) {
280             query = tax.getIdentifier().getValue();
281             qt = QUERY_TYPE.ID;
282             return obtainTaxonomy( TaxonomyDataManager.getIdTaxCacheMap(), query, qt );
283         }
284         else if ( !ForesterUtil.isEmpty( tax.getScientificName() ) ) {
285             if ( !ForesterUtil.isEmpty( tax.getLineage() ) ) {
286                 query = tax.getLineage();
287                 qt = QUERY_TYPE.LIN;
288                 return obtainTaxonomy( TaxonomyDataManager.getLineageTaxCacheMap(), query, qt );
289             }
290             else {
291                 query = tax.getScientificName();
292                 qt = QUERY_TYPE.SN;
293                 return obtainTaxonomy( TaxonomyDataManager.getSnTaxCacheMap(), query, qt );
294             }
295         }
296         else if ( !ForesterUtil.isEmpty( tax.getTaxonomyCode() ) ) {
297             query = tax.getTaxonomyCode();
298             qt = QUERY_TYPE.CODE;
299             return obtainTaxonomy( TaxonomyDataManager.getCodeTaxCacheMap(), query, qt );
300         }
301         else {
302             query = tax.getCommonName();
303             qt = QUERY_TYPE.CN;
304             return obtainTaxonomy( TaxonomyDataManager.getCnTaxCacheMap(), query, qt );
305         }
306     }
307
308     public final static UniProtTaxonomy obtainUniProtTaxonomy( final String simple_name, QUERY_TYPE qt )
309             throws IOException, AncestralTaxonomyInferenceException {
310         if ( ForesterUtil.isEmpty( simple_name ) ) {
311             throw new IllegalArgumentException( "illegal attempt to use empty simple name" );
312         }
313         qt = QUERY_TYPE.SN;
314         UniProtTaxonomy ut = obtainTaxonomy( TaxonomyDataManager.getSnTaxCacheMap(), simple_name, qt );
315         if ( ut == null ) {
316             qt = QUERY_TYPE.CODE;
317             ut = obtainTaxonomy( TaxonomyDataManager.getCodeTaxCacheMap(), simple_name, qt );
318         }
319         if ( ut == null ) {
320             qt = QUERY_TYPE.CN;
321             ut = obtainTaxonomy( TaxonomyDataManager.getCnTaxCacheMap(), simple_name, qt );
322         }
323         return ut;
324     }
325
326     static final UniProtTaxonomy obtainUniProtTaxonomyFromLineage( final List<String> lineage )
327             throws AncestralTaxonomyInferenceException, IOException {
328         final String lineage_str = ForesterUtil.stringListToString( lineage, ">" );
329         if ( TaxonomyDataManager.getLineageTaxCacheMap().containsKey( lineage_str ) ) {
330             return TaxonomyDataManager.getLineageTaxCacheMap().get( lineage_str ).copy();
331         }
332         else {
333             final List<UniProtTaxonomy> matching_taxonomies = new ArrayList<UniProtTaxonomy>();
334             final List<UniProtTaxonomy> up_taxonomies = getTaxonomiesFromScientificName( lineage
335                     .get( lineage.size() - 1 ) );
336             if ( ( up_taxonomies != null ) && ( up_taxonomies.size() > 0 ) ) {
337                 for( final UniProtTaxonomy up_taxonomy : up_taxonomies ) {
338                     boolean match = true;
339                     I: for( int i = 0; i < lineage.size(); ++i ) {
340                         if ( ( i == up_taxonomy.getLineage().size() )
341                                 || !lineage.get( i ).equalsIgnoreCase( up_taxonomy.getLineage().get( i ) ) ) {
342                             match = false;
343                             break I;
344                         }
345                     }
346                     if ( match ) {
347                         matching_taxonomies.add( up_taxonomy );
348                     }
349                 }
350                 if ( matching_taxonomies.isEmpty() ) {
351                     throw new AncestralTaxonomyInferenceException( "lineage \""
352                             + ForesterUtil.stringListToString( lineage, " > " ) + "\" not found" );
353                 }
354                 //in case of more than one (e.g. "Xenopus" Genus and Subgenus), keep shorter, less specific  one:
355                 int shortest = Integer.MAX_VALUE;
356                 UniProtTaxonomy least_specific_up_tax = null;
357                 for( final UniProtTaxonomy m : matching_taxonomies ) {
358                     final int s = m.getLineage().size();
359                     if ( s < shortest ) {
360                         shortest = s;
361                         least_specific_up_tax = m;
362                     }
363                 }
364                 TaxonomyDataManager.getLineageTaxCacheMap().put( lineage_str, least_specific_up_tax );
365                 if ( !ForesterUtil.isEmpty( least_specific_up_tax.getScientificName() ) ) {
366                     TaxonomyDataManager.getSnTaxCacheMap().put( least_specific_up_tax.getScientificName(),
367                                                                 least_specific_up_tax );
368                 }
369                 if ( !ForesterUtil.isEmpty( least_specific_up_tax.getCode() ) ) {
370                     TaxonomyDataManager.getCodeTaxCacheMap().put( least_specific_up_tax.getCode(),
371                                                                   least_specific_up_tax );
372                 }
373                 if ( !ForesterUtil.isEmpty( least_specific_up_tax.getCommonName() ) ) {
374                     TaxonomyDataManager.getCnTaxCacheMap().put( least_specific_up_tax.getCommonName(),
375                                                                 least_specific_up_tax );
376                 }
377                 if ( !ForesterUtil.isEmpty( least_specific_up_tax.getId() ) ) {
378                     TaxonomyDataManager.getIdTaxCacheMap().put( least_specific_up_tax.getId(), least_specific_up_tax );
379                 }
380                 return least_specific_up_tax;
381             }
382             else {
383                 throw new AncestralTaxonomyInferenceException( "taxonomy \"" + ( lineage.get( lineage.size() - 1 ) )
384                         + "\" not found" );
385             }
386         }
387     }
388
389     synchronized final private static void updateTaxonomy( final QUERY_TYPE qt,
390                                                            final PhylogenyNode node,
391                                                            final Taxonomy tax,
392                                                            final UniProtTaxonomy up_tax )
393             throws PhyloXmlDataFormatException {
394         if ( ( qt != QUERY_TYPE.SN ) && !ForesterUtil.isEmpty( up_tax.getScientificName() )
395                 && ForesterUtil.isEmpty( tax.getScientificName() ) ) {
396             tax.setScientificName( up_tax.getScientificName() );
397         }
398         if ( node.isExternal() && ( qt != QUERY_TYPE.CODE ) && !ForesterUtil.isEmpty( up_tax.getCode() )
399                 && ForesterUtil.isEmpty( tax.getTaxonomyCode() ) ) {
400             tax.setTaxonomyCode( up_tax.getCode() );
401         }
402         if ( ( qt != QUERY_TYPE.CN ) && !ForesterUtil.isEmpty( up_tax.getCommonName() )
403                 && ForesterUtil.isEmpty( tax.getCommonName() ) ) {
404             tax.setCommonName( up_tax.getCommonName() );
405         }
406         if ( !ForesterUtil.isEmpty( up_tax.getSynonym() ) && !tax.getSynonyms().contains( up_tax.getSynonym() ) ) {
407             tax.getSynonyms().add( up_tax.getSynonym() );
408         }
409         if ( !ForesterUtil.isEmpty( up_tax.getRank() ) && ForesterUtil.isEmpty( tax.getRank() ) ) {
410             try {
411                 tax.setRank( up_tax.getRank().toLowerCase() );
412             }
413             catch ( final PhyloXmlDataFormatException ex ) {
414                 tax.setRank( "" );
415             }
416         }
417         if ( ( qt != QUERY_TYPE.ID ) && !ForesterUtil.isEmpty( up_tax.getId() )
418                 && ( ( tax.getIdentifier() == null ) || ForesterUtil.isEmpty( tax.getIdentifier().getValue() ) ) ) {
419             tax.setIdentifier( new Identifier( up_tax.getId(), "uniprot" ) );
420         }
421         if ( up_tax.getLineage() != null ) {
422             tax.setLineage( new ArrayList<String>() );
423             for( final String lin : up_tax.getLineage() ) {
424                 if ( !ForesterUtil.isEmpty( lin ) ) {
425                     tax.getLineage().add( lin );
426                 }
427             }
428         }
429     }
430
431     private final void execute() {
432         start( _mf, "taxonomy data" );
433         SortedSet<String> not_found = null;
434         try {
435             not_found = obtainDetailedTaxonomicInformation( _phy, _delete, _allow_simple_names );
436         }
437         catch ( final UnknownHostException e ) {
438             JOptionPane.showMessageDialog( _mf,
439                                            "Could not connect to \"" + getBaseUrl() + "\"",
440                                            "Network error during taxonomic information gathering",
441                                            JOptionPane.ERROR_MESSAGE );
442             return;
443         }
444         catch ( final IOException e ) {
445             e.printStackTrace();
446             JOptionPane.showMessageDialog( _mf,
447                                            e.toString(),
448                                            "Failed to obtain taxonomic information",
449                                            JOptionPane.ERROR_MESSAGE );
450             return;
451         }
452         catch ( final AncestralTaxonomyInferenceException e ) {
453             e.printStackTrace();
454             JOptionPane.showMessageDialog( _mf,
455                                            e.toString(),
456                                            "Failed to obtain taxonomic information",
457                                            JOptionPane.ERROR_MESSAGE );
458             return;
459         }
460         finally {
461             end( _mf );
462         }
463         if ( ( _phy == null ) || _phy.isEmpty() ) {
464             try {
465                 JOptionPane.showMessageDialog( _mf,
466                                                "None of the external node taxonomies could be resolved",
467                                                "Taxonomy Tool Failed",
468                                                JOptionPane.WARNING_MESSAGE );
469             }
470             catch ( final Exception e ) {
471                 // Not important if this fails, do nothing. 
472             }
473             return;
474         }
475         _treepanel.setTree( _phy );
476         _mf.showWhole();
477         _treepanel.setEdited( true );
478         if ( ( not_found != null ) && ( not_found.size() > 0 ) ) {
479             int max = not_found.size();
480             boolean more = false;
481             if ( max > 20 ) {
482                 more = true;
483                 max = 20;
484             }
485             final StringBuffer sb = new StringBuffer();
486             sb.append( "Not all taxonomies could be resolved.\n" );
487             if ( not_found.size() == 1 ) {
488                 if ( _delete ) {
489                     sb.append( "The following taxonomy was not found and deleted (if external):\n" );
490                 }
491                 else {
492                     sb.append( "The following taxonomy was not found:\n" );
493                 }
494             }
495             else {
496                 if ( _delete ) {
497                     sb.append( "The following taxonomies were not found and deleted (if external) (total: "
498                             + not_found.size() + "):\n" );
499                 }
500                 else {
501                     sb.append( "The following taxonomies were not found (total: " + not_found.size() + "):\n" );
502                 }
503             }
504             int i = 0;
505             for( final String string : not_found ) {
506                 if ( i > 19 ) {
507                     break;
508                 }
509                 sb.append( string );
510                 sb.append( "\n" );
511                 ++i;
512             }
513             if ( more ) {
514                 sb.append( "..." );
515             }
516             try {
517                 JOptionPane.showMessageDialog( _mf,
518                                                sb.toString(),
519                                                "Taxonomy Tool Completed",
520                                                JOptionPane.WARNING_MESSAGE );
521             }
522             catch ( final Exception e ) {
523                 // Not important if this fails, do nothing. 
524             }
525         }
526         else {
527             try {
528                 JOptionPane.showMessageDialog( _mf,
529                                                "Taxonomy tool successfully completed",
530                                                "Taxonomy Tool Completed",
531                                                JOptionPane.INFORMATION_MESSAGE );
532             }
533             catch ( final Exception e ) {
534                 // Not important if this fails, do nothing.
535             }
536         }
537     }
538
539     private final String getBaseUrl() {
540         return AncestralTaxonomyInferrer.getBaseUrl();
541     }
542
543     @Override
544     public void run() {
545         execute();
546     }
547 }