]> git.mxchange.org Git - flightgear.git/blob - src/Environment/environment_ctrl.cxx
Make FlightGear work with 16bpp:
[flightgear.git] / src / Environment / environment_ctrl.cxx
1 // environment_ctrl.cxx -- manager for natural environment information.
2 //
3 // Written by David Megginson, started February 2002.
4 //
5 // Copyright (C) 2002  David Megginson - david@megginson.com
6 //
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License as
9 // published by the Free Software Foundation; either version 2 of the
10 // License, or (at your option) any later version.
11 //
12 // This program is distributed in the hope that it will be useful, but
13 // WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 // General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 //
21 // $Id$
22
23 #include <simgear/debug/logstream.hxx>
24
25 #include <stdlib.h>
26 #include <algorithm>
27
28 #include <simgear/structure/commands.hxx>
29 #include <simgear/structure/exception.hxx>
30
31 #include <Airports/simple.hxx>
32 #include <Main/fg_props.hxx>
33 #include <Main/util.hxx>
34
35 #include "environment_mgr.hxx"
36 #include "environment_ctrl.hxx"
37
38 SG_USING_STD(sort);
39
40
41 \f
42 ////////////////////////////////////////////////////////////////////////
43 // Implementation of FGEnvironmentCtrl abstract base class.
44 ////////////////////////////////////////////////////////////////////////
45
46 FGEnvironmentCtrl::FGEnvironmentCtrl ()
47   : _environment(0),
48     _lon_deg(0),
49     _lat_deg(0),
50     _elev_ft(0)
51 {
52 }
53
54 FGEnvironmentCtrl::~FGEnvironmentCtrl ()
55 {
56 }
57
58 void
59 FGEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
60 {
61   _environment = environment;
62 }
63
64 void
65 FGEnvironmentCtrl::setLongitudeDeg (double lon_deg)
66 {
67   _lon_deg = lon_deg;
68 }
69
70 void
71 FGEnvironmentCtrl::setLatitudeDeg (double lat_deg)
72 {
73   _lat_deg = lat_deg;
74 }
75
76 void
77 FGEnvironmentCtrl::setElevationFt (double elev_ft)
78 {
79   _elev_ft = elev_ft;
80 }
81
82 void
83 FGEnvironmentCtrl::setPosition (double lon_deg, double lat_deg, double elev_ft)
84 {
85   _lon_deg = lon_deg;
86   _lat_deg = lat_deg;
87   _elev_ft = elev_ft;
88 }
89
90
91 \f
92 ////////////////////////////////////////////////////////////////////////
93 // Implementation of FGUserDefEnvironmentCtrl.
94 ////////////////////////////////////////////////////////////////////////
95
96 FGUserDefEnvironmentCtrl::FGUserDefEnvironmentCtrl ()
97   : _base_wind_speed_node(0),
98     _gust_wind_speed_node(0),
99     _current_wind_speed_kt(0),
100     _delta_wind_speed_kt(0)
101 {
102 }
103
104 FGUserDefEnvironmentCtrl::~FGUserDefEnvironmentCtrl ()
105 {
106 }
107
108 void
109 FGUserDefEnvironmentCtrl::init ()
110 {
111                                 // Fill in some defaults.
112   if (!fgHasNode("/environment/params/base-wind-speed-kt"))
113     fgSetDouble("/environment/params/base-wind-speed-kt",
114                 fgGetDouble("/environment/wind-speed-kt"));
115   if (!fgHasNode("/environment/params/gust-wind-speed-kt"))
116     fgSetDouble("/environment/params/gust-wind-speed-kt",
117                 fgGetDouble("/environment/params/base-wind-speed-kt"));
118
119   _base_wind_speed_node =
120     fgGetNode("/environment/params/base-wind-speed-kt", true);
121   _gust_wind_speed_node =
122     fgGetNode("/environment/params/gust-wind-speed-kt", true);
123
124   _current_wind_speed_kt = _base_wind_speed_node->getDoubleValue();
125   _delta_wind_speed_kt = 0.1;
126 }
127
128 void
129 FGUserDefEnvironmentCtrl::update (double dt)
130 {
131   double base_wind_speed = _base_wind_speed_node->getDoubleValue();
132   double gust_wind_speed = _gust_wind_speed_node->getDoubleValue();
133
134   if (gust_wind_speed < base_wind_speed) {
135       gust_wind_speed = base_wind_speed;
136       _gust_wind_speed_node->setDoubleValue(gust_wind_speed);
137   }
138
139   if (base_wind_speed == gust_wind_speed) {
140     _current_wind_speed_kt = base_wind_speed;
141   } else {
142     int rn = rand() % 128;
143     int sign = (_delta_wind_speed_kt < 0 ? -1 : 1);
144     double gust = _current_wind_speed_kt - base_wind_speed;
145     double incr = gust / 50;
146
147     if (rn == 0)
148       _delta_wind_speed_kt = - _delta_wind_speed_kt;
149     else if (rn < 4)
150       _delta_wind_speed_kt -= incr * sign;
151     else if (rn < 16)
152       _delta_wind_speed_kt += incr * sign;
153
154     _current_wind_speed_kt += _delta_wind_speed_kt;
155
156     if (_current_wind_speed_kt < base_wind_speed) {
157       _current_wind_speed_kt = base_wind_speed;
158       _delta_wind_speed_kt = 0.01;
159     } else if (_current_wind_speed_kt > gust_wind_speed) {
160       _current_wind_speed_kt = gust_wind_speed;
161       _delta_wind_speed_kt = -0.01;
162     }
163   }
164   
165   if (_environment != 0)
166     _environment->set_wind_speed_kt(_current_wind_speed_kt);
167 }
168
169
170 \f
171 ////////////////////////////////////////////////////////////////////////
172 // Implementation of FGInterpolateEnvironmentCtrl.
173 ////////////////////////////////////////////////////////////////////////
174
175 FGInterpolateEnvironmentCtrl::FGInterpolateEnvironmentCtrl ()
176 {
177 }
178
179 FGInterpolateEnvironmentCtrl::~FGInterpolateEnvironmentCtrl ()
180 {
181     unsigned int i;
182     for (i = 0; i < _boundary_table.size(); i++)
183         delete _boundary_table[i];
184     for (i = 0; i < _aloft_table.size(); i++)
185         delete _aloft_table[i];
186 }
187
188
189
190 void
191 FGInterpolateEnvironmentCtrl::init ()
192 {
193     read_table(fgGetNode("/environment/config/boundary", true),
194                _boundary_table);
195     read_table(fgGetNode("/environment/config/aloft", true),
196                _aloft_table);
197 }
198
199 void
200 FGInterpolateEnvironmentCtrl::reinit ()
201 {
202     unsigned int i;
203     for (i = 0; i < _boundary_table.size(); i++)
204         delete _boundary_table[i];
205     for (i = 0; i < _aloft_table.size(); i++)
206         delete _aloft_table[i];
207     _boundary_table.clear();
208     _aloft_table.clear();
209     init();
210 }
211
212 void
213 FGInterpolateEnvironmentCtrl::read_table (const SGPropertyNode * node,
214                                           vector<bucket *> &table)
215 {
216     for (int i = 0; i < node->nChildren(); i++) {
217         const SGPropertyNode * child = node->getChild(i);
218         if ( strcmp(child->getName(), "entry") == 0
219              && child->getStringValue("elevation-ft", "")[0] != '\0'
220              && ( child->getDoubleValue("elevation-ft") > 0.1 || i == 0 ) )
221         {
222             bucket * b = new bucket;
223             if (i > 0)
224                 b->environment.copy(table[i-1]->environment);
225             b->environment.read(child);
226             b->altitude_ft = b->environment.get_elevation_ft();
227             table.push_back(b);
228         }
229     }
230     sort(table.begin(), table.end());
231 }
232
233 void
234 FGInterpolateEnvironmentCtrl::update (double delta_time_sec)
235 {
236                                 // FIXME
237     double altitude_ft = fgGetDouble("/position/altitude-ft");
238     double altitude_agl_ft = fgGetDouble("/position/altitude-agl-ft");
239     double boundary_transition =
240         fgGetDouble("/environment/config/boundary-transition-ft", 500);
241
242     // double ground_elevation_ft = altitude_ft - altitude_agl_ft;
243
244     int length = _boundary_table.size();
245
246     if (length > 0) {
247                                 // boundary table
248         double boundary_limit = _boundary_table[length-1]->altitude_ft;
249         if (boundary_limit >= altitude_agl_ft) {
250             do_interpolate(_boundary_table, altitude_agl_ft,
251                            _environment);
252             return;
253         } else if ((boundary_limit + boundary_transition) >= altitude_agl_ft) {
254                                 // both tables
255             do_interpolate(_boundary_table, altitude_agl_ft, &env1);
256             do_interpolate(_aloft_table, altitude_ft, &env2);
257             double fraction =
258                 (altitude_agl_ft - boundary_limit) / boundary_transition;
259             interpolate(&env1, &env2, fraction, _environment);
260             return;
261         }
262     }
263
264                                 // aloft table
265     do_interpolate(_aloft_table, altitude_ft, _environment);
266 }
267
268 void
269 FGInterpolateEnvironmentCtrl::do_interpolate (vector<bucket *> &table,
270                                               double altitude_ft,
271                                               FGEnvironment * environment)
272 {
273     int length = table.size();
274     if (length == 0)
275         return;
276
277                                 // Boundary conditions
278     if ((length == 1) || (table[0]->altitude_ft >= altitude_ft)) {
279         environment->copy(table[0]->environment);
280         return;
281     } else if (table[length-1]->altitude_ft <= altitude_ft) {
282         environment->copy(table[length-1]->environment);
283         return;
284     }
285         
286                                 // Search the interpolation table
287     for (int i = 0; i < length - 1; i++) {
288         if ((i == length - 1) || (table[i]->altitude_ft <= altitude_ft)) {
289                 FGEnvironment * env1 = &(table[i]->environment);
290                 FGEnvironment * env2 = &(table[i+1]->environment);
291                 double fraction;
292                 if (table[i]->altitude_ft == table[i+1]->altitude_ft)
293                     fraction = 1.0;
294                 else
295                     fraction =
296                         ((altitude_ft - table[i]->altitude_ft) /
297                          (table[i+1]->altitude_ft - table[i]->altitude_ft));
298                 interpolate(env1, env2, fraction, environment);
299
300                 return;
301         }
302     }
303 }
304
305 bool
306 FGInterpolateEnvironmentCtrl::bucket::operator< (const bucket &b) const
307 {
308     return (altitude_ft < b.altitude_ft);
309 }
310
311
312 \f
313 ////////////////////////////////////////////////////////////////////////
314 // Implementation of FGMetarEnvironmentCtrl.
315 ////////////////////////////////////////////////////////////////////////
316
317 FGMetarEnvironmentCtrl::FGMetarEnvironmentCtrl ()
318     : env( new FGInterpolateEnvironmentCtrl ),
319       _icao( "" ),
320       search_interval_sec( 60.0 ),        // 1 minute
321       same_station_interval_sec( 900.0 ), // 15 minutes
322       search_elapsed( 9999.0 ),
323       fetch_elapsed( 9999.0 ),
324       proxy_host( fgGetNode("/sim/presets/proxy/host", true) ),
325       proxy_port( fgGetNode("/sim/presets/proxy/port", true) ),
326       proxy_auth( fgGetNode("/sim/presets/proxy/authentication", true) ),
327       _error_dt( 0.0 ),
328       _error_count( 0 )
329 {
330 #if defined(ENABLE_THREADS) && ENABLE_THREADS
331     thread = new MetarThread(this);
332     thread->start();
333 #endif // ENABLE_THREADS
334 }
335
336 FGMetarEnvironmentCtrl::~FGMetarEnvironmentCtrl ()
337 {
338 #if defined(ENABLE_THREADS) && ENABLE_THREADS
339    thread->cancel();
340    thread->join();
341 #endif // ENABLE_THREADS
342
343    delete env;
344    env = NULL;
345 }
346
347
348 // use a "command" to set station temp at station elevation
349 static void set_temp_at_altitude( float temp_degc, float altitude_ft ) {
350     SGPropertyNode args;
351     SGPropertyNode *node = args.getNode("temp-degc", 0, true);
352     node->setFloatValue( temp_degc );
353     node = args.getNode("altitude-ft", 0, true);
354     node->setFloatValue( altitude_ft );
355     globals->get_commands()->execute("set-outside-air-temp-degc", &args);
356 }
357
358
359 static void set_dewpoint_at_altitude( float dewpoint_degc, float altitude_ft ) {
360     SGPropertyNode args;
361     SGPropertyNode *node = args.getNode("dewpoint-degc", 0, true);
362     node->setFloatValue( dewpoint_degc );
363     node = args.getNode("altitude-ft", 0, true);
364     node->setFloatValue( altitude_ft );
365     globals->get_commands()->execute("set-dewpoint-temp-degc", &args);
366 }
367
368
369 void
370 FGMetarEnvironmentCtrl::update_env_config ()
371 {
372     fgSetupWind( fgGetDouble("/environment/metar/base-wind-range-from"),
373                  fgGetDouble("/environment/metar/base-wind-range-to"),
374                  fgGetDouble("/environment/metar/base-wind-speed-kt"),
375                  fgGetDouble("/environment/metar/gust-wind-speed-kt") );
376
377     fgDefaultWeatherValue( "visibility-m",
378                            fgGetDouble("/environment/metar/min-visibility-m") );
379     set_temp_at_altitude( fgGetDouble("/environment/metar/temperature-degc"),
380                           station_elevation_ft );
381     set_dewpoint_at_altitude( fgGetDouble("/environment/metar/dewpoint-degc"),
382                               station_elevation_ft );
383     fgDefaultWeatherValue( "pressure-sea-level-inhg",
384                            fgGetDouble("/environment/metar/pressure-inhg") );
385 }
386
387 void
388 FGMetarEnvironmentCtrl::init ()
389 {
390     const SGPropertyNode *longitude
391         = fgGetNode( "/position/longitude-deg", true );
392     const SGPropertyNode *latitude
393         = fgGetNode( "/position/latitude-deg", true );
394
395     bool found_metar = false;
396
397     while ( !found_metar && (_error_count < 3) ) {
398         FGAirport a = globals->get_airports()
399             ->search( longitude->getDoubleValue(),
400                       latitude->getDoubleValue(),
401                       true );
402         FGMetarResult result = fetch_data( a.id );
403         if ( result.m != NULL ) {
404             SG_LOG( SG_GENERAL, SG_INFO, "closest station w/ metar = " << a.id);
405             last_apt = a;
406             _icao = a.id;
407             search_elapsed = 0.0;
408             fetch_elapsed = 0.0;
409             update_metar_properties( result.m );
410             update_env_config();
411             env->init();
412             found_metar = true;
413         } else {
414             // mark as no metar so it doesn't show up in subsequent
415             // searches.
416             SG_LOG( SG_GENERAL, SG_INFO, "no metar at metar = " << a.id );
417             globals->get_airports()->no_metar( a.id );
418         }
419     }
420 }
421
422 void
423 FGMetarEnvironmentCtrl::reinit ()
424 {
425     _error_count = 0;
426     _error_dt = 0.0;
427
428 #if 0
429     update_env_config();
430 #endif
431
432     env->reinit();
433 }
434
435 void
436 FGMetarEnvironmentCtrl::update(double delta_time_sec)
437 {
438
439     _dt += delta_time_sec;
440     if (_error_count >= 3)
441        return;
442
443     FGMetarResult result;
444
445     static const SGPropertyNode *longitude
446         = fgGetNode( "/position/longitude-deg", true );
447     static const SGPropertyNode *latitude
448         = fgGetNode( "/position/latitude-deg", true );
449     search_elapsed += delta_time_sec;
450     fetch_elapsed += delta_time_sec;
451
452     // if time for a new search request, push it onto the request
453     // queue
454     if ( search_elapsed > search_interval_sec ) {
455         FGAirport a = globals->get_airports()
456             ->search( longitude->getDoubleValue(),
457                       latitude->getDoubleValue(),
458                       true );
459         if ( last_apt.id != a.id
460              || fetch_elapsed > same_station_interval_sec )
461         {
462             SG_LOG( SG_GENERAL, SG_INFO, "closest station w/ metar = " << a.id);
463             request_queue.push( a.id );
464             last_apt = a;
465             _icao = a.id;
466             search_elapsed = 0.0;
467             fetch_elapsed = 0.0;
468         } else {
469             search_elapsed = 0.0;
470             SG_LOG( SG_GENERAL, SG_INFO, "same station, waiting = "
471                  << same_station_interval_sec - fetch_elapsed );
472         }
473     }
474
475 #if defined(ENABLE_THREADS) && ENABLE_THREADS
476     // No loader thread running so manually fetch the data
477     string id = "";
478     while ( !request_queue.empty() ) {
479         id = request_queue.front();
480         request_queue.pop();
481     }
482
483     if ( !id.empty() ) {
484         SG_LOG( SG_GENERAL, SG_INFO, "inline fetching = " << id );
485         result = fetch_data( id );
486         result_queue.push( result );
487     }
488 #endif // ENABLE_THREADS
489
490     // process any results from the loader.
491     while ( !result_queue.empty() ) {
492         result = result_queue.front();
493         result_queue.pop();
494         if ( result.m != NULL ) {
495             update_metar_properties( result.m );
496             delete result.m;
497             update_env_config();
498             env->reinit();
499         } else {
500             // mark as no metar so it doesn't show up in subsequent
501             // searches, and signal an immediate re-search.
502             SG_LOG( SG_GENERAL, SG_WARN,
503                     "no metar at station = " << result.icao );
504             globals->get_airports()->no_metar( result.icao );
505             search_elapsed = 9999.0;
506         }
507     }
508
509     env->update(delta_time_sec);
510 }
511
512
513 void
514 FGMetarEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
515 {
516     env->setEnvironment(environment);
517 }
518
519 FGMetarResult
520 FGMetarEnvironmentCtrl::fetch_data( const string &icao )
521 {
522     FGMetarResult result;
523     result.icao = icao;
524
525     // if the last error was more than three seconds ago,
526     // then pretent nothing happened.
527     if (_error_dt < 3) {
528         _error_dt += _dt;
529
530     } else {
531         _error_dt = 0.0;
532         _error_count = 0;
533     }
534
535     // fetch station elevation if exists
536     FGAirport a = globals->get_airports()->search( icao );
537     station_elevation_ft = a.elevation;
538
539     // fetch current metar data
540     try {
541         string host = proxy_host->getStringValue();
542         string auth = proxy_auth->getStringValue();
543         string port = proxy_port->getStringValue();
544         result.m = new SGMetar( icao, host, port, auth);
545
546     } catch (const sg_io_exception& e) {
547         SG_LOG( SG_GENERAL, SG_WARN, "Error fetching live weather data: "
548                 << e.getFormattedMessage().c_str() );
549 #if defined(ENABLE_THREADS) && ENABLE_THREADS
550         if (_error_count++ >= 3) {
551            SG_LOG( SG_GENERAL, SG_WARN, "Stop fetching data permanently.");
552            thread->cancel();
553            thread->join();
554         }
555 #endif
556
557         result.m = NULL;
558     }
559
560     _dt = 0;
561
562     return result;
563 }
564
565
566 void
567 FGMetarEnvironmentCtrl::update_metar_properties( SGMetar *m )
568 {
569     int i;
570     double d, dt;
571     char s[128];
572
573     d = m->getMinVisibility().getVisibility_m();
574     d = (d != SGMetarNaN) ? d : 10000;
575     fgSetDouble("/environment/metar/min-visibility-m", d);
576
577     dt =  m->getMaxVisibility().getVisibility_m();
578     d = (dt != SGMetarNaN) ? dt : d;
579     fgSetDouble("/environment/metar/max-visibility-m", d);
580
581     SGMetarVisibility *dirvis = m->getDirVisibility();
582     for (i = 0; i < 8; i++, dirvis++) {
583         const char *min = "/environment/metar/visibility[%d]/min-m";
584         const char *max = "/environment/metar/visibility[%d]/max-m";
585         char s[128];
586
587         d = dirvis->getVisibility_m();
588         d = (d != SGMetarNaN) ? d : 10000;
589
590         snprintf(s, 128, min, i);
591         fgSetDouble(s, d);
592         snprintf(s, 128, max, i);
593         fgSetDouble(s, d);
594     }
595
596     i = m->getWindDir();
597     if ( i == -1 ) {
598         fgSetInt("/environment/metar/base-wind-range-from",
599                  m->getWindRangeFrom() );
600         fgSetInt("/environment/metar/base-wind-range-to",
601                  m->getWindRangeTo() );
602     } else {
603         fgSetInt("/environment/metar/base-wind-range-from", i);
604         fgSetInt("/environment/metar/base-wind-range-to", i);
605     }
606     fgSetDouble("/environment/metar/base-wind-speed-kt",
607                 m->getWindSpeed_kt() );
608
609     d = m->getGustSpeed_kt();
610     d = (d != SGMetarNaN) ? d : 0.0;
611     fgSetDouble("/environment/metar/gust-wind-speed-kt", d);
612
613     d = m->getTemperature_C();
614     if (d != SGMetarNaN) {
615         dt = m->getDewpoint_C();
616         dt = (dt != SGMetarNaN) ? dt : 0.0;
617         fgSetDouble("/environment/metar/dewpoint-degc", dt);
618         fgSetDouble("/environment/metar/rel-humidity-norm",
619                     m->getRelHumidity() );
620     }
621     d = (d != SGMetarNaN) ? d : 15.0;
622     fgSetDouble("/environment/metar/temperature-degc", d);
623
624     d = m->getPressure_inHg();
625     d = (d != SGMetarNaN) ? d : 30.0;
626     fgSetDouble("/environment/metar/pressure-inhg", d);
627
628     vector<SGMetarCloud> cv = m->getClouds();
629     vector<SGMetarCloud>::iterator cloud;
630
631     const char *cl = "/environment/clouds/layer[%i]";
632     for (i = 0, cloud = cv.begin(); cloud != cv.end(); cloud++, i++) {
633         const char *coverage_string[5] = 
634             { "clear", "few", "scattered", "broken", "overcast" };
635         const double thickness[5] = { 0, 65, 600,750, 1000};
636         int q;
637
638         snprintf(s, 128, cl, i);
639         strncat(s, "/coverage", 128);
640         q = cloud->getCoverage();
641         q = (q != -1 ) ? q : 0;
642         fgSetString(s, coverage_string[q] );
643
644         snprintf(s, 128, cl, i);
645         strncat(s, "/elevation-ft", 128);
646         d = cloud->getAltitude_ft();
647         d = (d != SGMetarNaN) ? d : -9999;
648         fgSetDouble(s, d + station_elevation_ft);
649
650         snprintf(s, 128, cl, i);
651         strncat(s, "/thickness-ft", 128);
652         fgSetDouble(s, thickness[q]);
653
654         snprintf(s, 128, cl, i);
655         strncat(s, "/span-m", 128);
656         fgSetDouble(s, 40000.0);
657     }
658
659     for (; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
660         snprintf(s, 128, cl, i);
661         strncat(s, "/coverage", 128);
662         fgSetString(s, "clear");
663
664         snprintf(s, 128, cl, i);
665         strncat(s, "/elevation-ft", 128);
666         fgSetDouble(s, -9999);
667
668         snprintf(s, 128, cl, i);
669         strncat(s, "/thickness-ft", 128);
670         fgSetDouble(s, 0);
671
672         snprintf(s, 128, cl, i);
673         strncat(s, "/span-m", 128);
674         fgSetDouble(s, 40000.0);
675     }
676 }
677
678
679 #if defined(ENABLE_THREADS) && ENABLE_THREADS
680 /**
681  *
682  */
683 void
684 FGMetarEnvironmentCtrl::MetarThread::run()
685 {
686     pthread_cleanup_push( metar_cleanup_handler, fetcher );
687     while ( true )
688     {
689         set_cancel( SGThread::CANCEL_DISABLE );
690
691         string icao = fetcher->request_queue.pop();
692         SG_LOG( SG_GENERAL, SG_INFO, "Thread: fetch metar data = " << icao );
693         FGMetarResult result = fetcher->fetch_data( icao );
694
695         set_cancel( SGThread::CANCEL_DEFERRED );
696
697         fetcher->result_queue.push( result );
698     }
699     pthread_cleanup_pop(1);
700 }
701
702 /**
703  * Ensure mutex is unlocked.
704  */
705 void
706 metar_cleanup_handler( void* arg )
707 {
708     FGMetarEnvironmentCtrl* fetcher = (FGMetarEnvironmentCtrl*) arg;
709     fetcher->mutex.unlock();
710 }
711 #endif // ENABLE_THREADS
712
713
714 // end of environment_ctrl.cxx