← Back to branch summary

~ubuntu-branches/ubuntu/breezy/ace/breezy

« back to all changes in this revision

Viewing changes to TAO/orbsvcs/Event_Service/Event_Service.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad, Benjamin Montgomery, Adam Conrad
  • Date: 2005-09-18 22:51:38 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge) (0.1.2 woody)
  • Revision ID: james.westby@ubuntu.com-20050918225138-seav22q6fyylb536
Tags: 5.4.7-3ubuntu1
[ Benjamin Montgomery ]
* Added a patch for amd64 and powerpc that disables the compiler
  option -fvisibility-inlines-hidden

[ Adam Conrad ]
* Added DPATCH_OPTION_CPP=1 to debian/patches/00options to make
  Benjamin's above changes work correctly with dpatch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
TAO/orbsvcs/Event_Service/Event_Service.cpp
1
 
// Event_Service.cpp,v 1.47 2003/11/04 05:21:30 dhinton Exp
2
 
 
3
 
#include "Event_Service.h"
4
 
 
5
 
#include "ace/Get_Opt.h"
6
 
#include "ace/Auto_Ptr.h"
7
 
#include "ace/Argv_Type_Converter.h"
8
 
#include "ace/OS_main.h"
9
 
 
10
 
#include "orbsvcs/CosNamingC.h"
11
 
#include "orbsvcs/Event_Utilities.h"
12
 
#include "orbsvcs/Sched/Config_Scheduler.h"
13
 
#include "orbsvcs/Event/Module_Factory.h"
14
 
#include "orbsvcs/Event/Event_Channel.h"
15
 
 
16
 
#include "orbsvcs/Event/EC_Default_Factory.h"
17
 
#include "orbsvcs/Event/EC_Event_Channel.h"
18
 
 
19
 
#include "tao/BiDir_GIOP/BiDirGIOP.h"
20
 
#include "ace/OS_NS_strings.h"
21
 
 
22
 
ACE_RCSID(Event_Service, Event_Service, "Event_Service.cpp,v 1.47 2003/11/04 05:21:30 dhinton Exp")
23
 
 
24
 
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
25
 
{
26
 
  TAO_EC_Default_Factory::init_svcs ();
27
 
 
28
 
  Event_Service event_service;
29
 
  return event_service.run (argc, argv);
30
 
}
31
 
 
32
 
// ****************************************************************
33
 
 
34
 
Event_Service::Event_Service (void)
35
 
  : module_factory_ (0),
36
 
    sched_impl_ (0),
37
 
    ec_impl_ (0),
38
 
    scheduler_type_ (ES_SCHED_NONE),
39
 
    event_service_type_ (ES_NEW),
40
 
    use_bidir_giop_ (0)
41
 
{
42
 
}
43
 
 
44
 
Event_Service::~Event_Service (void)
45
 
{
46
 
  delete this->ec_impl_;
47
 
  this->ec_impl_ = 0;
48
 
  delete this->sched_impl_;
49
 
  this->sched_impl_ = 0;
50
 
  delete this->module_factory_;
51
 
  this->module_factory_ = 0;
52
 
}
53
 
 
54
 
int
55
 
Event_Service::run (int argc, ACE_TCHAR* argv[])
56
 
{
57
 
  ACE_TRY_NEW_ENV
58
 
    {
59
 
      // Make a copy of command line parameter.
60
 
      ACE_Argv_Type_Converter command(argc, argv);
61
 
 
62
 
      // Initialize ORB.
63
 
      this->orb_ =
64
 
        CORBA::ORB_init (command.get_argc(), command.get_ASCII_argv(), "" ACE_ENV_ARG_PARAMETER);
65
 
      ACE_TRY_CHECK;
66
 
 
67
 
      if (this->parse_args (command.get_argc(), command.get_TCHAR_argv()) == -1)
68
 
        return 1;
69
 
 
70
 
      CORBA::Object_var root_poa_object =
71
 
        this->orb_->resolve_initial_references("RootPOA"
72
 
                                               ACE_ENV_ARG_PARAMETER);
73
 
      ACE_TRY_CHECK;
74
 
      if (CORBA::is_nil (root_poa_object.in ()))
75
 
        ACE_ERROR_RETURN ((LM_ERROR,
76
 
                           " (%P|%t) Unable to initialize the root POA.\n"),
77
 
                          1);
78
 
 
79
 
      PortableServer::POA_var root_poa =
80
 
        PortableServer::POA::_narrow (root_poa_object.in () ACE_ENV_ARG_PARAMETER);
81
 
      ACE_TRY_CHECK;
82
 
 
83
 
      PortableServer::POAManager_var poa_manager =
84
 
        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
85
 
      ACE_TRY_CHECK;
86
 
 
87
 
      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
88
 
      ACE_TRY_CHECK;
89
 
 
90
 
      CORBA::Object_var naming_obj =
91
 
        this->orb_->resolve_initial_references ("NameService" ACE_ENV_ARG_PARAMETER);
92
 
      ACE_TRY_CHECK;
93
 
      if (CORBA::is_nil (naming_obj.in ()))
94
 
        ACE_ERROR_RETURN ((LM_ERROR,
95
 
                           " (%P|%t) Unable to initialize the Naming Service.\n"),
96
 
                          1);
97
 
 
98
 
      CosNaming::NamingContext_var naming_context =
99
 
        CosNaming::NamingContext::_narrow (naming_obj.in () ACE_ENV_ARG_PARAMETER);
100
 
      ACE_TRY_CHECK;
101
 
 
102
 
      RtecScheduler::Scheduler_var scheduler;
103
 
      // This is the name we (potentially) register the Scheduling
104
 
      // Service in the Naming Service.
105
 
      CosNaming::Name schedule_name (1);
106
 
      schedule_name.length (1);
107
 
      schedule_name[0].id = CORBA::string_dup ("ScheduleService");
108
 
 
109
 
      // The old EC always needs a scheduler. If none is
110
 
      // specified, we default to a local scheduler
111
 
      if (this->scheduler_type_ == ES_SCHED_LOCAL ||
112
 
          (this->scheduler_type_ == ES_SCHED_NONE &&
113
 
           this->event_service_type_ != ES_NEW))
114
 
        {
115
 
          // Create a local scheduler instance
116
 
          ACE_NEW_RETURN (this->sched_impl_,
117
 
                          ACE_Config_Scheduler,
118
 
                          1);
119
 
 
120
 
          scheduler = this->sched_impl_->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
121
 
          ACE_TRY_CHECK;
122
 
 
123
 
          // Register the servant with the Naming Context....
124
 
          naming_context->rebind (schedule_name, scheduler.in ()
125
 
                                  ACE_ENV_ARG_PARAMETER);
126
 
          ACE_TRY_CHECK;
127
 
        }
128
 
      else if (this->scheduler_type_ == ES_SCHED_GLOBAL)
129
 
        {
130
 
          // Get reference to a scheduler from naming service
131
 
          CORBA::Object_var tmp =
132
 
            naming_context->resolve (schedule_name ACE_ENV_ARG_PARAMETER);
133
 
          ACE_TRY_CHECK;
134
 
 
135
 
          scheduler = RtecScheduler::Scheduler::_narrow (tmp.in ()
136
 
                                                         ACE_ENV_ARG_PARAMETER);
137
 
          ACE_TRY_CHECK;
138
 
 
139
 
          if (CORBA::is_nil (scheduler.in ()))
140
 
            ACE_ERROR_RETURN ((LM_ERROR,
141
 
                               " (%P|%t) Unable to resolve the Scheduling Service.\n"),
142
 
                              1);
143
 
        }
144
 
 
145
 
      switch (this->event_service_type_)
146
 
        {
147
 
        case ES_NEW:
148
 
          {
149
 
            TAO_EC_Event_Channel_Attributes attr (root_poa.in (),
150
 
                                                  root_poa.in ());
151
 
 
152
 
            if (this->scheduler_type_ != ES_SCHED_NONE)
153
 
              {
154
 
                attr.scheduler = scheduler.in ();
155
 
              }
156
 
 
157
 
            TAO_EC_Event_Channel* ec;
158
 
            ACE_NEW_RETURN (ec,
159
 
                            TAO_EC_Event_Channel (attr),
160
 
                            1);
161
 
            this->ec_impl_ = ec;
162
 
            ec->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
163
 
            ACE_TRY_CHECK;
164
 
          }
165
 
          break;
166
 
 
167
 
        case ES_OLD_REACTIVE:
168
 
          {
169
 
            ACE_NEW_RETURN (this->module_factory_,
170
 
                            TAO_Reactive_Module_Factory,
171
 
                            1);
172
 
            ACE_NEW_RETURN (this->ec_impl_,
173
 
                            ACE_EventChannel (scheduler.in (),
174
 
                                              1,
175
 
                                              ACE_DEFAULT_EVENT_CHANNEL_TYPE,
176
 
                                              this->module_factory_),
177
 
                            1);
178
 
          }
179
 
          break;
180
 
        case ES_OLD_MT:
181
 
          {
182
 
            ACE_NEW_RETURN (this->module_factory_,
183
 
                            TAO_Default_Module_Factory,
184
 
                            1);
185
 
 
186
 
            ACE_NEW_RETURN (this->ec_impl_,
187
 
                            ACE_EventChannel (scheduler.in (),
188
 
                                              1,
189
 
                                              ACE_DEFAULT_EVENT_CHANNEL_TYPE,
190
 
                                              this->module_factory_),
191
 
                            1);
192
 
          }
193
 
 
194
 
          break;
195
 
        }
196
 
 
197
 
      RtecEventChannelAdmin::EventChannel_var ec;
198
 
 
199
 
      // If the servant name is empty and we don't use BiDIR GIOP, activate the
200
 
      // servant under the default POA, else create a new child POA with persistent policies
201
 
      // the needed policies
202
 
      int persistent = ACE_OS::strcmp(this->servant_name_.c_str(), "");
203
 
      if ((persistent == 0) && (this->use_bidir_giop_ == 0))
204
 
        {
205
 
          // Notice that we activate *this* object with the POA, but we
206
 
          // forward all the requests to the underlying EC
207
 
          // implementation.
208
 
          ec = this->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
209
 
          ACE_TRY_CHECK;
210
 
        }
211
 
      else
212
 
        {
213
 
          int index = 0;
214
 
 
215
 
          // Create child POA
216
 
          CORBA::PolicyList policies (3);
217
 
 
218
 
          if (persistent == 1)
219
 
            {
220
 
              policies[index++] =
221
 
                root_poa->create_id_assignment_policy (PortableServer::USER_ID
222
 
                                                        ACE_ENV_ARG_PARAMETER);
223
 
              ACE_TRY_CHECK;
224
 
 
225
 
              policies[index++] =
226
 
                root_poa->create_lifespan_policy (PortableServer::PERSISTENT
227
 
                                                   ACE_ENV_ARG_PARAMETER);
228
 
              ACE_TRY_CHECK;
229
 
            }
230
 
 
231
 
          if (this->use_bidir_giop_ == 1)
232
 
            {
233
 
              CORBA::Any pol;
234
 
              pol <<= BiDirPolicy::BOTH;
235
 
              policies[index++] =
236
 
                this->orb_->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE,
237
 
                                           pol
238
 
                                            ACE_ENV_ARG_PARAMETER);
239
 
              ACE_TRY_CHECK;
240
 
            }
241
 
 
242
 
          policies.length (index);
243
 
 
244
 
          ACE_CString child_poa_name = "childPOA";
245
 
          PortableServer::POA_var child_poa =
246
 
            root_poa->create_POA (child_poa_name.c_str (),
247
 
                                  poa_manager.in (),
248
 
                                  policies
249
 
                                  ACE_ENV_ARG_PARAMETER);
250
 
          ACE_TRY_CHECK;
251
 
 
252
 
          // Creation of persistentPOA is over. Destroy the Policy objects.
253
 
          for (CORBA::ULong i = 0;
254
 
               i < policies.length ();
255
 
               ++i)
256
 
            {
257
 
              policies[i]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
258
 
              ACE_TRY_CHECK;
259
 
            }
260
 
 
261
 
          if (CORBA::is_nil (child_poa.in ()))
262
 
            ACE_ERROR_RETURN ((LM_ERROR,
263
 
                               " (%P|%t) Unable to initialize the child POA.\n"),
264
 
                              1);
265
 
 
266
 
          PortableServer::ObjectId_var ec_object_id =
267
 
            PortableServer::string_to_ObjectId(servant_name_.c_str());
268
 
 
269
 
          child_poa->activate_object_with_id(ec_object_id.in(),
270
 
                                             this
271
 
                                              ACE_ENV_ARG_PARAMETER);
272
 
          ACE_TRY_CHECK;
273
 
 
274
 
          CORBA::Object_var ec_obj =
275
 
            child_poa->id_to_reference(ec_object_id.in()
276
 
                                        ACE_ENV_ARG_PARAMETER);
277
 
          ACE_TRY_CHECK;
278
 
 
279
 
          ec =
280
 
            RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in()
281
 
                                                         ACE_ENV_ARG_PARAMETER);
282
 
          ACE_TRY_CHECK;
283
 
        }
284
 
 
285
 
      CORBA::String_var str =
286
 
         this->orb_->object_to_string (ec.in () ACE_ENV_ARG_PARAMETER);
287
 
      ACE_TRY_CHECK;
288
 
 
289
 
      if (ACE_OS::strcmp(this->ior_file_name_.c_str(), "") != 0)
290
 
        {
291
 
          FILE *output_file=
292
 
            ACE_OS::fopen (ACE_TEXT_CHAR_TO_TCHAR(this->ior_file_name_.c_str()),
293
 
                           ACE_LIB_TEXT("w"));
294
 
          if (output_file == 0)
295
 
            ACE_ERROR_RETURN ((LM_ERROR,
296
 
                               "Cannot open output file for writing IOR: %s",
297
 
                               this->ior_file_name_.c_str()),
298
 
                              1);
299
 
          ACE_OS::fprintf (output_file, "%s", str.in ());
300
 
          ACE_OS::fclose (output_file);
301
 
        }
302
 
 
303
 
      if (ACE_OS::strcmp(this->pid_file_name_.c_str(), "") != 0)
304
 
        {
305
 
          FILE *pidf =
306
 
            ACE_OS::fopen (ACE_TEXT_CHAR_TO_TCHAR(this->pid_file_name_.c_str()),
307
 
                           ACE_LIB_TEXT("w"));
308
 
          if (pidf != 0)
309
 
            {
310
 
              ACE_OS::fprintf (pidf,
311
 
                               "%ld\n",
312
 
                               ACE_static_cast (long, ACE_OS::getpid ()));
313
 
              ACE_OS::fclose (pidf);
314
 
            }
315
 
        }
316
 
 
317
 
      ACE_DEBUG ((LM_DEBUG,
318
 
                  ACE_LIB_TEXT("The EC IOR is <%s>\n"), ACE_TEXT_CHAR_TO_TCHAR(str.in ())));
319
 
 
320
 
      CosNaming::Name channel_name (1);
321
 
      channel_name.length (1);
322
 
      channel_name[0].id = CORBA::string_dup (this->service_name_.c_str());
323
 
      naming_context->rebind (channel_name, ec.in () ACE_ENV_ARG_PARAMETER);
324
 
      ACE_TRY_CHECK;
325
 
 
326
 
      ACE_DEBUG ((LM_DEBUG,
327
 
                  ACE_LIB_TEXT("%s; running event service\n"),
328
 
                  ACE_TEXT_CHAR_TO_TCHAR(__FILE__)));
329
 
      this->orb_->run (ACE_ENV_SINGLE_ARG_PARAMETER);
330
 
      ACE_TRY_CHECK;
331
 
 
332
 
      naming_context->unbind (channel_name ACE_ENV_ARG_PARAMETER);
333
 
      ACE_TRY_CHECK;
334
 
 
335
 
      if (!CORBA::is_nil (scheduler.in ()))
336
 
        {
337
 
          naming_context->unbind (schedule_name ACE_ENV_ARG_PARAMETER);
338
 
          ACE_TRY_CHECK;
339
 
        }
