process.h

Go to the documentation of this file.

 
#pragma once
#include "../core_export.h"
#include "../event.h"
#include "../event_handler.h"
#include "../object.h"
#include "../ustring.h"
#include "data_received_event_handler.h"
#include "process_priority_class.h"
#include "process_start_info.h"
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <thread>
 
struct __init_process_message_box_message__;
 
namespace xtd {
  namespace diagnostics {
    class core_export_ process final : public object {
      struct data;
      
    public:
      class error_data_received_event : protected xtd::diagnostics::data_received_event_handler {
        friend process;
        void set_data(data* data) {data_ = data;}
      public:
        bool is_empty() const noexcept;
        
        xtd::diagnostics::data_received_event_handler& operator+=(const xtd::diagnostics::data_received_event_handler& handler) noexcept;
        
        xtd::diagnostics::data_received_event_handler& operator+=(const typename xtd::diagnostics::data_received_event_handler::function_t& function) noexcept;
        
        template<typename fn_t>
        xtd::diagnostics::data_received_event_handler& operator+=(fn_t function) noexcept {
          data_->error_data_received_callback_+=(function);
          return xtd::diagnostics::data_received_event_handler::operator+=(function);
        }
        
        xtd::diagnostics::data_received_event_handler& operator-=(const xtd::diagnostics::data_received_event_handler& handler) noexcept;
        
        xtd::diagnostics::data_received_event_handler& operator-=(const typename xtd::diagnostics::data_received_event_handler::function_t& function) noexcept;
        
        template<typename fn_t>
        xtd::diagnostics::data_received_event_handler& operator -=(fn_t function) noexcept {
          data_->error_data_received_callback_-=(function);
          return data_received_event_handler::operator-=(function);
        }
        
      private:
        data* data_ = nullptr;
      };
 
      class exit_event : protected xtd::event_handler {
        friend process;
        void set_data(data* data) {data_ = data;}
      public:
        bool is_empty() const noexcept;
        
        xtd::event_handler& operator+=(const xtd::event_handler& handler) noexcept;
        
        xtd::event_handler& operator+=(const typename xtd::event_handler::function_t& function) noexcept;
        
        template<typename fn_t>
        xtd::event_handler& operator+=(fn_t function) noexcept {
          data_->exit_callback_+=(function);
          return xtd::event_handler::operator+=(function);
        }
        
        xtd::event_handler& operator-=(const xtd::event_handler& handler) noexcept;
        
        xtd::event_handler& operator-=(const typename xtd::event_handler::function_t& function) noexcept;
        
        template<typename fn_t>
        xtd::event_handler& operator -=(fn_t function) noexcept {
          data_->exit_callback_-=(function);
          return xtd::event_handler::operator-=(function);
        }
        
      private:
        data* data_ = nullptr;
      };
      
      class output_data_received_event : protected xtd::diagnostics::data_received_event_handler {
        friend process;
        void set_data(data* data) {data_ = data;}
      public:
        bool is_empty() const noexcept;
        
        xtd::diagnostics::data_received_event_handler& operator+=(const xtd::diagnostics::data_received_event_handler& handler) noexcept;
        
        xtd::diagnostics::data_received_event_handler& operator+=(const typename xtd::diagnostics::data_received_event_handler::function_t& function) noexcept;
        
        template<typename fn_t>
        xtd::diagnostics::data_received_event_handler& operator+=(fn_t function) noexcept {
          data_->output_data_received_callback_+=(function);
          return xtd::diagnostics::data_received_event_handler::operator+=(function);
        }
        
        xtd::diagnostics::data_received_event_handler& operator-=(const xtd::diagnostics::data_received_event_handler& handler) noexcept;
        
        xtd::diagnostics::data_received_event_handler& operator-=(const typename xtd::diagnostics::data_received_event_handler::function_t& function) noexcept;
        
        template<typename fn_t>
        xtd::diagnostics::data_received_event_handler& operator -=(fn_t function) noexcept {
          data_->output_data_received_callback_-=(function);
          return xtd::diagnostics::data_received_event_handler::operator-=(function);
        }
        
      private:
        data* data_ = nullptr;
      };
      
      using time_point = std::chrono::system_clock::time_point;
 
      process();
      process(const process&) = default;
      process& operator=(const process& value);
      ~process();
      
      int32_t base_priority() const;
      
      bool enable_raising_events() const;
      process& enable_raising_events(bool value);
 
      int32_t exit_code() const;
 
      time_point exit_time() const;
 
      intptr_t handle() const;
      
      bool has_exited() const;
 
      int32_t id() const;
 
      ustring machine_name() const;
 
      xtd::diagnostics::process_priority_class priority_class() const;
      process& priority_class(xtd::diagnostics::process_priority_class value);
      
      ustring process_name() const;
 
      std::istream& standard_error();
 
      std::ostream& standard_input();
 
      std::istream& standard_output();
 
      const xtd::diagnostics::process_start_info& start_info() const;
      xtd::diagnostics::process_start_info& start_info();
      process& start_info(const xtd::diagnostics::process_start_info& value);
 
      time_point start_time() const;
 
      void close();
      
      void kill();
 
      bool start();
      static process start(const xtd::diagnostics::process_start_info& start_info);
      static process start(const ustring& file_name);
      static process start(const ustring& file_name, const ustring& arguments);
 
      process& wait_for_exit();
      
      process& wait_for_exit(int32_t milliseconds);
      
      error_data_received_event error_data_received;
      
      exit_event exited;
      
      output_data_received_event output_data_received;
      
    protected:
      virtual void on_exited();
      
    private:
      struct data {
        xtd::diagnostics::process_start_info start_info_;
        std::optional<intptr_t> handle_ = 0;
        int32_t id_ = 0;
        ustring machine_name_;
        xtd::diagnostics::process_priority_class priority_class_ = xtd::diagnostics::process_priority_class::normal;
        std::unique_ptr<std::ostream> standard_input_;
        std::unique_ptr<std::istream> standard_output_;
        std::unique_ptr<std::istream> standard_error_;
        std::thread thread_;
        process::time_point start_time_;
        process::time_point exit_time_;
        bool enable_raising_events_ = false;
        std::optional<int32_t> exit_code_;
        event_handler exit_callback_;
        data_received_event_handler error_data_received_callback_;
        data_received_event_handler output_data_received_callback_;
        std::exception_ptr exception_pointer_;
      };
      std::shared_ptr<data> data_ = std::make_shared<data>();
      friend __init_process_message_box_message__;
      inline static xtd::delegate<void(const ustring&)> message_box_message_;
    };
  }
}