I386LINUX/util/I386LINUX/include/coss/CosTime.h

   1 /*
   2  *  MICO --- an Open Source CORBA implementation
   3  *  Copyright (c) 1997-2003 by The Mico Team
   4  *
   5  *  This file was automatically generated. DO NOT EDIT!
   6  */
   7
   8 #include <CORBA.h>
   9 #include <mico/throw.h>
  10
  11 #ifndef __COSTIME_H__
  12 #define __COSTIME_H__
  13
  14
  15
  16
  17
  18
  19 namespace CosTime
  20 {
  21
  22 class UTO;
  23 typedef UTO *UTO_ptr;
  24 typedef UTO_ptr UTORef;
  25 typedef ObjVar< UTO > UTO_var;
  26 typedef ObjOut< UTO > UTO_out;
  27
  28 class TIO;
  29 typedef TIO *TIO_ptr;
  30 typedef TIO_ptr TIORef;
  31 typedef ObjVar< TIO > TIO_var;
  32 typedef ObjOut< TIO > TIO_out;
  33
  34 class TimeService;
  35 typedef TimeService *TimeService_ptr;
  36 typedef TimeService_ptr TimeServiceRef;
  37 typedef ObjVar< TimeService > TimeService_var;
  38 typedef ObjOut< TimeService > TimeService_out;
  39
  40 }
  41
  42
  43
  44 #include <mico/timebase.h>
  45
  46
  47
  48 namespace CosTime
  49 {
  50
  51 enum TimeComparison {
  52   TCEqualTo = 0,
  53   TCLessThan,
  54   TCGreaterThan,
  55   TCIndeterminate
  56 };
  57
  58 typedef TimeComparison& TimeComparison_out;
  59
  60 enum ComparisonType {
  61   IntervalC = 0,
  62   MidC
  63 };
  64
  65 typedef ComparisonType& ComparisonType_out;
  66
  67 enum OverlapType {
  68   OTContainer = 0,
  69   OTContained,
  70   OTOverlap,
  71   OTNoOverlap
  72 };
  73
  74 typedef OverlapType& OverlapType_out;
  75
  76 struct TimeUnavailable : public CORBA::UserException {
  77   #ifdef HAVE_EXPLICIT_STRUCT_OPS
  78   TimeUnavailable();
  79   ~TimeUnavailable();
  80   TimeUnavailable( const TimeUnavailable& s );
  81   TimeUnavailable& operator=( const TimeUnavailable& s );
  82   #endif //HAVE_EXPLICIT_STRUCT_OPS
  83
  84
  85   #ifdef HAVE_STD_EH
  86   TimeUnavailable *operator->() { return this; }
  87   TimeUnavailable& operator*() { return *this; }
  88   operator TimeUnavailable*() { return this; }
  89   #endif // HAVE_STD_EH
  90
  91   void _throwit() const;
  92   const char *_repoid() const;
  93   void _encode( CORBA::DataEncoder &en ) const;
  94   void _encode_any( CORBA::Any &a ) const;
  95   CORBA::Exception *_clone() const;
  96   static TimeUnavailable *_downcast( CORBA::Exception *ex );
  97   static const TimeUnavailable *_downcast( const CORBA::Exception *ex );
  98 };
  99
 100 #ifdef HAVE_STD_EH
 101 typedef TimeUnavailable TimeUnavailable_catch;
 102 #else
 103 typedef ExceptVar< TimeUnavailable > TimeUnavailable_var;
 104 typedef TVarOut< TimeUnavailable > TimeUnavailable_out;
 105 typedef TimeUnavailable_var TimeUnavailable_catch;
 106 #endif // HAVE_STD_EH
 107
 108
 109 /*
 110  * Base class and common definitions for interface UTO
 111  */
 112
 113 class UTO :
 114   virtual public CORBA::Object
 115 {
 116   public:
 117     virtual ~UTO();
 118
 119     #ifdef HAVE_TYPEDEF_OVERLOAD
 120     typedef UTO_ptr _ptr_type;
 121     typedef UTO_var _var_type;
 122     #endif
 123
 124     static UTO_ptr _narrow( CORBA::Object_ptr obj );
 125     static UTO_ptr _narrow( CORBA::AbstractBase_ptr obj );
 126     static UTO_ptr _duplicate( UTO_ptr _obj )
 127     {
 128       CORBA::Object::_duplicate (_obj);
 129       return _obj;
 130     }
 131
 132     static UTO_ptr _nil()
 133     {
 134       return 0;
 135     }
 136
 137     virtual void *_narrow_helper( const char *repoid );
 138
 139     virtual ::TimeBase::TimeT time() = 0;
 140     virtual ::TimeBase::InaccuracyT inaccuracy() = 0;
 141     virtual ::TimeBase::TdfT tdf() = 0;
 142     virtual ::TimeBase::UtcT utc_time() = 0;
 143
 144     virtual UTO_ptr absolute_time() = 0;
 145     virtual TimeComparison compare_time( ComparisonType comparison_type, UTO_ptr uto ) = 0;
 146     virtual TIO_ptr time_to_interval( UTO_ptr uto ) = 0;
 147     virtual TIO_ptr interval() = 0;
 148     virtual void destroy() = 0;
 149
 150   protected:
 151     UTO() {};
 152   private:
 153     UTO( const UTO& );
 154     void operator=( const UTO& );
 155 };
 156
 157 // Stub for interface UTO
 158 class UTO_stub:
 159   virtual public UTO
 160 {
 161   public:
 162     virtual ~UTO_stub();
 163     ::TimeBase::TimeT time();
 164     ::TimeBase::InaccuracyT inaccuracy();
 165     ::TimeBase::TdfT tdf();
 166     ::TimeBase::UtcT utc_time();
 167
 168     UTO_ptr absolute_time();
 169     TimeComparison compare_time( ComparisonType comparison_type, UTO_ptr uto );
 170     TIO_ptr time_to_interval( UTO_ptr uto );
 171     TIO_ptr interval();
 172     void destroy();
 173
 174   private:
 175     void operator=( const UTO_stub& );
 176 };
 177
 178 #ifndef MICO_CONF_NO_POA
 179
 180 class UTO_stub_clp :
 181   virtual public UTO_stub,
 182   virtual public PortableServer::StubBase
 183 {
 184   public:
 185     UTO_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 186     virtual ~UTO_stub_clp ();
 187     ::TimeBase::TimeT time();
 188     ::TimeBase::InaccuracyT inaccuracy();
 189     ::TimeBase::TdfT tdf();
 190     ::TimeBase::UtcT utc_time();
 191
 192     UTO_ptr absolute_time();
 193     TimeComparison compare_time( ComparisonType comparison_type, UTO_ptr uto );
 194     TIO_ptr time_to_interval( UTO_ptr uto );
 195     TIO_ptr interval();
 196     void destroy();
 197
 198   protected:
 199     UTO_stub_clp ();
 200   private:
 201     void operator=( const UTO_stub_clp & );
 202 };
 203
 204 #endif // MICO_CONF_NO_POA
 205
 206
 207 /*
 208  * Base class and common definitions for interface TIO
 209  */
 210
 211 class TIO :
 212   virtual public CORBA::Object
 213 {
 214   public:
 215     virtual ~TIO();
 216
 217     #ifdef HAVE_TYPEDEF_OVERLOAD
 218     typedef TIO_ptr _ptr_type;
 219     typedef TIO_var _var_type;
 220     #endif
 221
 222     static TIO_ptr _narrow( CORBA::Object_ptr obj );
 223     static TIO_ptr _narrow( CORBA::AbstractBase_ptr obj );
 224     static TIO_ptr _duplicate( TIO_ptr _obj )
 225     {
 226       CORBA::Object::_duplicate (_obj);
 227       return _obj;
 228     }
 229
 230     static TIO_ptr _nil()
 231     {
 232       return 0;
 233     }
 234
 235     virtual void *_narrow_helper( const char *repoid );
 236
 237     virtual ::TimeBase::IntervalT time_interval() = 0;
 238
 239     virtual OverlapType spans( UTO_ptr time, TIO_out overlap ) = 0;
 240     virtual OverlapType overlaps( TIO_ptr interval, TIO_out overlap ) = 0;
 241     virtual UTO_ptr time() = 0;
 242     virtual void destroy() = 0;
 243
 244   protected:
 245     TIO() {};
 246   private:
 247     TIO( const TIO& );
 248     void operator=( const TIO& );
 249 };
 250
 251 // Stub for interface TIO
 252 class TIO_stub:
 253   virtual public TIO
 254 {
 255   public:
 256     virtual ~TIO_stub();
 257     ::TimeBase::IntervalT time_interval();
 258
 259     OverlapType spans( UTO_ptr time, TIO_out overlap );
 260     OverlapType overlaps( TIO_ptr interval, TIO_out overlap );
 261     UTO_ptr time();
 262     void destroy();
 263
 264   private:
 265     void operator=( const TIO_stub& );
 266 };
 267
 268 #ifndef MICO_CONF_NO_POA
 269
 270 class TIO_stub_clp :
 271   virtual public TIO_stub,
 272   virtual public PortableServer::StubBase
 273 {
 274   public:
 275     TIO_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 276     virtual ~TIO_stub_clp ();
 277     ::TimeBase::IntervalT time_interval();
 278
 279     OverlapType spans( UTO_ptr time, TIO_out overlap );
 280     OverlapType overlaps( TIO_ptr interval, TIO_out overlap );
 281     UTO_ptr time();
 282     void destroy();
 283
 284   protected:
 285     TIO_stub_clp ();
 286   private:
 287     void operator=( const TIO_stub_clp & );
 288 };
 289
 290 #endif // MICO_CONF_NO_POA
 291
 292
 293 /*
 294  * Base class and common definitions for interface TimeService
 295  */
 296
 297 class TimeService :
 298   virtual public CORBA::Object
 299 {
 300   public:
 301     virtual ~TimeService();
 302
 303     #ifdef HAVE_TYPEDEF_OVERLOAD
 304     typedef TimeService_ptr _ptr_type;
 305     typedef TimeService_var _var_type;
 306     #endif
 307
 308     static TimeService_ptr _narrow( CORBA::Object_ptr obj );
 309     static TimeService_ptr _narrow( CORBA::AbstractBase_ptr obj );
 310     static TimeService_ptr _duplicate( TimeService_ptr _obj )
 311     {
 312       CORBA::Object::_duplicate (_obj);
 313       return _obj;
 314     }
 315
 316     static TimeService_ptr _nil()
 317     {
 318       return 0;
 319     }
 320
 321     virtual void *_narrow_helper( const char *repoid );
 322
 323     virtual UTO_ptr universal_time() = 0;
 324     virtual UTO_ptr secure_universal_time() = 0;
 325     virtual UTO_ptr new_universal_time( ::TimeBase::TimeT time, ::TimeBase::InaccuracyT inaccuracy, ::TimeBase::TdfT tdf ) = 0;
 326     virtual UTO_ptr uto_from_utc( const ::TimeBase::UtcT& utc ) = 0;
 327     virtual TIO_ptr new_interval( ::TimeBase::TimeT lower, ::TimeBase::TimeT upper ) = 0;
 328
 329   protected:
 330     TimeService() {};
 331   private:
 332     TimeService( const TimeService& );
 333     void operator=( const TimeService& );
 334 };
 335
 336 // Stub for interface TimeService
 337 class TimeService_stub:
 338   virtual public TimeService
 339 {
 340   public:
 341     virtual ~TimeService_stub();
 342     UTO_ptr universal_time();
 343     UTO_ptr secure_universal_time();
 344     UTO_ptr new_universal_time( ::TimeBase::TimeT time, ::TimeBase::InaccuracyT inaccuracy, ::TimeBase::TdfT tdf );
 345     UTO_ptr uto_from_utc( const ::TimeBase::UtcT& utc );
 346     TIO_ptr new_interval( ::TimeBase::TimeT lower, ::TimeBase::TimeT upper );
 347
 348   private:
 349     void operator=( const TimeService_stub& );
 350 };
 351
 352 #ifndef MICO_CONF_NO_POA
 353
 354 class TimeService_stub_clp :
 355   virtual public TimeService_stub,
 356   virtual public PortableServer::StubBase
 357 {
 358   public:
 359     TimeService_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 360     virtual ~TimeService_stub_clp ();
 361     UTO_ptr universal_time();
 362     UTO_ptr secure_universal_time();
 363     UTO_ptr new_universal_time( ::TimeBase::TimeT time, ::TimeBase::InaccuracyT inaccuracy, ::TimeBase::TdfT tdf );
 364     UTO_ptr uto_from_utc( const ::TimeBase::UtcT& utc );
 365     TIO_ptr new_interval( ::TimeBase::TimeT lower, ::TimeBase::TimeT upper );
 366
 367   protected:
 368     TimeService_stub_clp ();
 369   private:
 370     void operator=( const TimeService_stub_clp & );
 371 };
 372
 373 #endif // MICO_CONF_NO_POA
 374
 375 }
 376
 377
 378 #ifndef MICO_CONF_NO_POA
 379
 380
 381
 382 namespace POA_CosTime
 383 {
 384
 385 class UTO : virtual public PortableServer::StaticImplementation
 386 {
 387   public:
 388     virtual ~UTO ();
 389     CosTime::UTO_ptr _this ();
 390     bool dispatch (CORBA::StaticServerRequest_ptr);
 391     virtual void invoke (CORBA::StaticServerRequest_ptr);
 392     virtual CORBA::Boolean _is_a (const char *);
 393     virtual CORBA::InterfaceDef_ptr _get_interface ();
 394     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 395
 396     virtual void * _narrow_helper (const char *);
 397     static UTO * _narrow (PortableServer::Servant);
 398     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 399
 400     virtual ::TimeBase::TimeT time() = 0;
 401     virtual ::TimeBase::InaccuracyT inaccuracy() = 0;
 402     virtual ::TimeBase::TdfT tdf() = 0;
 403     virtual ::TimeBase::UtcT utc_time() = 0;
 404
 405     virtual ::CosTime::UTO_ptr absolute_time() = 0;
 406     virtual ::CosTime::TimeComparison compare_time( ::CosTime::ComparisonType comparison_type, ::CosTime::UTO_ptr uto ) = 0;
 407     virtual ::CosTime::TIO_ptr time_to_interval( ::CosTime::UTO_ptr uto ) = 0;
 408     virtual ::CosTime::TIO_ptr interval() = 0;
 409     virtual void destroy() = 0;
 410
 411   protected:
 412     UTO () {};
 413
 414   private:
 415     UTO (const UTO &);
 416     void operator= (const UTO &);
 417 };
 418
 419 class TIO : virtual public PortableServer::StaticImplementation
 420 {
 421   public:
 422     virtual ~TIO ();
 423     CosTime::TIO_ptr _this ();
 424     bool dispatch (CORBA::StaticServerRequest_ptr);
 425     virtual void invoke (CORBA::StaticServerRequest_ptr);
 426     virtual CORBA::Boolean _is_a (const char *);
 427     virtual CORBA::InterfaceDef_ptr _get_interface ();
 428     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 429
 430     virtual void * _narrow_helper (const char *);
 431     static TIO * _narrow (PortableServer::Servant);
 432     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 433
 434     virtual ::TimeBase::IntervalT time_interval() = 0;
 435
 436     virtual ::CosTime::OverlapType spans( ::CosTime::UTO_ptr time, ::CosTime::TIO_out overlap ) = 0;
 437     virtual ::CosTime::OverlapType overlaps( ::CosTime::TIO_ptr interval, ::CosTime::TIO_out overlap ) = 0;
 438     virtual ::CosTime::UTO_ptr time() = 0;
 439     virtual void destroy() = 0;
 440
 441   protected:
 442     TIO () {};
 443
 444   private:
 445     TIO (const TIO &);
 446     void operator= (const TIO &);
 447 };
 448
 449 class TimeService : virtual public PortableServer::StaticImplementation
 450 {
 451   public:
 452     virtual ~TimeService ();
 453     CosTime::TimeService_ptr _this ();
 454     bool dispatch (CORBA::StaticServerRequest_ptr);
 455     virtual void invoke (CORBA::StaticServerRequest_ptr);
 456     virtual CORBA::Boolean _is_a (const char *);
 457     virtual CORBA::InterfaceDef_ptr _get_interface ();
 458     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 459
 460     virtual void * _narrow_helper (const char *);
 461     static TimeService * _narrow (PortableServer::Servant);
 462     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 463
 464     virtual ::CosTime::UTO_ptr universal_time() = 0;
 465     virtual ::CosTime::UTO_ptr secure_universal_time() = 0;
 466     virtual ::CosTime::UTO_ptr new_universal_time( ::TimeBase::TimeT time, ::TimeBase::InaccuracyT inaccuracy, ::TimeBase::TdfT tdf ) = 0;
 467     virtual ::CosTime::UTO_ptr uto_from_utc( const ::TimeBase::UtcT& utc ) = 0;
 468     virtual ::CosTime::TIO_ptr new_interval( ::TimeBase::TimeT lower, ::TimeBase::TimeT upper ) = 0;
 469
 470   protected:
 471     TimeService () {};
 472
 473   private:
 474     TimeService (const TimeService &);
 475     void operator= (const TimeService &);
 476 };
 477
 478 }
 479
 480
 481 #endif // MICO_CONF_NO_POA
 482
 483 extern CORBA::StaticTypeInfo *_marshaller_CosTime_TimeComparison;
 484
 485 extern CORBA::StaticTypeInfo *_marshaller_CosTime_ComparisonType;
 486
 487 extern CORBA::StaticTypeInfo *_marshaller_CosTime_OverlapType;
 488
 489 extern CORBA::StaticTypeInfo *_marshaller_CosTime_TimeUnavailable;
 490
 491 extern CORBA::StaticTypeInfo *_marshaller_CosTime_UTO;
 492
 493 extern CORBA::StaticTypeInfo *_marshaller_CosTime_TIO;
 494
 495 extern CORBA::StaticTypeInfo *_marshaller_CosTime_TimeService;
 496
 497 #endif