Mercurial > projects > dwt-addons

comparison dwtx/core/internal/jobs/InternalJob.d @ 122:9d0585bcb7aa

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add core.jobs package
author Frank Benoit <benoit@tionex.de>
date Tue, 12 Aug 2008 02:34:21 +0200
parents
children 862b05e0334a
comparison
equal deleted inserted replaced
121:c0304616ea23 122:9d0585bcb7aa
1 /*******************************************************************************
2 * Copyright (c) 2003, 2007 IBM Corporation and others.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
7 *
8 * Contributors:
9 * IBM - Initial API and implementation
10 * Port to the D programming language:
11 * Frank Benoit <benoit@tionex.de>
12 *******************************************************************************/
13 module dwtx.core.internal.jobs.InternalJob;
14
15 import dwt.dwthelper.utils;
16 import dwtx.dwtxhelper.Collection;
17
18 import dwtx.core.runtime.Assert;
19 import dwtx.core.runtime.IProgressMonitor;
20 import dwtx.core.runtime.IStatus;
21 import dwtx.core.runtime.ListenerList;
22 import dwtx.core.runtime.PlatformObject;
23 import dwtx.core.runtime.QualifiedName;
24 import dwtx.core.runtime.jobs.IJobChangeListener;
25 import dwtx.core.runtime.jobs.ISchedulingRule;
26 import dwtx.core.runtime.jobs.Job;
27 import dwtx.core.runtime.jobs.MultiRule;
28
29 import dwtx.core.internal.jobs.JobManager;
30 import dwtx.core.internal.jobs.ObjectMap;
31
32 import tango.core.Thread;
33 import tango.text.convert.Format;
34
35 /**
36 * Internal implementation class for jobs. Clients must not implement this class
37 * directly. All jobs must be subclasses of the API <code>dwtx.core.runtime.jobs.Job</code> class.
38 */
39 public abstract class InternalJob : PlatformObject, Comparable {
40 /**
41 * Job state code (value 16) indicating that a job has been removed from
42 * the wait queue and is about to start running. From an API point of view,
43 * this is the same as RUNNING.
44 */
45 static const int ABOUT_TO_RUN = 0x10;
46
47 /**
48 * Job state code (value 32) indicating that a job has passed scheduling
49 * precondition checks and is about to be added to the wait queue. From an API point of view,
50 * this is the same as WAITING.
51 */
52 static const int ABOUT_TO_SCHEDULE = 0x20;
53 /**
54 * Job state code (value 8) indicating that a job is blocked by another currently
55 * running job. From an API point of view, this is the same as WAITING.
56 */
57 static const int BLOCKED = 0x08;
58
59 //flag mask bits
60 private static const int M_STATE = 0xFF;
61 private static const int M_SYSTEM = 0x0100;
62 private static const int M_USER = 0x0200;
63
64 /*
65 * flag on a job indicating that it was about to run, but has been canceled
66 */
67 private static const int M_ABOUT_TO_RUN_CANCELED = 0x0400;
68
69 private static JobManager manager_;
70 protected static JobManager manager(){
71 if( manager_ is null ){
72 synchronized( InternalJob.classinfo ){
73 if( manager_ is null ){
74 manager_ = JobManager.getInstance();
75 }
76 }
77 }
78 return manager_;
79 }
80 private static int nextJobNumber = 0;
81
82 /**
83 * Start time constant indicating a job should be started at
84 * a time in the infinite future, causing it to sleep forever.
85 */
86 static const long T_INFINITE = Long.MAX_VALUE;
87 /**
88 * Start time constant indicating that the job has no start time.
89 */
90 static const long T_NONE = -1;
91
92 private /+volatile+/ int flags = Job.NONE;
93 private const int jobNumber;
94 private ListenerList listeners = null;
95 private IProgressMonitor monitor;
96 private String name;
97 /**
98 * The job ahead of me in a queue or list.
99 */
100 private InternalJob next_;
101 /**
102 * The job behind me in a queue or list.
103 */
104 private InternalJob previous_;
105 private int priority = Job.LONG;
106 /**
107 * Arbitrary properties (key,value) pairs, attached
108 * to a job instance by a third party.
109 */
110 private ObjectMap properties;
111 private IStatus result;
112 private ISchedulingRule schedulingRule;
113 /**
114 * If the job is waiting, this represents the time the job should start by.
115 * If this job is sleeping, this represents the time the job should wake up.
116 * If this job is running, this represents the delay automatic rescheduling,
117 * or -1 if the job should not be rescheduled.
118 */
119 private long startTime;
120
121 /**
122 * Stamp added when a job is added to the wait queue. Used to ensure
123 * jobs in the wait queue maintain their insertion order even if they are
124 * removed from the wait queue temporarily while blocked
125 */
126 private long waitQueueStamp = T_NONE;
127
128 /*
129 * The thread that is currently running this job
130 */
131 private /+volatile+/ Thread thread = null;
132
133 protected this(String name) {
134 Assert.isNotNull(name);
135 jobNumber = nextJobNumber++;
136 this.name = name;
137 }
138
139 /* (non-Javadoc)
140 * @see Job#addJobListener(IJobChangeListener)
141 */
142 protected void addJobChangeListener(IJobChangeListener listener) {
143 if (listeners is null)
144 listeners = new ListenerList(ListenerList.IDENTITY);
145 listeners.add(cast(Object)listener);
146 }
147 package void addJobChangeListener_package(IJobChangeListener listener) {
148 addJobChangeListener(listener);
149 }
150
151 /**
152 * Adds an entry at the end of the list of which this item is the head.
153 */
154 final void addLast(InternalJob entry) {
155 InternalJob last = this;
156 //find the end of the queue
157 while (last.previous_ !is null)
158 last = last.previous_;
159 //add the new entry to the end of the queue
160 last.previous_ = entry;
161 entry.next_ = last;
162 entry.previous_ = null;
163 }
164
165 /* (non-Javadoc)
166 * @see Job#belongsTo(Object)
167 */
168 protected bool belongsTo(Object family) {
169 return false;
170 }
171 package bool belongsTo_package(Object family) {
172 return belongsTo(family);
173 }
174
175 /* (non-Javadoc)
176 * @see Job#cancel()
177 */
178 protected package bool cancel() {
179 return manager.cancel_package(this);
180 }
181
182 /* (non-Javadoc)
183 * @see Job#canceling()
184 */
185 protected package void canceling() {
186 //default implementation does nothing
187 }
188
189 /* (on-Javadoc)
190 * @see java.lang.Comparable#compareTo(java.lang.Object)
191 */
192 public final int compareTo(Object otherJob) {
193 return (cast(InternalJob) otherJob).startTime >= startTime ? 1 : -1;
194 }
195
196 /* (non-Javadoc)
197 * @see Job#done(IStatus)
198 */
199 protected void done(IStatus endResult) {
200 manager.endJob_package(this, endResult, true);
201 }
202
203 /**
204 * Returns the job listeners that are only listening to this job. Returns
205 * <code>null</code> if this job has no listeners.
206 */
207 final ListenerList getListeners() {
208 return listeners;
209 }
210
211 /* (non-Javadoc)
212 * @see Job#getName()
213 */
214 protected String getName() {
215 return name;
216 }
217 package String getName_package() {
218 return name;
219 }
220
221 /* (non-Javadoc)
222 * @see Job#getPriority()
223 */
224 protected package int getPriority() {
225 return priority;
226 }
227
228 /**
229 * Returns the job's progress monitor, or null if it is not running.
230 */
231 final IProgressMonitor getProgressMonitor() {
232 return monitor;
233 }
234
235 /* (non-Javadoc)
236 * @see Job#getProperty
237 */
238 protected Object getProperty(QualifiedName key) {
239 // thread safety: (Concurrency001 - copy on write)
240 Map temp = properties;
241 if (temp is null)
242 return null;
243 return temp.get(key);
244 }
245
246 /* (non-Javadoc)
247 * @see Job#getResult
248 */
249 protected IStatus getResult() {
250 return result;
251 }
252
253 /* (non-Javadoc)
254 * @see Job#getRule
255 */
256 protected package ISchedulingRule getRule() {
257 return schedulingRule;
258 }
259 package ISchedulingRule getRule_package() {
260 return getRule();
261 }
262
263 /**
264 * Returns the time that this job should be started, awakened, or
265 * rescheduled, depending on the current state.
266 * @return time in milliseconds
267 */
268 final long getStartTime() {
269 return startTime;
270 }
271
272 /* (non-Javadoc)
273 * @see Job#getState()
274 */
275 protected int getState() {
276 int state = flags & M_STATE;
277 switch (state) {
278 //blocked state is equivalent to waiting state for clients
279 case BLOCKED :
280 return Job.WAITING;
281 case ABOUT_TO_RUN :
282 return Job.RUNNING;
283 case ABOUT_TO_SCHEDULE :
284 return Job.WAITING;
285 default :
286 return state;
287 }
288 }
289 package int getState_package() {
290 return getState();
291 }
292
293 /* (non-javadoc)
294 * @see Job.getThread
295 */
296 protected Thread getThread() {
297 return thread;
298 }
299 package Thread getThread_package() {
300 return getThread();
301 }
302
303 /**
304 * Returns the raw job state, including internal states no exposed as API.
305 */
306 final int internalGetState() {
307 return flags & M_STATE;
308 }
309
310 /**
311 * Must be called from JobManager#setPriority
312 */
313 final void internalSetPriority(int newPriority) {
314 this.priority = newPriority;
315 }
316
317 /**
318 * Must be called from JobManager#setRule
319 */
320 final void internalSetRule(ISchedulingRule rule) {
321 this.schedulingRule = rule;
322 }
323
324 /**
325 * Must be called from JobManager#changeState
326 */
327 final void internalSetState(int i) {
328 flags = (flags & ~M_STATE) | i;
329 }
330
331 /**
332 * Returns whether this job was canceled when it was about to run
333 */
334 final bool isAboutToRunCanceled() {
335 return (flags & M_ABOUT_TO_RUN_CANCELED) !is 0;
336 }
337
338 /* (non-Javadoc)
339 * @see Job#isBlocking()
340 */
341 protected bool isBlocking() {
342 return manager.isBlocking_package(this);
343 }
344
345 /**
346 * Returns true if this job conflicts with the given job, and false otherwise.
347 */
348 final bool isConflicting(InternalJob otherJob) {
349 ISchedulingRule otherRule = otherJob.getRule();
350 if (schedulingRule is null || otherRule is null)
351 return false;
352 //if one of the rules is a compound rule, it must be asked the question.
353 if (schedulingRule.classinfo is MultiRule.classinfo)
354 return schedulingRule.isConflicting(otherRule);
355 return otherRule.isConflicting(schedulingRule);
356 }
357
358 /* (non-javadoc)
359 * @see Job.isSystem()
360 */
361 protected bool isSystem() {
362 return (flags & M_SYSTEM) !is 0;
363 }
364 package bool isSystem_package() {
365 return isSystem();
366 }
367
368 /* (non-javadoc)
369 * @see Job.isUser()
370 */
371 protected bool isUser() {
372 return (flags & M_USER) !is 0;
373 }
374
375 /* (non-Javadoc)
376 * @see Job#join()
377 */
378 protected void join() {
379 manager.join_package(this);
380 }
381
382 /**
383 * Returns the next_ entry (ahead of this one) in the list, or null if there is no next_ entry
384 */
385 final InternalJob next() {
386 return next_;
387 }
388
389 /**
390 * Returns the previous_ entry (behind this one) in the list, or null if there is no previous_ entry
391 */
392 final InternalJob previous() {
393 return previous_;
394 }
395
396 /**
397 * Removes this entry from any list it belongs to. Returns the receiver.
398 */
399 final InternalJob remove() {
400 if (next_ !is null)
401 next_.setPrevious(previous_);
402 if (previous_ !is null)
403 previous_.setNext(next_);
404 next_ = previous_ = null;
405 return this;
406 }
407
408 /* (non-Javadoc)
409 * @see Job#removeJobListener(IJobChangeListener)
410 */
411 protected void removeJobChangeListener(IJobChangeListener listener) {
412 if (listeners !is null)
413 listeners.remove(cast(Object)listener);
414 }
415 package void removeJobChangeListener_package(IJobChangeListener listener) {
416 removeJobChangeListener(listener);
417 }
418
419 /* (non-Javadoc)
420 * @see Job#run(IProgressMonitor)
421 */
422 protected abstract IStatus run(IProgressMonitor progressMonitor);
423 package IStatus run_package(IProgressMonitor progressMonitor){
424 return run(progressMonitor);
425 }
426
427 /* (non-Javadoc)
428 * @see Job#schedule(long)
429 */
430 protected void schedule(long delay) {
431 if (shouldSchedule())
432 manager.schedule_package(this, delay, false);
433 }
434 package void schedule_package(long delay) {
435 schedule(delay);
436 }
437
438 /**
439 * Sets whether this job was canceled when it was about to run
440 */
441 final void setAboutToRunCanceled(bool value) {
442 flags = value ? flags | M_ABOUT_TO_RUN_CANCELED : flags & ~M_ABOUT_TO_RUN_CANCELED;
443
444 }
445
446 /* (non-Javadoc)
447 * @see Job#setName(String)
448 */
449 protected void setName(String name) {
450 Assert.isNotNull(name);
451 this.name = name;
452 }
453
454 /**
455 * Sets the next_ entry in this linked list of jobs.
456 * @param entry
457 */
458 final void setNext(InternalJob entry) {
459 this.next_ = entry;
460 }
461
462 /**
463 * Sets the previous_ entry in this linked list of jobs.
464 * @param entry
465 */
466 final void setPrevious(InternalJob entry) {
467 this.previous_ = entry;
468 }
469
470 /* (non-Javadoc)
471 * @see Job#setPriority(int)
472 */
473 protected void setPriority(int newPriority) {
474 switch (newPriority) {
475 case Job.INTERACTIVE :
476 case Job.SHORT :
477 case Job.LONG :
478 case Job.BUILD :
479 case Job.DECORATE :
480 manager.setPriority_package(this, newPriority);
481 break;
482 default :
483 throw new IllegalArgumentException(Integer.toString(newPriority));
484 }
485 }
486
487 /* (non-Javadoc)
488 * @see Job#setProgressGroup(IProgressMonitor, int)
489 */
490 protected void setProgressGroup(IProgressMonitor group, int ticks) {
491 Assert.isNotNull(cast(Object)group);
492 IProgressMonitor pm = manager.createMonitor_package(this, group, ticks);
493 if (pm !is null)
494 setProgressMonitor(pm);
495 }
496
497 /**
498 * Sets the progress monitor to use for the next_ execution of this job,
499 * or for clearing the monitor when a job completes.
500 * @param monitor a progress monitor
501 */
502 final void setProgressMonitor(IProgressMonitor monitor) {
503 this.monitor = monitor;
504 }
505
506 /* (non-Javadoc)
507 * @see Job#setProperty(QualifiedName,Object)
508 */
509 protected void setProperty(QualifiedName key, Object value) {
510 // thread safety: (Concurrency001 - copy on write)
511 if (value is null) {
512 if (properties is null)
513 return;
514 ObjectMap temp = cast(ObjectMap) properties.clone();
515 temp.remove(key);
516 if (temp.isEmpty())
517 properties = null;
518 else
519 properties = temp;
520 } else {
521 ObjectMap temp = properties;
522 if (temp is null)
523 temp = new ObjectMap(5);
524 else
525 temp = cast(ObjectMap) properties.clone();
526 temp.put(key, value);
527 properties = temp;
528 }
529 }
530
531 /**
532 * Sets or clears the result of an execution of this job.
533 * @param result a result status, or <code>null</code>
534 */
535 final void setResult(IStatus result) {
536 this.result = result;
537 }
538
539 /* (non-Javadoc)
540 * @see Job#setRule(ISchedulingRule)
541 */
542 protected void setRule(ISchedulingRule rule) {
543 manager.setRule(this, rule);
544 }
545
546 /**
547 * Sets a time to start, wake up, or schedule this job,
548 * depending on the current state
549 * @param time a time in milliseconds
550 */
551 final void setStartTime(long time) {
552 startTime = time;
553 }
554
555 /* (non-javadoc)
556 * @see Job.setSystem
557 */
558 protected void setSystem(bool value) {
559 if (getState() !is Job.NONE)
560 throw new IllegalStateException();
561 flags = value ? flags | M_SYSTEM : flags & ~M_SYSTEM;
562 }
563
564 /* (non-javadoc)
565 * @see Job.setThread
566 */
567 protected void setThread(Thread thread) {
568 this.thread = thread;
569 }
570 package void setThread_package(Thread thread) {
571 setThread(thread);
572 }
573
574 /* (non-javadoc)
575 * @see Job.setUser
576 */
577 protected void setUser(bool value) {
578 if (getState() !is Job.NONE)
579 throw new IllegalStateException();
580 flags = value ? flags | M_USER : flags & ~M_USER;
581 }
582
583 /* (Non-javadoc)
584 * @see Job#shouldSchedule
585 */
586 protected bool shouldSchedule() {
587 return true;
588 }
589 package bool shouldSchedule_package() {
590 return shouldSchedule();
591 }
592
593 /* (non-Javadoc)
594 * @see Job#sleep()
595 */
596 protected bool sleep() {
597 return manager.sleep_package(this);
598 }
599
600 /* (non-Javadoc)
601 * Prints a string-based representation of this job instance.
602 * For debugging purposes only.
603 */
604 public String toString() {
605 return Format( "{}({})", getName(), jobNumber ); //$NON-NLS-1$//$NON-NLS-2$
606 }
607
608 /* (non-Javadoc)
609 * @see Job#wakeUp(long)
610 */
611 protected void wakeUp(long delay) {
612 manager.wakeUp_package(this, delay);
613 }
614
615 /**
616 * @param waitQueueStamp The waitQueueStamp to set.
617 */
618 void setWaitQueueStamp(long waitQueueStamp) {
619 this.waitQueueStamp = waitQueueStamp;
620 }
621
622 /**
623 * @return Returns the waitQueueStamp.
624 */
625 long getWaitQueueStamp() {
626 return waitQueueStamp;
627 }
628 }