OCCT

// Copyright (c) 2020 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#ifndef _Message_ProgressRange_HeaderFile
#define _Message_ProgressRange_HeaderFile

#include <Standard_TypeDef.hxx>

class Message_ProgressScope;

//! Auxiliary class representing a part of the global progress scale allocated by
//! a step of the progress scope, see Message_ProgressScope::Next().
//!
//! A range object takes responsibility of advancing the progress by the size of
//! allocated step, which is then performed depending on how it is used:
//!
//! - If Message_ProgressScope object is created using this range as argument, then
//!   this respondibility is taken over by that scope.
//!
//! - Otherwise, a range advances progress directly upon destruction.
//!
//! A range object can be copied, the responsibility for progress advancement is
//! then taken by the copy.
//! The same range object may be used (either copied or used to create scope) only once.
//! Any consequent attempts to use range will give no result on the progress;
//! in debug mode, an assert message will be generated.
//!
//! @sa Message_ProgressScope for more details
class Message_ProgressRange
{
public:
  //! Constructor of the empty range
  Message_ProgressRange()
      : myParentScope(nullptr),
        myStart(0.),
        myDelta(0.),
        myWasUsed(false)
  {
  }

  //! Copy constructor disarms the source
  Message_ProgressRange(const Message_ProgressRange& theOther)
      : myParentScope(theOther.myParentScope),
        myStart(theOther.myStart),
        myDelta(theOther.myDelta),
        myWasUsed(theOther.myWasUsed)
  {
    // discharge theOther
    theOther.myWasUsed = true;
  }

  //! Copy assignment disarms the source
  Message_ProgressRange& operator=(const Message_ProgressRange& theOther)
  {
    myParentScope      = theOther.myParentScope;
    myStart            = theOther.myStart;
    myDelta            = theOther.myDelta;
    myWasUsed          = theOther.myWasUsed;
    theOther.myWasUsed = true;
    return *this;
  }

  //! Returns true if ProgressIndicator signals UserBreak
  bool UserBreak() const;

  //! Returns false if ProgressIndicator signals UserBreak
  bool More() const { return !UserBreak(); }

  //! Returns true if this progress range is attached to some indicator.
  bool IsActive() const;

  //! Closes the current range and advances indicator
  void Close();

  //! Destructor
  ~Message_ProgressRange() { Close(); }

private:
  //! Constructor is private
  Message_ProgressRange(const Message_ProgressScope& theParent, double theStart, double theDelta)
      : myParentScope(&theParent),
        myStart(theStart),
        myDelta(theDelta),
        myWasUsed(false)
  {
  }

private:
  const Message_ProgressScope* myParentScope; //!< Pointer to parent scope
  double                       myStart;       //!< Start point on the global scale
  double                       myDelta;       //!< Step of incrementation on the global scale

  mutable bool myWasUsed; //!< Flag indicating that this range
                          //!  was used to create a new scope

  friend class Message_ProgressScope;
};

#include <Message_ProgressIndicator.hxx>

//=================================================================================================

inline bool Message_ProgressRange::IsActive() const
{
  return !myWasUsed && myParentScope && myParentScope->myProgress;
}

//=================================================================================================

inline bool Message_ProgressRange::UserBreak() const
{
  return myParentScope && myParentScope->myProgress && myParentScope->myProgress->UserBreak();
}

//=================================================================================================

inline void Message_ProgressRange::Close()
{
  if (!IsActive())
    return;

  myParentScope->myProgress->Increment(myDelta, *myParentScope);
  myParentScope = nullptr;
  myWasUsed     = true;
}

#endif // _Message_ProgressRange_HeaderFile