mitkProcessExecutor.h

Go to the documentation of this file.

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

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.

Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.

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

// Class is adapted from MatchPoint ProcessExecutor

#ifndef __MITK_PROCESS_EXECUTOR_H
#define __MITK_PROCESS_EXECUTOR_H

#include <MitkSegmentationExports.h>
#include <itkObject.h>
#include <vector>
#include <itksys/Process.h>

namespace mitk
{
  class ExternalProcessOutputEvent : public itk::AnyEvent
  {
  public:
    typedef ExternalProcessOutputEvent Self;
    typedef itk::AnyEvent Superclass;

    explicit ExternalProcessOutputEvent(const std::string &output = "") : m_Output(output) {}
    ~ExternalProcessOutputEvent() override {}

    const char *GetEventName() const override { return "ExternalProcessOutputEvent"; }
    bool CheckEvent(const ::itk::EventObject *e) const override { return dynamic_cast<const Self *>(e); }
    itk::EventObject *MakeObject() const override { return new Self(m_Output); }
    std::string GetOutput() const { return m_Output; }

  private:
    std::string m_Output;
  };

#define mitkProcessExecutorEventMacro(classname)                                                                       \
  class classname : public ExternalProcessOutputEvent                                                                  \
  {                                                                                                                    \
  public:                                                                                                              \
    typedef classname Self;                                                                                            \
    typedef ExternalProcessOutputEvent Superclass;                                                                     \
                                                                                                                       \
    explicit classname(const std::string &output) : Superclass(output) {}                                              \
    ~classname() override {}                                                                                           \
                                                                                                                       \
    virtual const char *GetEventName() const { return #classname; }                                                    \
    virtual bool CheckEvent(const ::itk::EventObject *e) const { return dynamic_cast<const Self *>(e); }               \
    virtual ::itk::EventObject *MakeObject() const { return new Self(this->GetOutput()); }                             \
  };

  mitkProcessExecutorEventMacro(ExternalProcessStdOutEvent);
  mitkProcessExecutorEventMacro(ExternalProcessStdErrEvent);

  class MITKSEGMENTATION_EXPORT ProcessExecutor : public itk::Object
  {
  public:
    using Self = ProcessExecutor;
    using Superclass = ::itk::Object;
    using Pointer = ::itk::SmartPointer<Self>;
    using ConstPointer = ::itk::SmartPointer<const Self>;

    itkTypeMacro(ProcessExecutor, ::itk::Object);
    itkFactorylessNewMacro(Self);

    itkSetMacro(SharedOutputPipes, bool);
    itkGetConstMacro(SharedOutputPipes, bool);

    using ArgumentListType = std::vector<std::string>;

    bool Execute(const std::string &executionPath, const std::string &executableName, ArgumentListType &argumentList);

    bool Execute(const std::string &executionPath, const ArgumentListType &argumentList);

    int GetExitValue();
    static std::string EnsureCorrectOSPathSeparator(const std::string &);

    static std::string GetOSDependendExecutableName(const std::string &name);

    void KillProcess();

  protected:
    ProcessExecutor();
    ~ProcessExecutor() override;

    int m_ExitValue;

    bool m_SharedOutputPipes;

  private:
    itksysProcess *m_ProcessID = nullptr;
  };

} // namespace mitk
#endif