process.hpp

Go to the documentation of this file.

 
#pragma once
#include "../core_export.hpp"
#include "../date_time.hpp"
#include "../event.hpp"
#include "../event_handler.hpp"
#include "../object.hpp"
#include "../string.hpp"
#include "../optional.hpp"
#include "data_received_event_handler.hpp"
#include "process_priority_class.hpp"
#include "process_start_info.hpp"
#include <functional>
#include <memory>
 
struct __init_process_message_box_message__;
 
namespace xtd {
  namespace diagnostics {
    class core_export_ process final : public xtd::object {
      struct data;
      
    public:
      class error_data_received_event : protected xtd::diagnostics::data_received_event_handler {
        friend process;
        void set_data(process::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 {
          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 {
          error_data_received_callback() -= (function);
          return data_received_event_handler::operator -=(function);
        }
        
      private:
        data_received_event_handler& error_data_received_callback() noexcept;
        process::data* data_ = nullptr;
      };
      
      class exit_event : protected xtd::event_handler {
        friend process;
        void set_data(process::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 {
          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 {
          exit_callback() -= (function);
          return xtd::event_handler::operator -=(function);
        }
        
      private:
        event_handler& exit_callback() noexcept;
        process::data* data_ = nullptr;
      };
      
      class output_data_received_event : protected xtd::diagnostics::data_received_event_handler {
        friend process;
        void set_data(process::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 {
          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 {
          output_data_received_callback() -= (function);
          return xtd::diagnostics::data_received_event_handler::operator -=(function);
        }
        
      private:
        data_received_event_handler& output_data_received_callback() noexcept;
        process::data* data_ = nullptr;
      };
      
      
      process();
      
      process(const process&) = default;
      process& operator =(const process& value);
      ~process();
      
      
      int32 base_priority() const;
      
      bool enable_raising_events() const;
      process& enable_raising_events(bool value);
      
      int32 exit_code() const;
      
      xtd::date_time exit_time() const;
      
      intptr handle() const;
      
      bool has_exited() const;
      
      int32 id() const;
      
      string machine_name() const;
      
      xtd::diagnostics::process_priority_class priority_class() const;
      process& priority_class(xtd::diagnostics::process_priority_class value);
      
      string 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);
      
      xtd::date_time start_time() const;
      
      
      void close();
      
      void kill();
      
      bool start();
      
      process& wait_for_exit();
      
      process& wait_for_exit(int32 milliseconds);
 
      
      static process start(const xtd::diagnostics::process_start_info& start_info);
      static process start(const string& file_name);
      static process start(const string& file_name, const string& arguments);
      
      
      error_data_received_event error_data_received;
      
      exit_event exited;
      
      output_data_received_event output_data_received;
      
    protected:
      
      virtual void on_exited();
      
    private:
      xtd::sptr<data> data_;
      friend __init_process_message_box_message__;
      inline static xtd::delegate<void(const string&)> message_box_message_;
    };
  }
}