gdcmCommand.h

Go to the documentation of this file.

/*=========================================================================
 
  Program: GDCM (Grassroots DICOM). A DICOM library
 
  Copyright (c) 2006-2011 Mathieu Malaterre
  All rights reserved.
  See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef GDCMCOMMAND_H
#define GDCMCOMMAND_H
 
#include "gdcmSubject.h"
 
namespace gdcm
{
class Event;
 
class GDCM_EXPORT Command : public Subject
{
public :
  Command(const Command&) = delete;
  void operator=(const Command&) = delete;
 
  virtual void Execute(Subject *caller, const Event & event ) = 0;
 
  virtual void Execute(const Subject *caller, const Event & event ) = 0;
 
protected:
  Command();
  ~Command() override;
};
 
template <class T>
class MemberCommand : public Command
{
public:
 
  typedef  void (T::*TMemberFunctionPointer)(Subject*, const Event &);
  typedef  void (T::*TConstMemberFunctionPointer)(const Subject*,
                                                  const Event &);
 
  typedef MemberCommand       Self;
  //typedef SmartPointer<Self>  Pointer;
 
  MemberCommand(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  static SmartPointer<MemberCommand> New()
    {
    return new MemberCommand;
    }
 
  //gdcmTypeMacro(MemberCommand,Command);
 
  void SetCallbackFunction(T* object,
                           TMemberFunctionPointer memberFunction)
    {
    m_This = object;
    m_MemberFunction = memberFunction;
    }
  void SetCallbackFunction(T* object,
                           TConstMemberFunctionPointer memberFunction)
    {
    m_This = object;
    m_ConstMemberFunction = memberFunction;
    }
 
  void Execute(Subject *caller, const Event & event ) override
    {
    if( m_MemberFunction )
      {
      ((*m_This).*(m_MemberFunction))(caller, event);
      }
    }
 
  void Execute( const Subject *caller, const Event & event ) override
    {
    if( m_ConstMemberFunction )
      {
      ((*m_This).*(m_ConstMemberFunction))(caller, event);
      }
    }
 
protected:
 
  T* m_This;
  TMemberFunctionPointer m_MemberFunction;
  TConstMemberFunctionPointer m_ConstMemberFunction;
  MemberCommand():m_MemberFunction(nullptr),m_ConstMemberFunction(nullptr) {}
  ~MemberCommand() override= default;
 
};
 
template <typename T>
class SimpleMemberCommand : public Command
{
public:
 
  typedef  void (T::*TMemberFunctionPointer)();
 
  typedef SimpleMemberCommand   Self;
  //typedef SmartPointer<Self>    Pointer;
 
  SimpleMemberCommand(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  //gdcmTypeMacro(SimpleMemberCommand,Command);
 
  static SmartPointer<SimpleMemberCommand> New()
    {
    return new SimpleMemberCommand;
    }
 
  void SetCallbackFunction(T* object,
                           TMemberFunctionPointer memberFunction)
    {
    m_This = object;
    m_MemberFunction = memberFunction;
    }
 
  void Execute(Subject *,const Event & ) override
    {
    if( m_MemberFunction )
      {
      ((*m_This).*(m_MemberFunction))();
      }
    }
  void Execute(const Subject *,const Event & ) override
    {
    if( m_MemberFunction )
      {
      ((*m_This).*(m_MemberFunction))();
      }
    }
 
protected:
  T* m_This;
  TMemberFunctionPointer m_MemberFunction;
  SimpleMemberCommand():m_This(nullptr),m_MemberFunction(nullptr) {}
  ~SimpleMemberCommand() override = default;
};
 
} // end namespace gdcm
//-----------------------------------------------------------------------------
#endif //GDCMCOMMAND_H