Progress.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//----- Included files ---------------------------------------------------------

// 1. Precompiled header

// 2. My own header
#include <xmscore/misc/Progress.h>

// 3. Standard library headers

// 4. External library headers

// 5. Shared code headers
#include <xmscore/misc/XmError.h>

// 6. Non-shared code headers

//----- Forward declarations ---------------------------------------------------

//----- External globals -------------------------------------------------------

//----- Namespace declaration --------------------------------------------------
namespace xms
{
//----- Constants / Enumerations -----------------------------------------------

//----- Classes / Structs ------------------------------------------------------

//----- Internal functions -----------------------------------------------------

//----- Class / Function definitions -------------------------------------------

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BSHP<ProgressListener>& iListener()
{
  static BSHP<ProgressListener> fg_listener;
  return fg_listener;
} // iListener

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Progress::Progress(const std::string& a_message)
: m_stackIndex(0)
, m_itemCount(0)
{
  if (iListener())
  {
    m_stackIndex = iListener()->OnBeginOperationString(a_message);
  }
} // Progress::Progress
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Progress::~Progress()
{
  if (iListener())
  {
    iListener()->OnEndOperation(m_stackIndex);
  }
} // Progress::~Progress
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Progress::UpdateMessage(const std::string& a_message)
{
  if (iListener())
  {
    iListener()->OnUpdateMessage(m_stackIndex, a_message);
  }
} // Progress::UpdateMessage
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Progress::SetItemCount(long long a_count)
{
  m_itemCount = a_count;
} // Progress::SetItemCount
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Progress::CurrentItem(long long a_item)
{
  XM_ASSERT(m_itemCount != 0);
  if (iListener() && m_itemCount)
  {
    if (a_item < m_itemCount)
      ++a_item;
    iListener()->OnProgressStatus(m_stackIndex, (double)a_item / m_itemCount);
  }
} // Progress::CurrentItem
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Progress::ProgressStatus(double a_fractionComplete)
{
  // should use either this alone or SetItemCount/CurrentItem
  XM_ASSERT(m_itemCount == 0);

  if (iListener())
  {
    iListener()->OnProgressStatus(m_stackIndex, a_fractionComplete);
  }
} // Progress::ProgressStatus

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
ProgressListener::~ProgressListener()
{
} // ProgressListener::~ProgressListener
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ProgressListener::SetListener(BSHP<ProgressListener> a_listener)
{
  iListener() = a_listener;
} // ProgressListener::SetListener
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BSHP<ProgressListener> ProgressListener::GetListener()
{
  return iListener();
} // ProgressListener::GetListener

} // namespace xms

#ifdef CXX_TEST
#include <xmscore/misc/Progress.t.h>
#include <sstream>

using namespace xms;

class MockProgressListener : public ProgressListener
{
public:
  MockProgressListener() {}
  ~MockProgressListener() {}

  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  void OnProgressStatus(int a_stackIndex, double a_fractionComplete) override
  {
    std::ostringstream ss;
    ss << "OnProgressStatus " << a_stackIndex << ": " << a_fractionComplete << '\n';
    m_messages += ss.str();
  }
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  int OnBeginOperationString(const std::string& a_operation) override
  {
    ++m_stackIndex;
    std::ostringstream ss;
    ss << "OnBeginOperationString " << a_operation << '\n';
    m_messages += ss.str();
    return m_stackIndex;
  }

  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  void OnEndOperation(int a_stackIndex) override
  {
    --m_stackIndex;
    std::ostringstream ss;
    ss << "OnEndOperation " << a_stackIndex << '\n';
    m_messages += ss.str();
  }

  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  void OnUpdateMessage(int a_stackIndex, const std::string& a_message) override
  {
    std::ostringstream ss;
    ss << "OnUpdateMessage " << a_stackIndex << ": " << a_message << '\n';
    m_messages += ss.str();
  }

  std::string m_messages; 
  int m_stackIndex = 0;   
};
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ProgressUnitTests::testProgress()
{
  BSHP<ProgressListener> old = ProgressListener::GetListener();
  BSHP<MockProgressListener> listener(new MockProgressListener);
  ProgressListener::SetListener(listener);
  {
    Progress p1("First progress");
    p1.ProgressStatus(0.5);
    {
      {
        Progress p2("Second progress");
        p2.ProgressStatus(0.25);
        p2.UpdateMessage("Second progress message 2");
        p2.ProgressStatus(0.75);
      }
      {
        Progress p3("Third progress");
        p3.SetItemCount(4);
        p3.CurrentItem(0);
        p3.CurrentItem(1);
        p3.CurrentItem(2);
        p3.CurrentItem(3);
      }
    }
    p1.ProgressStatus(1.0);
  }

  std::string expected =
    "OnBeginOperationString First progress\n"
    "OnProgressStatus 1: 0.5\n"
    "OnBeginOperationString Second progress\n"
    "OnProgressStatus 2: 0.25\n"
    "OnUpdateMessage 2: Second progress message 2\n"
    "OnProgressStatus 2: 0.75\n"
    "OnEndOperation 2\n"
    "OnBeginOperationString Third progress\n"
    "OnProgressStatus 2: 0.25\n"
    "OnProgressStatus 2: 0.5\n"
    "OnProgressStatus 2: 0.75\n"
    "OnProgressStatus 2: 1\n"
    "OnEndOperation 2\n"
    "OnProgressStatus 1: 1\n"
    "OnEndOperation 1\n";
  TS_ASSERT_EQUALS(expected, listener->m_messages);
  ProgressListener::SetListener(old);
} // ProgressUnitTests::testProgress

#endif