src/BOPAlgo/BOPAlgo_Options.hxx

   1 // Created by: Eugeny MALTCHIKOV
   2 // Copyright (c) 2017 OPEN CASCADE SAS
   3 //
   4 // This file is part of Open CASCADE Technology software library.
   5 //
   6 // This library is free software; you can redistribute it and/or modify it under
   7 // the terms of the GNU Lesser General Public License version 2.1 as published
   8 // by the Free Software Foundation, with special exception defined in the file
   9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  10 // distribution for complete text of the license and disclaimer of any warranty.
  11 //
  12 // Alternatively, this file may be used under the terms of Open CASCADE
  13 // commercial license or contractual agreement.
  14
  15 #ifndef _BOPAlgo_Options_HeaderFile
  16 #define _BOPAlgo_Options_HeaderFile
  17
  18 #include <Message_Report.hxx>
  19 #include <Standard_OStream.hxx>
  20
  21 #include <BOPCol_BaseAllocator.hxx>
  22
  23 class Message_ProgressIndicator;
  24
  25 //! The class provides the following options for the algorithms in Boolean Component:
  26 //! - *Memory allocation tool* - tool for memory allocations;
  27 //! - *Error and warning reporting* - allows recording warnings and errors occurred
  28 //!                              during the operation.
  29 //!                              Error means that the algorithm has failed.
  30 //! - *Parallel processing mode* - provides the possibility to perform operation in parallel mode;
  31 //! - *Fuzzy tolerance* - additional tolerance for the operation to detect
  32 //!                       touching or coinciding cases;
  33 //! - *Progress indicator* - provides interface to track the progress of
  34 //!                          operation and stop the operation by user's break.
  35 //!
  36 class BOPAlgo_Options
  37 {
  38 public:
  39
  40   DEFINE_STANDARD_ALLOC
  41
  42   //! Empty constructor
  43   Standard_EXPORT BOPAlgo_Options();
  44
  45   //! Constructor with allocator
  46   Standard_EXPORT BOPAlgo_Options(const BOPCol_BaseAllocator& theAllocator);
  47
  48   //! Destructor
  49   Standard_EXPORT virtual ~BOPAlgo_Options();
  50
  51   //! Returns allocator
  52   const BOPCol_BaseAllocator& Allocator() const
  53   {
  54     return myAllocator;
  55   }
  56
  57   //! Clears all warnings and errors, and any data cached by the algorithm.
  58   //! User defined options are not cleared.
  59   virtual void Clear()
  60   {
  61     myReport->Clear();
  62   }
  63
  64 public:
  65   //!@name Error reporting mechanism
  66
  67   //! Adds the alert as error (fail)
  68   void AddError (const Handle(Message_Alert)& theAlert)
  69   {
  70     myReport->AddAlert (Message_Fail, theAlert);
  71   }
  72
  73   //! Adds the alert as warning
  74   void AddWarning (const Handle(Message_Alert)& theAlert)
  75   {
  76     myReport->AddAlert (Message_Warning, theAlert);
  77   }
  78
  79   //! Returns true if algorithm has failed
  80   Standard_Boolean HasErrors() const
  81   {
  82     return ! myReport->GetAlerts(Message_Fail).IsEmpty();
  83   }
  84
  85   //! Returns true if algorithm has generated error of specified type
  86   Standard_Boolean HasError (const Handle(Standard_Type)& theType) const
  87   {
  88     return myReport->HasAlert(theType, Message_Fail);
  89   }
  90
  91   //! Returns true if algorithm has generated some warning alerts
  92   Standard_Boolean HasWarnings() const
  93   {
  94     return ! myReport->GetAlerts(Message_Warning).IsEmpty();
  95   }
  96
  97   //! Returns true if algorithm has generated warning of specified type
  98   Standard_Boolean HasWarning (const Handle(Standard_Type)& theType) const
  99   {
 100     return myReport->HasAlert(theType, Message_Warning);
 101   }
 102
 103   //! Returns report collecting all errors and warnings
 104   const Handle(Message_Report)& GetReport () const { return myReport; }
 105
 106   //! Dumps the error status into the given stream
 107   Standard_EXPORT void DumpErrors(Standard_OStream& theOS) const;
 108
 109   //! Dumps the warning statuses into the given stream
 110   Standard_EXPORT void DumpWarnings(Standard_OStream& theOS) const;
 111
 112   //! Clears the warnings of the algorithm
 113   void ClearWarnings()
 114   {
 115     myReport->Clear (Message_Warning);
 116   }
 117
 118 public:
 119   //!@name Parallel processing mode
 120
 121   //! Gets the global parallel mode
 122   Standard_EXPORT static Standard_Boolean GetParallelMode();
 123
 124   //! Sets the global parallel mode
 125   Standard_EXPORT static void SetParallelMode(const Standard_Boolean theNewMode);
 126
 127   //! Set the flag of parallel processing
 128   //! if <theFlag> is true  the parallel processing is switched on
 129   //! if <theFlag> is false the parallel processing is switched off
 130   void SetRunParallel(const Standard_Boolean theFlag)
 131   {
 132     myRunParallel = theFlag;
 133   }
 134
 135   //! Returns the flag of parallel processing
 136   Standard_Boolean RunParallel() const
 137   {
 138     return myRunParallel;
 139   }
 140
 141 public:
 142   //!@name Fuzzy tolerance
 143
 144   //! Sets the additional tolerance
 145   Standard_EXPORT void SetFuzzyValue(const Standard_Real theFuzz);
 146
 147   //! Returns the additional tolerance
 148   Standard_Real FuzzyValue() const
 149   {
 150     return myFuzzyValue;
 151   }
 152
 153 public:
 154   //!@name Progress indicator
 155
 156   //! Set the Progress Indicator object.
 157   Standard_EXPORT void SetProgressIndicator(const Handle(Message_ProgressIndicator)& theObj);
 158
 159 protected:
 160
 161   //! Breaks the execution if the break signal
 162   //! is indicated by myProgressIndicator.
 163   Standard_EXPORT void UserBreak() const;
 164
 165 protected:
 166
 167   BOPCol_BaseAllocator myAllocator;
 168   Handle(Message_Report) myReport;
 169   Standard_Boolean myRunParallel;
 170   Standard_Real myFuzzyValue;
 171   Handle(Message_ProgressIndicator) myProgressIndicator;
 172
 173 };
 174
 175 #endif // _BOPAlgo_Options_HeaderFile