Observer.cpp

Go to the documentation of this file.

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

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

// 1. Precompiled header

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

// 3. Standard library headers

// 4. External library headers
#pragma warning(push)
#pragma warning(disable : 4103)
#include <boost/timer/timer.hpp>
#pragma warning(pop)

// 5. Shared code headers

// 6. Non-shared code headers

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

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

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

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

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

//----- Class / Function definitions -------------------------------------------
class Observer::impl
{
public:
  impl()
  : m_percentComplete(0)
  {
  }
  ~impl() {}

  void BeginOperationString();
  void EndOperation();
  double ElapsedTimeInSeconds();
  double EstimatedTimeRemainingInSec(double a_percentComplete, double a_elapsedTime);

  boost::timer::cpu_timer m_timer; 
  double m_percentComplete;        
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Observer::Observer()
: m_p(new Observer::impl())
{
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
Observer::~Observer()
{
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool Observer::ProgressStatus(double a_percentComplete)
{
  if (a_percentComplete > m_p->m_percentComplete + .02)
  {
    double elapsedTime = m_p->ElapsedTimeInSeconds();
    m_p->m_percentComplete = a_percentComplete;
    OnProgressStatus(a_percentComplete);

    TimeElapsedInSeconds(elapsedTime);
    double rem = m_p->EstimatedTimeRemainingInSec(a_percentComplete, elapsedTime);
    TimeRemainingInSeconds(rem);
    return true;
  }
  return false;
} // Observer::ProgressStatus
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::TimeRemainingInSeconds(double a_remainingSeconds)
{
  (void)a_remainingSeconds;
} // Observer::TimeRemainingInSeconds
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::TimeElapsedInSeconds(double a_elapsedSeconds)
{
  (void)a_elapsedSeconds;
} // Observer::TimeElapsedInSeconds
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::BeginOperationString(const std::string& a_operation)
{
  m_p->BeginOperationString();
  OnBeginOperationString(a_operation);
  ProgressStatus(0.0);
} // Observer::BeginOperationString
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::EndOperation()
{
  m_p->EndOperation();
  OnEndOperation();
  ProgressStatus(0.0);
} // Observer::EndOperation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::UpdateMessage(const std::string& a_message)
{
  OnUpdateMessage(a_message);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::OnBeginOperationString(const std::string& a_operation)
{
  (void)a_operation;
} // Observer::OnBeginOperationString
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::OnEndOperation()
{
} // Observer::OnEndOperation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::OnUpdateMessage(const std::string& a_message)
{
  (void)a_message; // For Doxygen
} // Observer::OnUpdateMessage
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::impl::BeginOperationString()
{
  m_timer.start();
  m_percentComplete = 0;
} // Observer::impl::BeginOperationString
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void Observer::impl::EndOperation()
{
  m_timer.stop();
} // Observer::impl::EndOperation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double Observer::impl::ElapsedTimeInSeconds()
{
  boost::timer::cpu_times const elapsed_times(m_timer.elapsed());
  boost::timer::nanosecond_type time = elapsed_times.wall;
  const double NANO_PER_SEC = 1e9;
  double seconds = time / NANO_PER_SEC;
  return seconds;
} // Observer::impl::ElapsedTimeInSeconds
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
double Observer::impl::EstimatedTimeRemainingInSec(double a_percentComplete, double a_elapsedTime)
{
  if (a_percentComplete < .01)
    return 60;

  double percentRemaining = 1 - a_percentComplete;
  double timeRemaining = (a_elapsedTime * percentRemaining) / a_percentComplete;
  return timeRemaining;
} // Observer::impl::EstimatedTimeRemainingInSec

} // namespace xms

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

#include <boost/thread/thread.hpp>

#include <xmscore/math/math.h>
#include <xmscore/testing/TestTools.h>

class MockObserver : public xms::Observer
{
public:
  double m_percentComplete, 
    m_remainingSeconds,     
    m_elapsedSeconds;       
  std::stringstream m_info; 

private:
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  virtual void OnProgressStatus(double a_percentComplete) override
  {
    m_percentComplete = a_percentComplete;
    int i = (int)(xms::Round(m_percentComplete * 100));
    m_info << "Percent complete: " << i << "%.\n";
  }
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  virtual void OnBeginOperationString(const std::string& a_operation) override
  {
    if (!m_info.str().empty())
      m_info << "\n";
    m_info << "Begin operation: " << a_operation << ".\n";
  }
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  virtual void TimeElapsedInSeconds(double a_elapsedSeconds) override
  {
    m_elapsedSeconds = a_elapsedSeconds;
    int i = (int)(xms::Round(m_elapsedSeconds * 10));
    m_info << "Elapsed seconds: 0." << i << ".\n";
  }

  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  virtual void TimeRemainingInSeconds(double a_secondsRemaining) override
  {
    m_remainingSeconds = a_secondsRemaining;
    int i = (int)(xms::Round(m_remainingSeconds * 10));
    m_info << "Time remaining (seconds): 0." << i << ".\n";
  }
};
class MockMesher
{
public:
  MockMesher() {}
  ~MockMesher() {}

  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  void SetObserver(BSHP<xms::Observer> a_) { m_prog = a_; }
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  void WaitForNextTenthSecond(boost::timer::cpu_timer& a_timer, int& a_count)
  {
    ++a_count;
    const long long tenth_second = 100000000LL;
    while (a_timer.elapsed().wall < tenth_second * a_count)
    {
    }
    // boost::this_thread::sleep(boost::posix_time::millisec(100));
  }
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  void PretendMeshing()
  {
    if (!m_prog)
      return;

    boost::timer::cpu_timer timer;
    int count = 0;

    m_prog->BeginOperationString("Generating mesh points");
    for (int i = 0; i < 4; ++i)
    {
      WaitForNextTenthSecond(timer, count);
      m_prog->ProgressStatus((double)(i + 1) / 4);
    }

    m_prog->BeginOperationString("Triangulating");
    for (int i = 0; i < 5; ++i)
    {
      WaitForNextTenthSecond(timer, count);
      m_prog->ProgressStatus((double)(i + 1) / 5);
    }

    m_prog->BeginOperationString("Generating unstructured grid");
    for (int i = 0; i < 3; ++i)
    {
      WaitForNextTenthSecond(timer, count);
      m_prog->ProgressStatus((double)(i + 1) / 3);
    }
  }

  BSHP<xms::Observer> m_prog; 
};
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef CXXTEST4
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
const CxxTest::TestGroup& ObserverIntermediateTests::group()
{
  return *CxxTest::TestGroup::GetGroup(CxxTest::TG_INTERMEDIATE);
  // return CxxTest::TestSuite::group();
} // ObserverIntermediateTests::group
#endif
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ObserverIntermediateTests::testTimeRemaining()
{
  MockObserver o;
  o.BeginOperationString("Test Operation");
  boost::this_thread::sleep(boost::posix_time::millisec(100));
  o.ProgressStatus(.2);
  double remaining = (o.m_elapsedSeconds * .8) / .2;
  const double DELTA = 1e-5;
  TS_ASSERT_DELTA(remaining, o.m_remainingSeconds, DELTA);
} // ObserverIntermediateTests::testTimeRemaining
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ObserverIntermediateTests::testMockObserver()
{
  // create an object derived off of Observer
  BSHP<MockObserver> p(new MockObserver());
  // create a mock meshing class
  MockMesher m;
  // set the observer on the mesher
  m.SetObserver(p);
  // execute the mesher
  m.PretendMeshing();
  // capture the output from the observer class and verify it
  std::string outStr(p->m_info.str());
  std::string baseStr =
    "Begin operation: Generating mesh points.\n"
    "Percent complete: 25%.\n"
    "Elapsed seconds: 0.1.\n"
    "Time remaining (seconds): 0.3.\n"
    "Percent complete: 50%.\n"
    "Elapsed seconds: 0.2.\n"
    "Time remaining (seconds): 0.2.\n"
    "Percent complete: 75%.\n"
    "Elapsed seconds: 0.3.\n"
    "Time remaining (seconds): 0.1.\n"
    "Percent complete: 100%.\n"
    "Elapsed seconds: 0.4.\n"
    "Time remaining (seconds): 0.0.\n"
    "\n"
    "Begin operation: Triangulating.\n"
    "Percent complete: 20%.\n"
    "Elapsed seconds: 0.1.\n"
    "Time remaining (seconds): 0.4.\n"
    "Percent complete: 40%.\n"
    "Elapsed seconds: 0.2.\n"
    "Time remaining (seconds): 0.3.\n"
    "Percent complete: 60%.\n"
    "Elapsed seconds: 0.3.\n"
    "Time remaining (seconds): 0.2.\n"
    "Percent complete: 80%.\n"
    "Elapsed seconds: 0.4.\n"
    "Time remaining (seconds): 0.1.\n"
    "Percent complete: 100%.\n"
    "Elapsed seconds: 0.5.\n"
    "Time remaining (seconds): 0.0.\n"
    "\n"
    "Begin operation: Generating unstructured grid.\n"
    "Percent complete: 33%.\n"
    "Elapsed seconds: 0.1.\n"
    "Time remaining (seconds): 0.2.\n"
    "Percent complete: 67%.\n"
    "Elapsed seconds: 0.2.\n"
    "Time remaining (seconds): 0.1.\n"
    "Percent complete: 100%.\n"
    "Elapsed seconds: 0.3.\n"
    "Time remaining (seconds): 0.0.\n";
  TS_ASSERT_EQUALS(baseStr, outStr);
} // ObserverIntermediateTests::testMockObserver

#endif