niftkAtomicStateTransitionTester.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

=============================================================================*/

#ifndef niftkAtomicStateTransitionTester_h
#define niftkAtomicStateTransitionTester_h

#include <niftkItkSignalCollector.h>
#include <niftkQtSignalCollector.h>

#include <QObject>
#include <QByteArray>
#include <QMetaObject>

#include <mitkCommon.h>

#include <map>

namespace niftk
{

template <class TestObject, class TestObjectState>
class AtomicStateTransitionTester : public itk::Object, private ItkSignalListener, private QtSignalListener
{
public:

  mitkClassMacroItkParent(AtomicStateTransitionTester, itk::Object)
  mitkNewMacro1Param(AtomicStateTransitionTester, TestObject)

  typedef ItkSignalCollector::Signal ItkSignal;
  typedef ItkSignalCollector::Signals ItkSignals;

  typedef QtSignalCollector::Signal QtSignal;
  typedef QtSignalCollector::Signals QtSignals;

  itkGetConstMacro(TestObject, TestObject);

  itkGetConstMacro(InitialState, typename TestObjectState::Pointer);

  itkGetConstMacro(NextState, typename TestObjectState::Pointer);

  itkGetConstMacro(ExpectedState, typename TestObjectState::Pointer);

  itkSetMacro(ExpectedState, typename TestObjectState::Pointer);

  virtual void Clear();

  void Connect(itk::Object* itkObject, const itk::EventObject& event);

  void Connect(const itk::EventObject& event);

  void Connect(const QObject* qObject, const char* signal = 0);

  void Connect(const char* signal);

  const ItkSignals& GetItkSignals() const
  {
    return m_ItkSignalCollector->GetSignals();
  }

  ItkSignals GetItkSignals(const itk::Object* itkObject, const itk::EventObject& event = itk::AnyEvent()) const
  {
    return m_ItkSignalCollector->GetSignals(itkObject, event);
  }

  ItkSignals GetItkSignals(const itk::EventObject& event) const
  {
    return m_ItkSignalCollector->GetSignals(event);
  }

  const QtSignals& GetQtSignals() const
  {
    return m_QtSignalCollector->GetSignals();
  }

  QtSignals GetQtSignals(const QObject* object, const char* signal = 0)
  {
    return m_QtSignalCollector->GetSignals(object, signal);
  }

  QtSignals GetQtSignals(const char* signal)
  {
    return m_QtSignalCollector->GetSignals(signal);
  }

protected:

  AtomicStateTransitionTester(TestObject testObject);

  virtual ~AtomicStateTransitionTester();

  virtual void OnItkSignalReceived(const itk::Object* object, const itk::EventObject& event)
  {
    this->CheckState();
  }

  virtual void OnQtSignalReceived(const QObject* object, const char* signal)
  {
    this->CheckState();
  }

  virtual void PrintSelf(std::ostream & os, itk::Indent indent) const;

private:

  void CheckState();

  TestObject m_TestObject;

  typename TestObjectState::Pointer m_InitialState;

  typename TestObjectState::Pointer m_NextState;

  typename TestObjectState::Pointer m_ExpectedState;

  ItkSignalCollector::Pointer m_ItkSignalCollector;

  QtSignalCollector::Pointer m_QtSignalCollector;

};

}

#endif