00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef ___HxCorbaBSplineCurve_skel_h__
00016 #define ___HxCorbaBSplineCurve_skel_h__
00017
00018 #include <HxCorbaBSplineCurve.h>
00019
00020 #include <HxCorbaPolyline2d_skel.h>
00021
00022 #ifndef OB_INTEGER_VERSION
00023 # error No ORBacus version defined! Is <OB/CORBA.h> included?
00024 #endif
00025
00026 #ifndef OB_NO_VERSION_CHECK
00027 # if (OB_INTEGER_VERSION != 4000500L)
00028 # error ORBacus version mismatch!
00029 # endif
00030 #endif
00031
00032
00033
00034
00035 namespace POA_HxCorba
00036 {
00037
00038
00039
00040
00041 class BSplineCurve : virtual public PortableServer::ServantBase
00042 {
00043 BSplineCurve(const BSplineCurve&);
00044 void operator=(const BSplineCurve&);
00045
00046 protected:
00047
00048
00049
00050
00051 void _OB_op_curveType(OB::Upcall_ptr);
00052
00053
00054
00055
00056 void _OB_op_degree(OB::Upcall_ptr);
00057
00058
00059
00060
00061 void _OB_op_minT(OB::Upcall_ptr);
00062
00063
00064
00065
00066 void _OB_op_maxT(OB::Upcall_ptr);
00067
00068
00069
00070
00071 void _OB_op_C(OB::Upcall_ptr);
00072
00073
00074
00075
00076 void _OB_op_sampleC(OB::Upcall_ptr);
00077
00078
00079
00080
00081 void _OB_op_length(OB::Upcall_ptr);
00082
00083
00084
00085
00086 void _OB_op_controlP(OB::Upcall_ptr);
00087
00088
00089
00090
00091 void _OB_op_center(OB::Upcall_ptr);
00092
00093
00094
00095
00096 void _OB_op_numP(OB::Upcall_ptr);
00097
00098
00099
00100
00101 void _OB_op_P(OB::Upcall_ptr);
00102
00103
00104
00105
00106 void _OB_op_allP(OB::Upcall_ptr);
00107
00108 public:
00109
00110 BSplineCurve() { }
00111
00112 virtual CORBA::Boolean _is_a(const char*)
00113 throw(CORBA::SystemException);
00114
00115 virtual CORBA::RepositoryId _primary_interface(const PortableServer::ObjectId&,
00116 PortableServer::POA_ptr);
00117
00118 HxCorba::BSplineCurve_ptr _this();
00119
00120 virtual OB::DirectStubImpl_ptr _OB_createDirectStubImpl(PortableServer::POA_ptr,
00121 const PortableServer::ObjectId&);
00122 virtual void _OB_dispatch(OB::Upcall_ptr);
00123
00124
00125
00126
00127 virtual HxCorba::BSplineType curveType()
00128 throw(CORBA::SystemException) = 0;
00129
00130
00131
00132
00133 virtual CORBA::Long degree()
00134 throw(CORBA::SystemException) = 0;
00135
00136
00137
00138
00139 virtual CORBA::Double minT()
00140 throw(CORBA::SystemException) = 0;
00141
00142
00143
00144
00145 virtual CORBA::Double maxT()
00146 throw(CORBA::SystemException) = 0;
00147
00148
00149
00150
00151 virtual HxCorba::PointR2 C(CORBA::Double t)
00152 throw(CORBA::SystemException) = 0;
00153
00154
00155
00156
00157 virtual HxCorba::Polyline2d_ptr sampleC(CORBA::Long np)
00158 throw(CORBA::SystemException) = 0;
00159
00160
00161
00162
00163 virtual CORBA::Double length(CORBA::Long np)
00164 throw(CORBA::SystemException) = 0;
00165
00166
00167
00168
00169 virtual HxCorba::Polyline2d_ptr controlP()
00170 throw(CORBA::SystemException) = 0;
00171
00172
00173
00174
00175 virtual HxCorba::PointR2 center()
00176 throw(CORBA::SystemException) = 0;
00177
00178
00179
00180
00181 virtual CORBA::Long numP()
00182 throw(CORBA::SystemException) = 0;
00183
00184
00185
00186
00187 virtual HxCorba::PointR2 P(CORBA::Long i)
00188 throw(CORBA::SystemException) = 0;
00189
00190
00191
00192
00193 virtual HxCorba::PointR2Seq* allP()
00194 throw(CORBA::SystemException) = 0;
00195 };
00196
00197
00198
00199
00200 class SampledBSplineCurve : virtual public PortableServer::ServantBase
00201 {
00202 SampledBSplineCurve(const SampledBSplineCurve&);
00203 void operator=(const SampledBSplineCurve&);
00204
00205 protected:
00206
00207
00208
00209
00210 void _OB_op_continuousCurve(OB::Upcall_ptr);
00211
00212
00213
00214
00215 void _OB_op_nSamples(OB::Upcall_ptr);
00216
00217
00218
00219
00220 void _OB_op_CPoly(OB::Upcall_ptr);
00221
00222
00223
00224
00225 void _OB_op_C(OB::Upcall_ptr);
00226
00227
00228
00229
00230 void _OB_op_allC(OB::Upcall_ptr);
00231
00232
00233
00234
00235 void _OB_op_length(OB::Upcall_ptr);
00236
00237
00238
00239
00240 void _OB_op_controlP(OB::Upcall_ptr);
00241
00242
00243
00244
00245 void _OB_op_numP(OB::Upcall_ptr);
00246
00247
00248
00249
00250 void _OB_op_allP(OB::Upcall_ptr);
00251
00252 public:
00253
00254 SampledBSplineCurve() { }
00255
00256 virtual CORBA::Boolean _is_a(const char*)
00257 throw(CORBA::SystemException);
00258
00259 virtual CORBA::RepositoryId _primary_interface(const PortableServer::ObjectId&,
00260 PortableServer::POA_ptr);
00261
00262 HxCorba::SampledBSplineCurve_ptr _this();
00263
00264 virtual OB::DirectStubImpl_ptr _OB_createDirectStubImpl(PortableServer::POA_ptr,
00265 const PortableServer::ObjectId&);
00266 virtual void _OB_dispatch(OB::Upcall_ptr);
00267
00268
00269
00270
00271 virtual HxCorba::BSplineCurve_ptr continuousCurve()
00272 throw(CORBA::SystemException) = 0;
00273
00274
00275
00276
00277 virtual CORBA::Long nSamples()
00278 throw(CORBA::SystemException) = 0;
00279
00280
00281
00282
00283 virtual HxCorba::Polyline2d_ptr CPoly()
00284 throw(CORBA::SystemException) = 0;
00285
00286
00287
00288
00289 virtual HxCorba::PointR2 C(CORBA::Long i)
00290 throw(CORBA::SystemException) = 0;
00291
00292
00293
00294
00295 virtual HxCorba::PointR2Seq* allC()
00296 throw(CORBA::SystemException) = 0;
00297
00298
00299
00300
00301 virtual CORBA::Double length()
00302 throw(CORBA::SystemException) = 0;
00303
00304
00305
00306
00307 virtual HxCorba::Polyline2d_ptr controlP()
00308 throw(CORBA::SystemException) = 0;
00309
00310
00311
00312
00313 virtual CORBA::Long numP()
00314 throw(CORBA::SystemException) = 0;
00315
00316
00317
00318
00319 virtual HxCorba::PointR2Seq* allP()
00320 throw(CORBA::SystemException) = 0;
00321 };
00322
00323
00324
00325
00326 class BSplineFactory : virtual public PortableServer::ServantBase
00327 {
00328 BSplineFactory(const BSplineFactory&);
00329 void operator=(const BSplineFactory&);
00330
00331 protected:
00332
00333
00334
00335
00336 void _OB_op_makeUniformBSpline(OB::Upcall_ptr);
00337
00338
00339
00340
00341 void _OB_op_makeInterpolatingBSpline(OB::Upcall_ptr);
00342
00343
00344
00345
00346 void _OB_op_makeUniformSampledBSpline(OB::Upcall_ptr);
00347
00348
00349
00350
00351 void _OB_op_makeInterpolatingSampledBSpline(OB::Upcall_ptr);
00352
00353 public:
00354
00355 BSplineFactory() { }
00356
00357 virtual CORBA::Boolean _is_a(const char*)
00358 throw(CORBA::SystemException);
00359
00360 virtual CORBA::RepositoryId _primary_interface(const PortableServer::ObjectId&,
00361 PortableServer::POA_ptr);
00362
00363 HxCorba::BSplineFactory_ptr _this();
00364
00365 virtual OB::DirectStubImpl_ptr _OB_createDirectStubImpl(PortableServer::POA_ptr,
00366 const PortableServer::ObjectId&);
00367 virtual void _OB_dispatch(OB::Upcall_ptr);
00368
00369
00370
00371
00372 virtual HxCorba::BSplineCurve_ptr makeUniformBSpline(HxCorba::Polyline2d_ptr cp,
00373 CORBA::Long degree)
00374 throw(CORBA::SystemException) = 0;
00375
00376
00377
00378
00379 virtual HxCorba::BSplineCurve_ptr makeInterpolatingBSpline(HxCorba::Polyline2d_ptr cp)
00380 throw(CORBA::SystemException) = 0;
00381
00382
00383
00384
00385 virtual HxCorba::SampledBSplineCurve_ptr makeUniformSampledBSpline(HxCorba::Polyline2d_ptr cp,
00386 CORBA::Long degree,
00387 CORBA::Double distance)
00388 throw(CORBA::SystemException) = 0;
00389
00390
00391
00392
00393 virtual HxCorba::SampledBSplineCurve_ptr makeInterpolatingSampledBSpline(HxCorba::Polyline2d_ptr cp,
00394 CORBA::Double distance)
00395 throw(CORBA::SystemException) = 0;
00396 };
00397
00398 }
00399
00400
00401
00402
00403 namespace OBDirectStubImpl_HxCorba
00404 {
00405
00406
00407
00408
00409 class BSplineCurve : virtual public OBStubImpl_HxCorba::BSplineCurve,
00410 virtual public OB::DirectStubImpl
00411 {
00412 BSplineCurve(const BSplineCurve&);
00413 void operator=(const BSplineCurve&);
00414
00415 protected:
00416
00417 #ifdef HAVE_VCPLUSPLUS_BUGS
00418
00419 BSplineCurve() { }
00420
00421 #endif
00422
00423 BSplineCurve(PortableServer::POA_ptr,
00424 const PortableServer::ObjectId&,
00425 PortableServer::ServantBase*);
00426
00427 friend class POA_HxCorba::BSplineCurve;
00428
00429 public:
00430
00431
00432
00433
00434 virtual HxCorba::BSplineType curveType();
00435
00436
00437
00438
00439 virtual CORBA::Long degree();
00440
00441
00442
00443
00444 virtual CORBA::Double minT();
00445
00446
00447
00448
00449 virtual CORBA::Double maxT();
00450
00451
00452
00453
00454 virtual HxCorba::PointR2 C(CORBA::Double t);
00455
00456
00457
00458
00459 virtual HxCorba::Polyline2d_ptr sampleC(CORBA::Long np);
00460
00461
00462
00463
00464 virtual CORBA::Double length(CORBA::Long np);
00465
00466
00467
00468
00469 virtual HxCorba::Polyline2d_ptr controlP();
00470
00471
00472
00473
00474 virtual HxCorba::PointR2 center();
00475
00476
00477
00478
00479 virtual CORBA::Long numP();
00480
00481
00482
00483
00484 virtual HxCorba::PointR2 P(CORBA::Long i);
00485
00486
00487
00488
00489 virtual HxCorba::PointR2Seq* allP();
00490 };
00491
00492
00493
00494
00495 class SampledBSplineCurve : virtual public OBStubImpl_HxCorba::SampledBSplineCurve,
00496 virtual public OB::DirectStubImpl
00497 {
00498 SampledBSplineCurve(const SampledBSplineCurve&);
00499 void operator=(const SampledBSplineCurve&);
00500
00501 protected:
00502
00503 #ifdef HAVE_VCPLUSPLUS_BUGS
00504
00505 SampledBSplineCurve() { }
00506
00507 #endif
00508
00509 SampledBSplineCurve(PortableServer::POA_ptr,
00510 const PortableServer::ObjectId&,
00511 PortableServer::ServantBase*);
00512
00513 friend class POA_HxCorba::SampledBSplineCurve;
00514
00515 public:
00516
00517
00518
00519
00520 virtual HxCorba::BSplineCurve_ptr continuousCurve();
00521
00522
00523
00524
00525 virtual CORBA::Long nSamples();
00526
00527
00528
00529
00530 virtual HxCorba::Polyline2d_ptr CPoly();
00531
00532
00533
00534
00535 virtual HxCorba::PointR2 C(CORBA::Long i);
00536
00537
00538
00539
00540 virtual HxCorba::PointR2Seq* allC();
00541
00542
00543
00544
00545 virtual CORBA::Double length();
00546
00547
00548
00549
00550 virtual HxCorba::Polyline2d_ptr controlP();
00551
00552
00553
00554
00555 virtual CORBA::Long numP();
00556
00557
00558
00559
00560 virtual HxCorba::PointR2Seq* allP();
00561 };
00562
00563
00564
00565
00566 class BSplineFactory : virtual public OBStubImpl_HxCorba::BSplineFactory,
00567 virtual public OB::DirectStubImpl
00568 {
00569 BSplineFactory(const BSplineFactory&);
00570 void operator=(const BSplineFactory&);
00571
00572 protected:
00573
00574 #ifdef HAVE_VCPLUSPLUS_BUGS
00575
00576 BSplineFactory() { }
00577
00578 #endif
00579
00580 BSplineFactory(PortableServer::POA_ptr,
00581 const PortableServer::ObjectId&,
00582 PortableServer::ServantBase*);
00583
00584 friend class POA_HxCorba::BSplineFactory;
00585
00586 public:
00587
00588
00589
00590
00591 virtual HxCorba::BSplineCurve_ptr makeUniformBSpline(HxCorba::Polyline2d_ptr cp,
00592 CORBA::Long degree);
00593
00594
00595
00596
00597 virtual HxCorba::BSplineCurve_ptr makeInterpolatingBSpline(HxCorba::Polyline2d_ptr cp);
00598
00599
00600
00601
00602 virtual HxCorba::SampledBSplineCurve_ptr makeUniformSampledBSpline(HxCorba::Polyline2d_ptr cp,
00603 CORBA::Long degree,
00604 CORBA::Double distance);
00605
00606
00607
00608
00609 virtual HxCorba::SampledBSplineCurve_ptr makeInterpolatingSampledBSpline(HxCorba::Polyline2d_ptr cp,
00610 CORBA::Double distance);
00611 };
00612
00613 }
00614
00615 #endif