340
 
 
341
 
    }
342
 
  ACE_CATCHANY
343
 
    {
344
 
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "EC");
345
 
    }
346
 
  ACE_ENDTRY;
347
 
 
348
 
 
349
 
  return 0;
350
 
}
351
 
 
352
 
int
353
 
Event_Service::parse_args (int argc, ACE_TCHAR* argv [])
354
 
{
355
 
  // default values...
356
 
  this->service_name_ = "EventService";
357
 
 
358
 
  ACE_Get_Opt get_opt (argc, argv, ACE_LIB_TEXT("n:o:p:s:t:q:b"));
359
 
  int opt;
360
 
 
361
 
  while ((opt = get_opt ()) != EOF)
362
 
    {
363
 
      switch (opt)
364
 
        {
365
 
        case 'n':
366
 
          this->service_name_ = ACE_TEXT_ALWAYS_CHAR(get_opt.opt_arg ());
367
 
          break;
368
 
 
369
 
        case 'o':
370
 
          this->ior_file_name_ = ACE_TEXT_ALWAYS_CHAR(get_opt.opt_arg ());
371
 
          break;
372
 
 
373
 
        case 'p':
374
 
          this->pid_file_name_ = ACE_TEXT_ALWAYS_CHAR(get_opt.opt_arg ());
375
 
          break;
376
 
 
377
 
        case 'q':
378
 
          this->servant_name_ = ACE_TEXT_ALWAYS_CHAR(get_opt.opt_arg ());
379
 
          break;
380
 
 
381
 
        case 'b':
382
 
          this->use_bidir_giop_ = 1;
383
 
          break;
384
 
 
385
 
        case 's':
386
 
          // It could be just a flag (i.e. no "global" or "local"
387
 
          // argument, but this is consistent with the EC_Multiple
388
 
          // test and also allows for a runtime scheduling service.
389
 
 
390
 
          if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_LIB_TEXT("global")) == 0)
391
 
            {
392
 
              this->scheduler_type_ = ES_SCHED_GLOBAL;
393
 
            }
394
 
          else if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_LIB_TEXT("local")) == 0)
395
 
            {
396
 
              this->scheduler_type_ = ES_SCHED_LOCAL;
397
 
            }
398
 
          else if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_LIB_TEXT("none")) == 0)
399
 
            {
400
 
              this->scheduler_type_ = ES_SCHED_NONE;
401
 
            }
402
 
          else
403
 
            {
404
 
              ACE_DEBUG ((LM_DEBUG,
405
 
                          ACE_LIB_TEXT("Unknown scheduling type <%s> ")
406
 
                          ACE_LIB_TEXT("defaulting to none\n"),
407
 
                          get_opt.opt_arg ()));
408
 
              this->scheduler_type_ = ES_SCHED_NONE;
409
 
            }
410
 
          break;
411
 
 
412
 
        case 't':
413
 
          if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_LIB_TEXT("NEW")) == 0)
414
 
            {
415
 
              this->event_service_type_ = ES_NEW;
416
 
            }
417
 
          else if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_LIB_TEXT("OLD_REACTIVE")) == 0)
418
 
            {
419
 
              this->event_service_type_ = ES_OLD_REACTIVE;
420
 
            }
421
 
          else if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_LIB_TEXT("OLD_MT")) == 0)
422
 
            {
423
 
              this->event_service_type_ = ES_OLD_MT;
424
 
            }
425
 
          else
