src/SMESH_I/SMESH_Filter_i.hxx

   1 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SMESH_Filter_i.hxx
  25 //  Author : Alexey Petrov, OCC
  26 //  Module : SMESH
  27
  28 #ifndef _SMESH_FILTER_I_HXX_
  29 #define _SMESH_FILTER_I_HXX_
  30
  31 #include <SALOMEconfig.h>
  32 #include CORBA_SERVER_HEADER(SMESH_Filter)
  33
  34 #include <LDOM_Document.hxx>
  35 #include <TopoDS_Shape.hxx>
  36
  37 #include "SALOME_GenericObj_i.hh"
  38 #include "SMESH_ControlsDef.hxx"
  39
  40 class SMESHDS_Mesh;
  41
  42 namespace SMESH
  43 {
  44
  45 namespace Controls
  46 {
  47
  48 /*
  49   Class       : BelongToGeom
  50   Description : Predicate for verifying whether entiy belong to
  51                 specified geometrical support
  52 */
  53 class BelongToGeom: public virtual Predicate
  54 {
  55 public:
  56                                   BelongToGeom();
  57
  58   virtual void                    SetMesh( SMDS_Mesh* theMesh );
  59   virtual void                    SetGeom( const TopoDS_Shape& theShape );
  60
  61   virtual bool                    IsSatisfy( long theElementId );
  62
  63   virtual void                    SetType( SMDSAbs_ElementType theType );
  64   virtual                         SMDSAbs_ElementType GetType() const;
  65
  66   TopoDS_Shape                    GetShape();
  67   SMESHDS_Mesh*                   GetMeshDS();
  68
  69 private:
  70   TopoDS_Shape                    myShape;
  71   SMESHDS_Mesh*                   myMeshDS;
  72   SMDSAbs_ElementType             myType;
  73 };
  74 typedef boost::shared_ptr<BelongToGeom> BelongToGeomPtr;
  75
  76 /*
  77   Class       : LyingOnGeom
  78   Description : Predicate for verifying whether entiy lying or partially lying on
  79                 specified geometrical support
  80 */
  81 class LyingOnGeom: public virtual Predicate
  82 {
  83 public:
  84                                   LyingOnGeom();
  85
  86   virtual void                    SetMesh( SMDS_Mesh* theMesh );
  87   virtual void                    SetGeom( const TopoDS_Shape& theShape );
  88
  89   virtual bool                    IsSatisfy( long theElementId );
  90
  91   virtual void                    SetType( SMDSAbs_ElementType theType );
  92   virtual                         SMDSAbs_ElementType GetType() const;
  93
  94   TopoDS_Shape                    GetShape();
  95   SMESHDS_Mesh*                   GetMeshDS();
  96
  97   virtual bool                    Contains( SMESHDS_Mesh*           theMeshDS,
  98                                             const TopoDS_Shape&     theShape,
  99                                             const SMDS_MeshElement* theElem,
 100                                             TopAbs_ShapeEnum        theFindShapeEnum,
 101                                             TopAbs_ShapeEnum        theAvoidShapeEnum = TopAbs_SHAPE );
 102 private:
 103   TopoDS_Shape                    myShape;
 104   SMESHDS_Mesh*                   myMeshDS;
 105   SMDSAbs_ElementType             myType;
 106 };
 107 typedef boost::shared_ptr<LyingOnGeom> LyingOnGeomPtr;
 108 }
 109
 110 /*
 111                                 FUNCTORS
 112 */
 113
 114 /*
 115   Class       : Functor_i
 116   Description : An abstact class for all functors
 117 */
 118 class Functor_i: public virtual POA_SMESH::Functor,
 119                  public virtual SALOME::GenericObj_i
 120 {
 121 public:
 122   void                            SetMesh( SMESH_Mesh_ptr theMesh );
 123   Controls::FunctorPtr            GetFunctor(){ return myFunctorPtr;}
 124   ElementType                     GetElementType();
 125
 126 protected:
 127                                   Functor_i();
 128 protected:
 129   Controls::FunctorPtr            myFunctorPtr;
 130 };
 131
 132
 133 /*
 134   Class       : NumericalFunctor_i
 135   Description : Base class for numerical functors
 136 */
 137 class NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,
 138                           public virtual Functor_i
 139 {
 140 public:
 141   CORBA::Double                   GetValue( CORBA::Long theElementId );
 142   void                            SetPrecision( CORBA::Long thePrecision );
 143   CORBA::Long                     GetPrecision();
 144   Controls::NumericalFunctorPtr   GetNumericalFunctor();
 145
 146 protected:
 147   Controls::NumericalFunctorPtr   myNumericalFunctorPtr;
 148 };
 149
 150
 151 /*
 152   Class       : SMESH_MinimumAngleFunct
 153   Description : Functor for calculation of minimum angle
 154 */
 155 class MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,
 156                       public virtual NumericalFunctor_i
 157 {
 158 public:
 159                                   MinimumAngle_i();
 160   FunctorType                     GetFunctorType();
 161 };
 162
 163
 164 /*
 165   Class       : AspectRatio_i
 166   Description : Functor for calculating aspect ratio
 167 */
 168 class AspectRatio_i: public virtual POA_SMESH::AspectRatio,
 169                      public virtual NumericalFunctor_i
 170 {
 171 public:
 172                                   AspectRatio_i();
 173   FunctorType                     GetFunctorType();
 174 };
 175
 176
 177 /*
 178   Class       : AspectRatio3D_i
 179   Description : Functor for calculating aspect ratio for 3D
 180 */
 181 class AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D,
 182                        public virtual NumericalFunctor_i
 183 {
 184 public:
 185                                   AspectRatio3D_i();
 186   FunctorType                     GetFunctorType();
 187 };
 188
 189
 190 /*
 191   Class       : Warping_i
 192   Description : Functor for calculating warping
 193 */
 194 class Warping_i: public virtual POA_SMESH::Warping,
 195                  public virtual NumericalFunctor_i
 196 {
 197 public:
 198                                   Warping_i();
 199   FunctorType                     GetFunctorType();
 200 };
 201
 202
 203 /*
 204   Class       : Taper_i
 205   Description : Functor for calculating taper
 206 */
 207 class Taper_i: public virtual POA_SMESH::Taper,
 208                public virtual NumericalFunctor_i
 209 {
 210 public:
 211                                   Taper_i();
 212   FunctorType                     GetFunctorType();
 213 };
 214
 215
 216 /*
 217   Class       : Skew_i
 218   Description : Functor for calculating skew in degrees
 219 */
 220 class Skew_i: public virtual POA_SMESH::Skew,
 221               public virtual NumericalFunctor_i
 222 {
 223 public:
 224                                   Skew_i();
 225   FunctorType                     GetFunctorType();
 226 };
 227
 228
 229 /*
 230   Class       : Area_i
 231   Description : Functor for calculating area
 232 */
 233 class Area_i: public virtual POA_SMESH::Area,
 234               public virtual NumericalFunctor_i
 235 {
 236 public:
 237                                   Area_i();
 238   FunctorType                     GetFunctorType();
 239 };
 240
 241
 242 /*
 243   Class       : Length_i
 244   Description : Functor for calculating length of edge
 245 */
 246 class Length_i: public virtual POA_SMESH::Length,
 247                 public virtual NumericalFunctor_i
 248 {
 249 public:
 250                                   Length_i();
 251   FunctorType                     GetFunctorType();
 252 };
 253
 254 /*
 255   Class       : Length2D_i
 256   Description : Functor for calculating length of edge
 257 */
 258 class Length2D_i: public virtual POA_SMESH::Length2D,
 259                   public virtual NumericalFunctor_i
 260 {
 261 public:
 262                                   Length2D_i();
 263   SMESH::Length2D::Values*        GetValues();
 264   FunctorType                     GetFunctorType();
 265
 266 protected:
 267   Controls::Length2DPtr          myLength2DPtr;
 268 };
 269
 270
 271 /*
 272   Class       : MultiConnection_i
 273   Description : Functor for calculating number of faces conneted to the edge
 274 */
 275 class MultiConnection_i: public virtual POA_SMESH::MultiConnection,
 276                          public virtual NumericalFunctor_i
 277 {
 278 public:
 279                                   MultiConnection_i();
 280   FunctorType                     GetFunctorType();
 281 };
 282
 283 /*
 284   Class       : MultiConnection2D_i
 285   Description : Functor for calculating number of faces conneted to the edge
 286 */
 287 class MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
 288                            public virtual NumericalFunctor_i
 289 {
 290 public:
 291                                      MultiConnection2D_i();
 292   SMESH::MultiConnection2D::Values*  GetValues();
 293   FunctorType                        GetFunctorType();
 294
 295 protected:
 296   Controls::MultiConnection2DPtr     myMulticonnection2DPtr;
 297 };
 298
 299
 300 /*
 301                             PREDICATES
 302 */
 303 /*
 304   Class       : Predicate_i
 305   Description : Base class for all predicates
 306 */
 307 class Predicate_i: public virtual POA_SMESH::Predicate,
 308                    public virtual Functor_i
 309 {
 310 public:
 311   CORBA::Boolean                  IsSatisfy( CORBA::Long theElementId );
 312   Controls::PredicatePtr          GetPredicate();
 313
 314 protected:
 315   Controls::PredicatePtr          myPredicatePtr;
 316 };
 317
 318
 319 /*
 320   Class       : BadOrientedVolume_i
 321   Description : Verify whether a mesh volume is incorrectly oriented from
 322                 the point of view of MED convention
 323 */
 324 class BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
 325                            public virtual Predicate_i
 326 {
 327  public:
 328   BadOrientedVolume_i();
 329   FunctorType                     GetFunctorType();
 330 };
 331
 332 /*
 333   Class       : BelongToGeom_i
 334   Description : Predicate for selection on geometrical support
 335 */
 336 class BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
 337                       public virtual Predicate_i
 338 {
 339 public:
 340                                   BelongToGeom_i();
 341   virtual                         ~BelongToGeom_i();
 342
 343   void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 344   void                            SetElementType( ElementType theType );
 345   FunctorType                     GetFunctorType();
 346
 347   void                            SetGeom( const TopoDS_Shape& theShape );
 348
 349   void                            SetShapeName( const char* theName );
 350   char*                           GetShapeName();
 351
 352 protected:
 353   Controls::BelongToGeomPtr       myBelongToGeomPtr;
 354   char*                           myShapeName;
 355 };
 356
 357 /*
 358   Class       : BelongToSurface_i
 359   Description : Verify whether mesh element lie in pointed Geom planar object
 360 */
 361 class BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
 362                          public virtual Predicate_i
 363 {
 364 public:
 365                                   BelongToSurface_i( const Handle(Standard_Type)& );
 366   virtual                         ~BelongToSurface_i();
 367
 368   void                            SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 369
 370   void                            SetShapeName( const char* theName, ElementType theType );
 371   char*                           GetShapeName();
 372
 373   void                            SetTolerance( CORBA::Double );
 374   CORBA::Double                   GetTolerance();
 375
 376 protected:
 377   Controls::ElementsOnSurfacePtr  myElementsOnSurfacePtr;
 378   char*                           myShapeName;
 379   Handle(Standard_Type)           mySurfaceType;
 380 };
 381
 382 /*
 383   Class       : BelongToPlane_i
 384   Description : Verify whether mesh element lie in pointed Geom planar object
 385 */
 386 class BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
 387                        public virtual BelongToSurface_i
 388 {
 389 public:
 390                                   BelongToPlane_i();
 391   void                            SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 392   FunctorType                     GetFunctorType();
 393 };
 394
 395 /*
 396   Class       : BelongToCylinder_i
 397   Description : Verify whether mesh element lie in pointed Geom cylindrical object
 398 */
 399 class BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
 400                           public virtual BelongToSurface_i
 401 {
 402 public:
 403                                   BelongToCylinder_i();
 404   void                            SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 405   FunctorType                     GetFunctorType();
 406 };
 407
 408 /*
 409   Class       : LyingOnGeom_i
 410   Description : Predicate for selection on geometrical support(lying or partially lying)
 411 */
 412 class LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
 413                      public virtual Predicate_i
 414 {
 415 public:
 416                                   LyingOnGeom_i();
 417   virtual                         ~LyingOnGeom_i();
 418
 419   void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 420   void                            SetElementType( ElementType theType );
 421   FunctorType                     GetFunctorType();
 422
 423   void                            SetGeom( const TopoDS_Shape& theShape );
 424
 425   void                            SetShapeName( const char* theName );
 426   char*                           GetShapeName();
 427
 428 protected:
 429   Controls::LyingOnGeomPtr        myLyingOnGeomPtr;
 430   char*                           myShapeName;
 431 };
 432
 433 /*
 434   Class       : FreeBorders_i
 435   Description : Predicate for free borders
 436 */
 437 class FreeBorders_i: public virtual POA_SMESH::FreeBorders,
 438                      public virtual Predicate_i
 439 {
 440 public:
 441                                   FreeBorders_i();
 442   FunctorType                     GetFunctorType();
 443 };
 444
 445
 446 /*
 447   Class       : FreeEdges_i
 448   Description : Predicate for free edges
 449 */
 450 class FreeEdges_i: public virtual POA_SMESH::FreeEdges,
 451                    public virtual Predicate_i
 452 {
 453 public:
 454                                   FreeEdges_i();
 455   SMESH::FreeEdges::Borders*      GetBorders();
 456   FunctorType                     GetFunctorType();
 457
 458 protected:
 459   Controls::FreeEdgesPtr          myFreeEdgesPtr;
 460 };
 461
 462
 463 /*
 464   Class       : RangeOfIds_i
 465   Description : Predicate for Range of Ids
 466 */
 467 class RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
 468                     public virtual Predicate_i
 469 {
 470 public:
 471                                   RangeOfIds_i();
 472   void                            SetRange( const SMESH::long_array& theIds );
 473   CORBA::Boolean                  SetRangeStr( const char* theRange );
 474   char*                           GetRangeStr();
 475
 476   void                            SetElementType( ElementType theType );
 477   FunctorType                     GetFunctorType();
 478
 479 protected:
 480   Controls::RangeOfIdsPtr         myRangeOfIdsPtr;
 481 };
 482
 483 /*
 484   Class       : Comparator_i
 485   Description : Base class for comparators
 486 */
 487 class Comparator_i: public virtual POA_SMESH::Comparator,
 488                     public virtual Predicate_i
 489 {
 490 public:
 491   virtual                         ~Comparator_i();
 492
 493   virtual void                    SetMargin( CORBA::Double );
 494   virtual void                    SetNumFunctor( NumericalFunctor_ptr );
 495
 496   Controls::ComparatorPtr         GetComparator();
 497   NumericalFunctor_i*             GetNumFunctor_i();
 498   CORBA::Double                   GetMargin();
 499
 500 protected:
 501                                   Comparator_i();
 502 protected:
 503   Controls::ComparatorPtr         myComparatorPtr;
 504   NumericalFunctor_i*             myNumericalFunctor;
 505 };
 506
 507
 508 /*
 509   Class       : LessThan_i
 510   Description : Comparator "<"
 511 */
 512 class LessThan_i: public virtual POA_SMESH::LessThan,
 513                   public virtual Comparator_i
 514 {
 515 public:
 516                                   LessThan_i();
 517   FunctorType                     GetFunctorType();
 518 };
 519
 520
 521 /*
 522   Class       : MoreThan_i
 523   Description : Comparator ">"
 524 */
 525 class MoreThan_i: public virtual POA_SMESH::MoreThan,
 526                   public virtual Comparator_i
 527 {
 528 public:
 529                                   MoreThan_i();
 530   FunctorType                     GetFunctorType();
 531 };
 532
 533
 534 /*
 535   Class       : EqualTo_i
 536   Description : Comparator "="
 537 */
 538 class EqualTo_i: public virtual POA_SMESH::EqualTo,
 539                  public virtual Comparator_i
 540 {
 541 public:
 542                                   EqualTo_i();
 543   virtual void                    SetTolerance( CORBA::Double );
 544   CORBA::Double                   GetTolerance();
 545   FunctorType                     GetFunctorType();
 546
 547 protected:
 548   Controls::EqualToPtr            myEqualToPtr;
 549 };
 550
 551
 552 /*
 553   Class       : LogicalNOT_i
 554   Description : Logical NOT predicate
 555 */
 556 class LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
 557                     public virtual Predicate_i
 558 {
 559 public:
 560                                   LogicalNOT_i();
 561   virtual                         ~LogicalNOT_i();
 562
 563   virtual void                    SetPredicate( Predicate_ptr );
 564   Predicate_i*                    GetPredicate_i();
 565   FunctorType                     GetFunctorType();
 566
 567 protected:
 568   Controls::LogicalNOTPtr         myLogicalNOTPtr;
 569   Predicate_i*                    myPredicate;
 570 };
 571
 572
 573 /*
 574   Class       : LogicalBinary_i
 575   Description : Base class for binary logical predicate
 576 */
 577 class LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
 578                        public virtual Predicate_i
 579 {
 580 public:
 581   virtual                         ~LogicalBinary_i();
 582   virtual void                    SetMesh( SMESH_Mesh_ptr theMesh );
 583   virtual void                    SetPredicate1( Predicate_ptr );
 584   virtual void                    SetPredicate2( Predicate_ptr );
 585
 586   Controls::LogicalBinaryPtr      GetLogicalBinary();
 587   Predicate_i*                    GetPredicate1_i();
 588   Predicate_i*                    GetPredicate2_i();
 589
 590 protected:
 591                                   LogicalBinary_i();
 592 protected:
 593   Controls::LogicalBinaryPtr      myLogicalBinaryPtr;
 594   Predicate_i*                    myPredicate1;
 595   Predicate_i*                    myPredicate2;
 596 };
 597
 598
 599 /*
 600   Class       : LogicalAND_i
 601   Description : Logical AND
 602 */
 603 class LogicalAND_i: public virtual POA_SMESH::LogicalAND,
 604                     public virtual LogicalBinary_i
 605 {
 606 public:
 607                                   LogicalAND_i();
 608   FunctorType                     GetFunctorType();
 609 };
 610
 611
 612 /*
 613   Class       : LogicalOR_i
 614   Description : Logical OR
 615 */
 616 class LogicalOR_i: public virtual POA_SMESH::LogicalOR,
 617                    public virtual LogicalBinary_i
 618 {
 619 public:
 620                                   LogicalOR_i();
 621   FunctorType                     GetFunctorType();
 622 };
 623
 624
 625 /*
 626                                FILTER
 627 */
 628 class Filter_i: public virtual POA_SMESH::Filter,
 629                 public virtual SALOME::GenericObj_i
 630 {
 631 public:
 632                                   Filter_i();
 633   virtual                         ~Filter_i();
 634
 635   void                            SetPredicate( Predicate_ptr );
 636   void                            SetMesh( SMESH_Mesh_ptr );
 637
 638   long_array*                     GetElementsId( SMESH_Mesh_ptr );
 639   ElementType                     GetElementType();
 640
 641   CORBA::Boolean                  GetCriteria( SMESH::Filter::Criteria_out theCriteria );
 642   CORBA::Boolean                  SetCriteria( const SMESH::Filter::Criteria& theCriteria );
 643
 644   Predicate_ptr                   GetPredicate();
 645   Predicate_i*                    GetPredicate_i();
 646
 647 private:
 648   Controls::Filter                myFilter;
 649   Predicate_i*                    myPredicate;
 650 };
 651
 652
 653 /*
 654                             FILTER LIBRARY
 655 */
 656 class FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
 657                        public virtual SALOME::GenericObj_i
 658 {
 659 public:
 660                           FilterLibrary_i( const char* theFileName );
 661                           FilterLibrary_i();
 662                           ~FilterLibrary_i();
 663
 664   Filter_ptr              Copy( const char* theFilterName );
 665
 666   CORBA::Boolean          Add     ( const char* theFilterName, Filter_ptr theFilter );
 667   CORBA::Boolean          AddEmpty( const char* theFilterName, ElementType theType );
 668   CORBA::Boolean          Delete  ( const char* theFilterName );
 669   CORBA::Boolean          Replace ( const char* theFilterName,
 670                                     const char* theNewName,
 671                                     Filter_ptr  theFilter );
 672
 673   CORBA::Boolean          Save();
 674   CORBA::Boolean          SaveAs( const char* aFileName );
 675
 676   CORBA::Boolean          IsPresent( const char* aFilterName );
 677   CORBA::Long             NbFilters( ElementType );
 678   string_array*           GetNames( ElementType );
 679   string_array*           GetAllNames();
 680   void                    SetFileName( const char* theFileName );
 681   char*                   GetFileName();
 682
 683 private:
 684   char*                   myFileName;
 685   LDOM_Document           myDoc;
 686   FilterManager_var       myFilterMgr;
 687 };
 688
 689
 690 /*
 691                             FILTER MANAGER
 692 */
 693
 694 class FilterManager_i: public virtual POA_SMESH::FilterManager,
 695                        public virtual SALOME::GenericObj_i
 696 {
 697 public:
 698                             FilterManager_i();
 699   MinimumAngle_ptr          CreateMinimumAngle();
 700   AspectRatio_ptr           CreateAspectRatio();
 701   AspectRatio3D_ptr         CreateAspectRatio3D();
 702   Warping_ptr               CreateWarping();
 703   Taper_ptr                 CreateTaper();
 704   Skew_ptr                  CreateSkew();
 705   Area_ptr                  CreateArea();
 706   Length_ptr                CreateLength();
 707   Length2D_ptr              CreateLength2D();
 708   MultiConnection_ptr       CreateMultiConnection();
 709   MultiConnection2D_ptr     CreateMultiConnection2D();
 710
 711   BelongToGeom_ptr          CreateBelongToGeom();
 712   BelongToPlane_ptr         CreateBelongToPlane();
 713   BelongToCylinder_ptr      CreateBelongToCylinder();
 714
 715   LyingOnGeom_ptr           CreateLyingOnGeom();
 716
 717   FreeBorders_ptr           CreateFreeBorders();
 718   FreeEdges_ptr             CreateFreeEdges();
 719
 720   RangeOfIds_ptr            CreateRangeOfIds();
 721
 722   BadOrientedVolume_ptr     CreateBadOrientedVolume();
 723
 724   LessThan_ptr              CreateLessThan();
 725   MoreThan_ptr              CreateMoreThan();
 726   EqualTo_ptr               CreateEqualTo();
 727
 728   LogicalNOT_ptr            CreateLogicalNOT();
 729   LogicalAND_ptr            CreateLogicalAND();
 730   LogicalOR_ptr             CreateLogicalOR();
 731
 732   Filter_ptr                CreateFilter();
 733
 734   FilterLibrary_ptr         LoadLibrary( const char* aFileName );
 735   FilterLibrary_ptr         CreateLibrary();
 736   CORBA::Boolean            DeleteLibrary( const char* aFileName );
 737 };
 738
 739
 740
 741 };
 742
 743
 744 #endif