cpp-software-patterns/BaseLib/Process.h at master · intact-software-systems/cpp-software-patterns · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
/***************************************************************************
                          Process.h  -  description
                             -------------------
    begin                : Sun May 9 2010
    copyright            : (C) 2010 by Knut-Helge Vik
    email                : knuthelge@vik.gs
 ***************************************************************************/
#ifndef BaseLib_Process_h_Included
#define BaseLib_Process_h_Included

#include <string>
#include <iostream>
#include <limits.h>

#include "BaseLib/Mutex.h"
#include "BaseLib/MutexLocker.h"

using namespace std;

namespace BaseLib
{

/*class ProcessDetails
{
public:
	enum Priority
	{
		IdlePriority = 0,
		LowestPriority,
		LowPriority,
		NormalPriority,
		HighPriority,
		HighestPriority,
		TimeCriticalPriority,
		InheritPriority
	};

	enum State
	{
		NoState = 0,
		RunState,
		StopState,
		CancelState,
		SystemEndState,
		PrintState,
		CheckState
	};

	friend std::ostream& operator<<(std::ostream& ostr, const ProcessDetails::State &status);

public:
	ProcessDetails()
		: processId_(-1)
		, processRunning_(false)
		, processPriority_(ProcessDetails::InheritPriority)
		, processState_(ProcessDetails::NoState)
	{ }
	~ProcessDetails()
	{ }

	pprocess_attr_t&			processAttributes() 		{ MutexLocker lock(&mutex_); return processAttributes_; }
	unsigned long int			processId()			const	{ MutexLocker lock(&mutex_); return processId_; }
	bool						processRunning()	const	{ MutexLocker lock(&mutex_); return processRunning_; }
	ProcessDetails::Priority 	processPriority()	const 	{ MutexLocker lock(&mutex_); return processPriority_; }
	ProcessDetails::State		processState()		const	{ MutexLocker lock(&mutex_); return processState_; }
	std::string					processName()		const 	{ MutexLocker lock(&mutex_); return processName_; }

	//void processAttributes(const pprocess_attr_t &attr)  	{ processAttributes_ = attr; }
	void processId(unsigned long int id)				{ MutexLocker lock(&mutex_); processId_ = id; }
	void processRunning(bool run)						{ MutexLocker lock(&mutex_); processRunning_ = run; }
	void processPriority(ProcessDetails::Priority p)	{ MutexLocker lock(&mutex_); processPriority_ = p; }
	void processState(ProcessDetails::State s)			{ MutexLocker lock(&mutex_); processState_ = s; }
	void processName(std::string name)					{ MutexLocker lock(&mutex_); processName_ = name; }

private:
	pprocess_attr_t 		processAttributes_;
	unsigned long int	processId_;
	bool				processRunning_;
	Priority			processPriority_;
	State				processState_;
	string				processName_;
	mutable Mutex		mutex_;
};*/

//-----------------------------------------------------------------------
//					class Process
//-----------------------------------------------------------------------
/*class Process
{
public:
	Process(std::string name = string(""));
	~Process();

	//static void* dispatch(void *process_obj);
	void start(ProcessDetails::Priority priority = ProcessDetails::InheritPriority);
	virtual void exit();
	virtual void terminate();

	bool 					isFinished() const;
	bool 					isRunning() const;
	ProcessDetails::Priority priority() const;
	std::string				processName() const;
	unsigned long int		processId() const;

	void 					setPriority(ProcessDetails::Priority priority);
	void					setProcessName(const std::string &name);

	ProcessDetails&			getProcessDetails()		{ return processDetails_; }

public:
	static Process*			currentProcess();
	static unsigned long 	currentProcessId();
	static bool				checkProcessState();
	static int				processId();

protected:
	ProcessDetails		processDetails_;
	mutable Mutex		processMutex_;
};
*/
}; // namespace BaseLib

//typedef boost::shared_ptr<Process> ProcessPtr;

#endif //PLANETLAB_SYSTEM_THREAD_KHV