426
 
            {
427
 
              ACE_DEBUG ((LM_DEBUG,
428
 
                          ACE_LIB_TEXT("Unknown event service type <%s> ")
429
 
                          ACE_LIB_TEXT("defaulting to NEW\n"),
430
 
                          get_opt.opt_arg ()));
431
 
              this->event_service_type_ = ES_NEW;
432
 
            }
433
 
          break;
434
 
 
435
 
        case '?':
436
 
        default:
437
 
          ACE_DEBUG ((LM_DEBUG,
438
 
                      ACE_LIB_TEXT("Usage: %s ")
439
 
                      ACE_LIB_TEXT("-n service_name ")
440
 
                      ACE_LIB_TEXT("-o ior_file_name ")
441
 
                      ACE_LIB_TEXT("-p pid_file_name ")
442
 
                      ACE_LIB_TEXT("-s <global|local|none> ")
443
 
                      ACE_LIB_TEXT("-t <new|old_reactive|old_mt> ")
444
 
                      ACE_LIB_TEXT("-q servant_name for persistent IOR ")
445
 
                      ACE_LIB_TEXT("-b use bidir giop ")
446
 
                      ACE_LIB_TEXT("\n"),
447
 
                      argv[0]));
448
 
          return -1;
449
 
        }
450
 
    }
451
 
 
452
 
  return 0;
453
 
}
454
 
 
455
 
 
456
 
RtecEventChannelAdmin::ConsumerAdmin_ptr
457
 
Event_Service::for_consumers (ACE_ENV_SINGLE_ARG_DECL)
458
 
      ACE_THROW_SPEC ((CORBA::SystemException))
459
 
{
460
 
  return this->ec_impl_->for_consumers (ACE_ENV_SINGLE_ARG_PARAMETER);
461
 
}
462
 
 
463
 
RtecEventChannelAdmin::SupplierAdmin_ptr
464
 
Event_Service::for_suppliers (ACE_ENV_SINGLE_ARG_DECL)
465
 
      ACE_THROW_SPEC ((CORBA::SystemException))
466
 
{
467
 
  return this->ec_impl_->for_suppliers (ACE_ENV_SINGLE_ARG_PARAMETER);
468
 
}
469
 
 
470
 
void
471
 
Event_Service::destroy (ACE_ENV_SINGLE_ARG_DECL)
472
 
      ACE_THROW_SPEC ((CORBA::SystemException))
473
 
{
474
 
  this->ec_impl_->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
475
 
  ACE_CHECK;
476
 
  this->orb_->shutdown ();
477
 
}
478
 
 
479
 
RtecEventChannelAdmin::Observer_Handle
480
 
Event_Service::append_observer (RtecEventChannelAdmin::Observer_ptr observer
481
 
                                ACE_ENV_ARG_DECL)
482
 
      ACE_THROW_SPEC ((
483
 
          CORBA::SystemException,
484
 
          RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR,
485
 
          RtecEventChannelAdmin::EventChannel::CANT_APPEND_OBSERVER))
486
 
{
487
 
  return this->ec_impl_->append_observer (observer ACE_ENV_ARG_PARAMETER);
488
 
}
489
 
 
490
 
void
491
 
Event_Service::remove_observer (RtecEventChannelAdmin::Observer_Handle handle
492
 
                                ACE_ENV_ARG_DECL)
493
 
      ACE_THROW_SPEC ((
494
 
          CORBA::SystemException,
495
 
          RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR,
496
 
          RtecEventChannelAdmin::EventChannel::CANT_REMOVE_OBSERVER))
497
 
{
498
 
  this->ec_impl_->remove_observer (handle ACE_ENV_ARG_PARAMETER);
499
 
}
500
 
 
501
 
#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
502
 
template class ACE_Auto_Basic_Ptr<POA_RtecScheduler::Scheduler>;
503
 
template class auto_ptr<POA_RtecScheduler::Scheduler>;
504
 
#elif defined(ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
505
 
#pragma instantiate ACE_Auto_Basic_Ptr<POA_RtecScheduler::Scheduler>
506
 
#pragma instantiate auto_ptr<POA_RtecScheduler::Scheduler>
507
 
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */