VirtualBox

source: vbox/trunk/src/VBox/Main/include/ProgressImpl.h@ 8155

Last change on this file since 8155 was 8155, checked in by vboxsync, 17 years ago

The Big Sun Rebranding Header Change
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.8 KB
Line 
1/** @file
2 *
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22#ifndef ____H_PROGRESSIMPL
23#define ____H_PROGRESSIMPL
24
25#include "VirtualBoxBase.h"
26#include "Collection.h"
27
28#include <iprt/semaphore.h>
29
30#include <vector>
31
32class VirtualBox;
33
34////////////////////////////////////////////////////////////////////////////////
35
36class ATL_NO_VTABLE ProgressBase :
37 public VirtualBoxSupportErrorInfoImpl <ProgressBase, IProgress>,
38 public VirtualBoxSupportTranslation <ProgressBase>,
39 public VirtualBoxBase,
40 public IProgress
41{
42protected:
43
44 BEGIN_COM_MAP(ProgressBase)
45 COM_INTERFACE_ENTRY(ISupportErrorInfo)
46 COM_INTERFACE_ENTRY(IProgress)
47 END_COM_MAP()
48
49 HRESULT FinalConstruct();
50
51 // public initializer/uninitializer for internal purposes only
52 HRESULT protectedInit (
53#if !defined (VBOX_COM_INPROC)
54 VirtualBox *aParent,
55#endif
56 IUnknown *aInitiator,
57 const BSTR aDescription, GUIDPARAMOUT aId = NULL);
58 HRESULT protectedInit();
59 void protectedUninit (AutoWriteLock &alock);
60
61public:
62
63 // IProgress properties
64 STDMETHOD(COMGETTER(Id)) (GUIDPARAMOUT aId);
65 STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
66 STDMETHOD(COMGETTER(Initiator)) (IUnknown **aInitiator);
67
68 // IProgress properties
69 STDMETHOD(COMGETTER(Cancelable)) (BOOL *aCancelable);
70 STDMETHOD(COMGETTER(Percent)) (LONG *aPercent);
71 STDMETHOD(COMGETTER(Completed)) (BOOL *aCompleted);
72 STDMETHOD(COMGETTER(Canceled)) (BOOL *aCanceled);
73 STDMETHOD(COMGETTER(ResultCode)) (HRESULT *aResultCode);
74 STDMETHOD(COMGETTER(ErrorInfo)) (IVirtualBoxErrorInfo **aErrorInfo);
75 STDMETHOD(COMGETTER(OperationCount)) (ULONG *aOperationCount);
76 STDMETHOD(COMGETTER(Operation)) (ULONG *aCount);
77 STDMETHOD(COMGETTER(OperationDescription)) (BSTR *aOperationDescription);
78 STDMETHOD(COMGETTER(OperationPercent)) (LONG *aOperationPercent);
79
80 // public methods only for internal purposes
81
82 Guid id() { AutoWriteLock alock (this); return mId; }
83 BOOL completed() { AutoWriteLock alock (this); return mCompleted; }
84 HRESULT resultCode() { AutoWriteLock alock (this); return mResultCode; }
85
86 // for VirtualBoxSupportErrorInfoImpl
87 static const wchar_t *getComponentName() { return L"Progress"; }
88
89protected:
90
91#if !defined (VBOX_COM_INPROC)
92 /** weak parent */
93 ComObjPtr <VirtualBox, ComWeakRef> mParent;
94#endif
95 ComPtr <IUnknown> mInitiator;
96
97 Guid mId;
98 Bstr mDescription;
99
100 // the fields below are to be initalized by subclasses
101
102 BOOL mCompleted;
103 BOOL mCancelable;
104 BOOL mCanceled;
105 HRESULT mResultCode;
106 ComPtr <IVirtualBoxErrorInfo> mErrorInfo;
107
108 ULONG mOperationCount;
109 ULONG mOperation;
110 Bstr mOperationDescription;
111 LONG mOperationPercent;
112};
113
114////////////////////////////////////////////////////////////////////////////////
115
116class ATL_NO_VTABLE Progress :
117 public VirtualBoxSupportTranslation <Progress>,
118 public ProgressBase
119{
120
121public:
122
123 VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(Progress)
124
125 DECLARE_NOT_AGGREGATABLE(Progress)
126
127 DECLARE_PROTECT_FINAL_CONSTRUCT()
128
129 BEGIN_COM_MAP(Progress)
130 COM_INTERFACE_ENTRY(ISupportErrorInfo)
131 COM_INTERFACE_ENTRY(IProgress)
132 END_COM_MAP()
133
134 NS_DECL_ISUPPORTS
135
136 HRESULT FinalConstruct();
137 void FinalRelease();
138
139 // public initializer/uninitializer for internal purposes only
140
141 HRESULT init (
142#if !defined (VBOX_COM_INPROC)
143 VirtualBox *aParent,
144#endif
145 IUnknown *aInitiator,
146 const BSTR aDescription, BOOL aCancelable,
147 GUIDPARAMOUT aId = NULL)
148 {
149 return init (
150#if !defined (VBOX_COM_INPROC)
151 aParent,
152#endif
153 aInitiator, aDescription, aCancelable, 1, aDescription, aId);
154 }
155
156 HRESULT init (
157#if !defined (VBOX_COM_INPROC)
158 VirtualBox *aParent,
159#endif
160 IUnknown *aInitiator,
161 const BSTR aDescription, BOOL aCancelable,
162 ULONG aOperationCount, const BSTR aOperationDescription,
163 GUIDPARAMOUT aId = NULL);
164
165 HRESULT init (BOOL aCancelable, ULONG aOperationCount,
166 const BSTR aOperationDescription);
167
168 void uninit();
169
170 // IProgress methods
171 STDMETHOD(WaitForCompletion) (LONG aTimeout);
172 STDMETHOD(WaitForOperationCompletion) (ULONG aOperation, LONG aTimeout);
173 STDMETHOD(Cancel)();
174
175 // public methods only for internal purposes
176
177 HRESULT notifyProgress (LONG aPercent);
178 HRESULT advanceOperation (const BSTR aOperationDescription);
179
180 HRESULT notifyComplete (HRESULT aResultCode);
181 HRESULT notifyComplete (HRESULT aResultCode, const GUID &aIID,
182 const Bstr &aComponent,
183 const char *aText, ...);
184 HRESULT notifyCompleteBstr (HRESULT aResultCode, const GUID &aIID,
185 const Bstr &aComponent, const Bstr &aText);
186
187private:
188
189 RTSEMEVENTMULTI mCompletedSem;
190 ULONG mWaitersCount;
191};
192
193////////////////////////////////////////////////////////////////////////////////
194
195/**
196 * The CombinedProgress class allows to combine several progress objects
197 * to a single progress component. This single progress component will treat
198 * all operations of individual progress objects as a single sequence of
199 * operations, that follow each other in the same order as progress objects are
200 * passed to the #init() method.
201 *
202 * Individual progress objects are sequentially combined so that this progress
203 * object:
204 *
205 * - is cancelable only if all progresses are cancelable.
206 * - is canceled once a progress that follows next to successfully completed
207 * ones reports it was canceled.
208 * - is completed successfully only after all progresses are completed
209 * successfully.
210 * - is completed unsuccessfully once a progress that follows next to
211 * successfully completed ones reports it was completed unsuccessfully;
212 * the result code and error info of the unsuccessful progress
213 * will be reported as the result code and error info of this progress.
214 * - returns N as the operation number, where N equals to the number of
215 * operations in all successfully completed progresses starting from the
216 * first one plus the operation number of the next (not yet complete)
217 * progress; the operation description of the latter one is reported as
218 * the operation description of this progress object.
219 * - returns P as the percent value, where P equals to the sum of percents
220 * of all successfully completed progresses starting from the
221 * first one plus the percent value of the next (not yet complete)
222 * progress, normalized to 100%.
223 *
224 * @note
225 * It's the respoisibility of the combined progress object creator
226 * to complete individual progresses in the right order: if, let's say,
227 * the last progress is completed before all previous ones,
228 * #WaitForCompletion(-1) will most likely give 100% CPU load because it
229 * will be in a loop calling a method that returns immediately.
230 */
231class ATL_NO_VTABLE CombinedProgress :
232 public VirtualBoxSupportTranslation <CombinedProgress>,
233 public ProgressBase
234{
235
236public:
237
238 VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(CombinedProgress)
239
240 DECLARE_NOT_AGGREGATABLE(CombinedProgress)
241
242 DECLARE_PROTECT_FINAL_CONSTRUCT()
243
244 BEGIN_COM_MAP(CombinedProgress)
245 COM_INTERFACE_ENTRY(ISupportErrorInfo)
246 COM_INTERFACE_ENTRY(IProgress)
247 END_COM_MAP()
248
249 NS_DECL_ISUPPORTS
250
251 HRESULT FinalConstruct();
252 void FinalRelease();
253
254 // public initializer/uninitializer for internal purposes only
255
256 HRESULT init (
257#if !defined (VBOX_COM_INPROC)
258 VirtualBox *aParent,
259#endif
260 IUnknown *aInitiator,
261 const BSTR aDescription,
262 IProgress *aProgress1, IProgress *aProgress2,
263 GUIDPARAMOUT aId = NULL)
264 {
265 AutoWriteLock alock (this);
266 ComAssertRet (!isReady(), E_UNEXPECTED);
267
268 mProgresses.resize (2);
269 mProgresses [0] = aProgress1;
270 mProgresses [1] = aProgress2;
271
272 return protectedInit (
273#if !defined (VBOX_COM_INPROC)
274 aParent,
275#endif
276 aInitiator, aDescription, aId);
277 }
278
279 template <typename InputIterator>
280 HRESULT init (
281#if !defined (VBOX_COM_INPROC)
282 VirtualBox *aParent,
283#endif
284 IUnknown *aInitiator,
285 const BSTR aDescription,
286 InputIterator aFirstProgress, InputIterator aLastProgress,
287 GUIDPARAMOUT aId = NULL)
288 {
289 AutoWriteLock alock (this);
290 ComAssertRet (!isReady(), E_UNEXPECTED);
291
292 mProgresses = ProgressVector (aFirstProgress, aLastProgress);
293
294 return protectedInit (
295#if !defined (VBOX_COM_INPROC)
296 aParent,
297#endif
298 aInitiator, aDescription, aId);
299 }
300
301protected:
302
303 HRESULT protectedInit (
304#if !defined (VBOX_COM_INPROC)
305 VirtualBox *aParent,
306#endif
307 IUnknown *aInitiator,
308 const BSTR aDescription, GUIDPARAMOUT aId);
309
310public:
311
312 void uninit();
313
314 // IProgress properties
315 STDMETHOD(COMGETTER(Percent)) (LONG *aPercent);
316 STDMETHOD(COMGETTER(Completed)) (BOOL *aCompleted);
317 STDMETHOD(COMGETTER(Canceled)) (BOOL *aCanceled);
318 STDMETHOD(COMGETTER(ResultCode)) (HRESULT *aResultCode);
319 STDMETHOD(COMGETTER(ErrorInfo)) (IVirtualBoxErrorInfo **aErrorInfo);
320 STDMETHOD(COMGETTER(Operation)) (ULONG *aCount);
321 STDMETHOD(COMGETTER(OperationDescription)) (BSTR *aOperationDescription);
322 STDMETHOD(COMGETTER(OperationPercent)) (LONG *aOperationPercent);
323
324 // IProgress methods
325 STDMETHOD(WaitForCompletion) (LONG aTimeout);
326 STDMETHOD(WaitForOperationCompletion) (ULONG aOperation, LONG aTimeout);
327 STDMETHOD(Cancel)();
328
329 // public methods only for internal purposes
330
331private:
332
333 HRESULT checkProgress();
334
335 typedef std::vector <ComPtr <IProgress> > ProgressVector;
336 ProgressVector mProgresses;
337
338 size_t mProgress;
339 ULONG mCompletedOperations;
340};
341
342COM_DECL_READONLY_ENUM_AND_COLLECTION_AS (Progress, IProgress)
343
344#endif // ____H_PROGRESSIMPL
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette