org.eclipse.platform/org.eclipse.core.jobs/3.10.600

http://www.eclipse.org/platform: Eclipse Jobs Mechanism (Eclipse Foundation)

Eclipse Public License - v 2.0

directory

Dependencies

java/11
org.eclipse.platform/org.eclipse.equinox.common/3.14.100

directory

Declarations

org
- eclipse
  - core
    - internal
      - jobs
        
        Counter
        
        value: long
        
        Counter(): void
        
        increment(): long
        
        Deadlock
        
        threads: Thread[]
        
        candidate: Thread
        
        locks: ISchedulingRule[]
        
        Deadlock(Thread[], ISchedulingRule[], Thread): void
        
        getLocks(): ISchedulingRule[]
        
        getCandidate(): Thread
        
        getThreads(): Thread[]
        
        DeadlockDetector
        
        NO_STATE: int
        
        WAITING_FOR_LOCK: int
        
        EMPTY_MATRIX: int[][]
        
        graph: int[][]
        
        locks: ArrayList<ISchedulingRule>
        
        lockThreads: ArrayList<Thread>
        
        resize: boolean
        
        addCycleThreads(ArrayList<Thread>, Thread): boolean
        
        blockingThreads(Thread): Thread[]
        
        checkWaitCycles(int[], int): boolean
        
        contains(Thread): boolean
        
        fillPresentEntries(ISchedulingRule, int): void
        
        getOwnedLocks(Thread): Object[]
        
        getThreadsInDeadlock(Thread): Thread[]
        
        getThreadsOwningLock(ISchedulingRule): Thread[]
        
        getWaitingLock(Thread): Object
        
        indexOf(ISchedulingRule, boolean): int
        
        indexOf(Thread, boolean): int
        
        isEmpty(): boolean
        
        lockAcquired(Thread, ISchedulingRule): void
        
        lockReleased(Thread, ISchedulingRule): void
        
        lockReleasedCompletely(Thread, ISchedulingRule): void
        
        lockWaitStart(Thread, ISchedulingRule): Deadlock
        
        lockWaitStop(Thread, ISchedulingRule): void
        
        ownsLocks(Thread): boolean
        
        ownsRealLocks(Thread): boolean
        
        ownsRuleLocks(Thread): boolean
        
        realLocksForThread(Thread): ISchedulingRule[]
        
        reduceGraph(int, ISchedulingRule): void
        
        reportDeadlock(Deadlock): void
        
        resizeGraph(): void
        
        resolutionCandidate(Thread[]): Thread
        
        setToWait(Thread, ISchedulingRule, boolean): void
        
        toDebugString(): String
        
        ImplicitJobs
        
        jobCache: ThreadJob
        
        manager: JobManager
        
        suspendedRules: Set<ISchedulingRule>
        
        threadJobs: Map<Thread, ThreadJob>
        
        ImplicitJobs(JobManager): void
        
        begin(ISchedulingRule, IProgressMonitor, boolean): void
        
        end(ISchedulingRule, boolean): void
        
        endJob(InternalJob): void
        
        endThreadJob(ThreadJob, boolean): void
        
        isSuspended(ISchedulingRule): boolean
        
        newThreadJob(ISchedulingRule): ThreadJob
        
        notifyWaitingThreadJobs(InternalJob): void
        
        recycle(ThreadJob): void
        
        resume(ISchedulingRule): void
        
        suspend(ISchedulingRule, IProgressMonitor): void
        
        transfer(ISchedulingRule, Thread): void
        
        removeWaiting(ThreadJob): void
        
        addWaiting(ThreadJob): void
        
        getThreadJob(Thread): ThreadJob
        
        InternalJob
        
        getNextJobNumber(): int
        
        ABOUT_TO_RUN: int
        
        ABOUT_TO_SCHEDULE: int
        
        BLOCKED: int
        
        YIELDING: int
        
        M_STATE: int
        
        M_SYSTEM: int
        
        M_USER: int
        
        M_ABOUT_TO_RUN_CANCELED: int
        
        M_RUN_CANCELED: int
        
        nextJobNumber: int
        
        manager: JobManager
        
        T_INFINITE: long
        
        T_NONE: long
        
        flags: int
        
        jobNumber: int
        
        listeners: ListenerList<IJobChangeListener>
        
        monitor: IProgressMonitor
        
        name: String
        
        jobGroup: JobGroup
        
        next: InternalJob
        
        previous: InternalJob
        
        priority: int
        
        properties: ObjectMap
        
        result: IStatus
        
        schedulingRule: ISchedulingRule
        
        startTime: long
        
        waitQueueStamp: long
        
        thread: Thread
        
        jobStateLock: Object
        
        InternalJob(String): void
        
        addJobChangeListener(IJobChangeListener): void
        
        addLast(InternalJob): void
        
        belongsTo(Object): boolean
        
        cancel(): boolean
        
        canceling(): void
        
        compareTo(Object): int
        
        done(IStatus): void
        
        getListeners(): ListenerList<IJobChangeListener>
        
        getName(): String
        
        getPriority(): int
        
        getProgressMonitor(): IProgressMonitor
        
        getProperty(QualifiedName): Object
        
        getResult(): IStatus
        
        getRule(): ISchedulingRule
        
        getStartTime(): long
        
        getState(): int
        
        getThread(): Thread
        
        getJobGroup(): JobGroup
        
        internalGetState(): int
        
        internalSetPriority(int): void
        
        internalSetRule(ISchedulingRule): void
        
        internalSetState(int): void
        
        isAboutToRunCanceled(): boolean
        
        isRunCanceled(): boolean
        
        isBlocking(): boolean
        
        isConflicting(InternalJob): boolean
        
        isSystem(): boolean
        
        isUser(): boolean
        
        join(): void
        
        join(long, IProgressMonitor): boolean
        
        next(): InternalJob
        
        previous(): InternalJob
        
        remove(): InternalJob
        
        removeJobChangeListener(IJobChangeListener): void
        
        run(IProgressMonitor): IStatus
        
        schedule(long): void
        
        setAboutToRunCanceled(boolean): void
        
        setRunCanceled(boolean): void
        
        setName(String): void
        
        setNext(InternalJob): void
        
        setPrevious(InternalJob): void
        
        setPriority(int): void
        
        setProgressGroup(IProgressMonitor, int): void
        
        setProgressMonitor(IProgressMonitor): void
        
        setProperty(QualifiedName, Object): void
        
        setResult(IStatus): void
        
        setRule(ISchedulingRule): void
        
        setStartTime(long): void
        
        setSystem(boolean): void
        
        setThread(Thread): void
        
        setUser(boolean): void
        
        setJobGroup(JobGroup): void
        
        shouldSchedule(): boolean
        
        sleep(): boolean
        
        yieldRule(IProgressMonitor): Job
        
        toString(): String
        
        wakeUp(long): void
        
        setWaitQueueStamp(long): void
        
        getWaitQueueStamp(): long
        
        InternalJobGroup
        
        seedJobsRemainingCount: int
        
        MAX_WAIT_INTERVAL: long
        
        jobGroupStateLock: Object
        
        manager: JobManager
        
        name: String
        
        maxThreads: int
        
        state: int
        
        result: MultiStatus
        
        runningJobs: Set<InternalJob>
        
        otherActiveJobs: Set<InternalJob>
        
        results: List<IStatus>
        
        cancelingDueToError: boolean
        
        failedJobsCount: int
        
        canceledJobsCount: int
        
        seedJobsCount: int
        
        InternalJobGroup(String, int, int): void
        
        getName(): String
        
        getMaxThreads(): int
        
        getResult(): MultiStatus
        
        getState(): int
        
        getActiveJobs(): List<Job>
        
        cancel(): void
        
        join(long, IProgressMonitor): boolean
        
        jobStateChanged(InternalJob, int, int): void
        
        getGroupOfCurrentlyRunningJob(): JobGroup
        
        updateCancelingReason(boolean): void
        
        cancelAndNotify(boolean): void
        
        endJobGroup(MultiStatus): void
        
        internalGetActiveJobs(): List<Job>
        
        getSeedJobsRemainingCount(): int
        
        getActiveJobsCount(): int
        
        getRunningJobsCount(): int
        
        getFailedJobsCount(): int
        
        getCanceledJobsCount(): int
        
        getCompletedJobResults(): List<IStatus>
        
        shouldCancel(IStatus, int, int): boolean
        
        computeGroupResult(List<IStatus>): MultiStatus
        
        doJoin(long): boolean
        
        InternalWorker
        
        manager: JobManager
        
        canceled: boolean
        
        InternalWorker(JobManager): void
        
        run(): void
        
        cancel(): void
        
        JobActivator
        
        PROP_REGISTER_JOB_SERVICE: String
        
        registerServices(): void
        
        unregisterServices(): void
        
        JobChangeEvent
        
        reschedule: boolean
        
        job: Job
        
        result: IStatus
        
        jobGroupResult: IStatus
        
        delay: long
        
        getDelay(): long
        
        getJob(): Job
        
        getResult(): IStatus
        
        getJobGroupResult(): IStatus
        
        JobListeners
        
        IListenerDoit
        
        notify(IJobChangeListener, IJobChangeEvent): void
        
        aboutToRun: IListenerDoit
        
        awake: IListenerDoit
        
        done: IListenerDoit
        
        running: IListenerDoit
        
        scheduled: IListenerDoit
        
        sleeping: IListenerDoit
        
        global: ListenerList<IJobChangeListener>
        
        newEvent(Job): JobChangeEvent
        
        newEvent(Job, IStatus): JobChangeEvent
        
        newEvent(Job, long): JobChangeEvent
        
        doNotify(IListenerDoit, IJobChangeEvent): void
        
        handleException(IJobChangeListener, Throwable): void
        
        add(IJobChangeListener): void
        
        remove(IJobChangeListener): void
        
        aboutToRun(Job): void
        
        awake(Job): void
        
        done(Job, IStatus, boolean): void
        
        running(Job): void
        
        scheduled(Job, long, boolean): void
        
        sleeping(Job): void
        
        JobManager
        
        DEBUG: boolean
        
        PI_JOBS: String
        
        PLUGIN_ERROR: int
        
        MAX_WAIT_INTERVAL: long
        
        OPTION_DEADLOCK_ERROR: String
        
        OPTION_DEBUG_BEGIN_END: String
        
        OPTION_DEBUG_YIELDING: String
        
        OPTION_DEBUG_YIELDING_DETAILED: String
        
        OPTION_DEBUG_JOBS: String
        
        OPTION_LOCKS: String
        
        OPTION_SHUTDOWN: String
        
        DEBUG_BEGIN_END: boolean
        
        DEBUG_YIELDING: boolean
        
        DEBUG_YIELDING_DETAILED: boolean
        
        DEBUG_DEADLOCK: boolean
        
        DEBUG_LOCKS: boolean
        
        DEBUG_SHUTDOWN: boolean
        
        instance: JobManager
        
        nullRule: ISchedulingRule
        
        $1
        
        contains(ISchedulingRule): boolean
        
        isConflicting(ISchedulingRule): boolean
        
        active: boolean
        
        implicitJobs: ImplicitJobs
        
        jobListeners: JobListeners
        
        lock: Object
        
        jobGroupUpdater: IJobChangeListener
        
        lockManager: LockManager
        
        pool: WorkerPool
        
        progressProvider: ProgressProvider
        
        running: HashSet<InternalJob>
        
        yielding: HashSet<InternalJob>
        
        sleeping: JobQueue
        
        suspended: boolean
        
        waiting: JobQueue
        
        waitingThreadJobs: JobQueue
        
        waitQueueCounter: Counter
        
        monitorStack: List<Object[]>
        
        internalWorker: InternalWorker
        
        debug(String): void
        
        getInstance(): JobManager
        
        printJobName(Job): String
        
        printState(Job): String
        
        printState(int): String
        
        shutdown(): void
        
        JobManager(): void
        
        addJobChangeListener(IJobChangeListener): void
        
        beginRule(ISchedulingRule, IProgressMonitor): void
        
        cancel(InternalJob): boolean
        
        cancel(Object): void
        
        cancel(InternalJobGroup): void
        
        startJob(Worker): Job
        
        cancel(InternalJobGroup, boolean): void
        
        changeState(InternalJob, int): void
        
        createMonitor(InternalJob, IProgressMonitor, int): IProgressMonitor
        
        createMonitor(Job): IProgressMonitor
        
        createProgressGroup(): IProgressMonitor
        
        currentJob(): Job
        
        currentRule(): ISchedulingRule
        
        delayFor(int): long
        
        doSchedule(InternalJob, long): boolean
        
        doShutdown(): void
        
        endJob(InternalJob, IStatus, boolean): void
        
        endRule(ISchedulingRule): void
        
        find(Object): Job[]
        
        find(InternalJobGroup): List<Job>
        
        findBlockingJob(InternalJob): InternalJob
        
        findBlockedJob(InternalJob, Iterator): InternalJob
        
        dequeue(JobQueue, InternalJob): void
        
        enqueue(JobQueue, InternalJob): void
        
        getLockManager(): LockManager
        
        getWaitMessage(int): String
        
        isActive(): boolean
        
        isBlocking(InternalJob): boolean
        
        isIdle(): boolean
        
        isSuspended(): boolean
        
        join(InternalJob, long, IProgressMonitor): boolean
        
        $2
        
        done(IJobChangeEvent): void
        
        join(Object, IProgressMonitor): void
        
        $3
        
        done(IJobChangeEvent): void
        
        running(IJobChangeEvent): void
        
        scheduled(IJobChangeEvent): void
        
        join(InternalJobGroup, long, IProgressMonitor): boolean
        
        monitorFor(IProgressMonitor): IProgressMonitor
        
        newLock(): ILock
        
        nextJob(): Job
        
        removeJobChangeListener(IJobChangeListener): void
        
        reportBlocked(IProgressMonitor, InternalJob): void
        
        reportUnblocked(IProgressMonitor): void
        
        resume(): void
        
        resume(ISchedulingRule): void
        
        runNow(ThreadJob, boolean): InternalJob
        
        doRunNow(ThreadJob, boolean): InternalJob
        
        schedule(InternalJob, long, boolean): void
        
        select(List<InternalJob>, Object, InternalJob, int): void
        
        select(Object): List<InternalJob>
        
        select(Object, int): List<InternalJob>
        
        setLockListener(LockListener): void
        
        setPriority(InternalJob, int): void
        
        setProgressProvider(ProgressProvider): void
        
        setRule(InternalJob, ISchedulingRule): void
        
        sleep(InternalJob): boolean
        
        sleep(Object): void
        
        sleepHint(): long
        
        yieldRule(InternalJob, IProgressMonitor): Job
        
        $4
        
        isCanceled(): boolean
        
        $5
        
        isResumingAfterYield(): boolean
        
        waitForUnblocked(InternalJob): void
        
        shouldRun(Job): boolean
        
        suspend(): void
        
        suspend(ISchedulingRule, IProgressMonitor): void
        
        transferRule(ISchedulingRule, Thread): void
        
        validateRule(ISchedulingRule): void
        
        wakeUp(InternalJob, long): void
        
        wakeUp(Object): void
        
        endMonitoring(ThreadJob): void
        
        beginMonitoring(ThreadJob, IProgressMonitor): void
        
        JobGroupUpdater
        
        jobManagerLock: Object
        
        JobGroupUpdater(Object): void
        
        done(IJobChangeEvent): void
        
        JobMessages
        
        BUNDLE_NAME: String
        
        jobs_blocked0: String
        
        jobs_blocked1: String
        
        jobs_internalError: String
        
        jobs_waitFamSub: String
        
        jobs_waitFamSubOne: String
        
        jobs_returnNoStatus: String
        
        meta_pluginProblems: String
        
        static class initializer
        
        reloadMessages(): void
        
        message(String): void
        
        JobOSGiUtils
        
        singleton: JobOSGiUtils
        
        getDefault(): JobOSGiUtils
        
        JobOSGiUtils(): void
        
        openServices(): void
        
        closeServices(): void
        
        getBundleId(Object): String
        
        useDaemonThreads(): boolean
        
        JobQueue
        
        dummy: InternalJob
        
        allowConflictOvertaking: boolean
        
        allowPriorityOvertaking: boolean
        
        JobQueue(boolean): void
        
        JobQueue(boolean, boolean): void
        
        $1
        
        run(IProgressMonitor): IStatus
        
        clear(): void
        
        dequeue(): InternalJob
        
        enqueue(InternalJob): void
        
        canOvertake(InternalJob, InternalJob): boolean
        
        remove(InternalJob): void
        
        resort(InternalJob): void
        
        isEmpty(): boolean
        
        peek(): InternalJob
        
        iterator(): Iterator
        
        $2
        
        pointer: InternalJob
        
        hasNext(): boolean
        
        next(): Object
        
        remove(): void
        
        JobStatus
        
        job: Job
        
        JobStatus(int, Job, String): void
        
        getJob(): Job
        
        LockManager
        
        LockState
        
        depth: int
        
        lock: OrderedLock
        
        suspend(OrderedLock): LockState
        
        resume(): void
        
        lockListener: LockListener
        
        locks: DeadlockDetector
        
        suspendedLocks: HashMap<Thread, ArrayDeque<LockState[]>>
        
        aboutToRelease(): void
        
        canBlock(): boolean
        
        aboutToWait(Thread): boolean
        
        addLockThread(Thread, ISchedulingRule): void
        
        addLockWaitThread(Thread, ISchedulingRule): void
        
        Lambda implementing Function<Thread, ArrayDeque<LockState[]>>
        
        createDebugException(DeadlockDetector, Exception): Exception
        
        handleException(Throwable): void
        
        handleInternalError(Throwable): void
        
        isEmpty(): boolean
        
        isLockOwner(): boolean
        
        newLock(): OrderedLock
        
        removeLockCompletely(Thread, ISchedulingRule): void
        
        removeLockThread(Thread, ISchedulingRule): void
        
        removeLockWaitThread(Thread, ISchedulingRule): void
        
        resumeSuspendedLocks(Thread): void
        
        setLockListener(LockListener): void
        
        ObjectMap
        
        DEFAULT_SIZE: int
        
        GROW_SIZE: int
        
        count: int
        
        elements: Object[]
        
        ObjectMap(int): void
        
        ObjectMap(Map): void
        
        clear(): void
        
        clone(): Object
        
        containsKey(Object): boolean
        
        containsValue(Object): boolean
        
        entrySet(): Set
        
        equals(Object): boolean
        
        get(Object): Object
        
        grow(): void
        
        hashCode(): int
        
        isEmpty(): boolean
        
        keySet(): Set
        
        put(Object, Object): Object
        
        putAll(Map): void
        
        remove(Object): Object
        
        size(): int
        
        toHashMap(): HashMap<Object, Object>
        
        values(): Collection
        
        OrderedLock
        
        operations: Queue
        
        DEBUG: boolean
        
        nextLockNumber: int
        
        currentOperationThread: Thread
        
        depth: int
        
        manager: LockManager
        
        number: int
        
        OrderedLock(LockManager): void
        
        acquire(): void
        
        acquire(long): boolean
        
        attempt(): boolean
        
        contains(ISchedulingRule): boolean
        
        createSemaphore(): Semaphore
        
        doAcquire(Semaphore, long): boolean
        
        doRelease(): void
        
        enqueue(Semaphore): Semaphore
        
        forceRelease(): int
        
        getDepth(): int
        
        isConflicting(ISchedulingRule): boolean
        
        release(): void
        
        removeFromQueue(Semaphore): void
        
        setCurrentOperationThread(Thread): void
        
        setDepth(int): void
        
        toString(): String
        
        updateCurrentOperation(): void
        
        updateOperationQueue(Semaphore, boolean): boolean
        
        Queue
        
        elements: Object[]
        
        head: int
        
        reuse: boolean
        
        tail: int
        
        Queue(): void
        
        Queue(int, boolean): void
        
        enqueue(Object): void
        
        decrement(int): int
        
        elements(): Iterator
        
        get(Object): Object
        
        remove(Object): boolean
        
        grow(): void
        
        increment(int): int
        
        isEmpty(): boolean
        
        peek(): Object
        
        dequeue(): Object
        
        size(): int
        
        toString(): String
        
        Semaphore
        
        notifications: long
        
        runnable: Runnable
        
        Semaphore(Runnable): void
        
        acquire(long): boolean
        
        attempt(): boolean
        
        equals(Object): boolean
        
        hashCode(): int
        
        release(): void
        
        toString(): String
        
        ThreadJob
        
        acquireRule: boolean
        
        isBlocked: boolean
        
        isRunning: boolean
        
        lastPush: RuntimeException
        
        realJob: Job
        
        ruleStack: ISchedulingRule[]
        
        top: int
        
        isWaiting: boolean
        
        ThreadJob(ISchedulingRule): void
        
        isResumingAfterYield(): boolean
        
        illegalPop(ISchedulingRule): void
        
        illegalPush(ISchedulingRule, ISchedulingRule): void
        
        isCanceled(IProgressMonitor): boolean
        
        isRunning(): boolean
        
        joinRun(ThreadJob, IProgressMonitor): ThreadJob
        
        waitForRun(ThreadJob, IProgressMonitor, InternalJob): ThreadJob
        
        pop(ISchedulingRule): boolean
        
        push(ISchedulingRule): void
        
        recycle(): boolean
        
        run(IProgressMonitor): IStatus
        
        setRealJob(Job): void
        
        shouldInterrupt(): boolean
        
        toString(): String
        
        getRuleStack(): String
        
        waitEnd(ThreadJob, boolean, IProgressMonitor): void
        
        waitStart(ThreadJob, IProgressMonitor, InternalJob): void
        
        shouldSchedule(): boolean
        
        Worker
        
        nextWorkerNumber: int
        
        currentJob: InternalJob
        
        pool: WorkerPool
        
        generalName: String
        
        Worker(WorkerPool): void
        
        currentJob(): Job
        
        handleException(InternalJob, Throwable): IStatus
        
        run(): void
        
        getJobName(): String
        
        WorkerPool
        
        BEST_BEFORE: int
        
        MIN_THREADS: int
        
        MAX_THREADS: int
        
        busyThreads: int
        
        defaultContextLoader: ClassLoader
        
        isDaemon: boolean
        
        manager: JobManager
        
        numThreads: int
        
        sleepingThreads: int
        
        threads: Worker[]
        
        WorkerPool(JobManager): void
        
        add(Worker): void
        
        decrementBusyThreads(): void
        
        endJob(InternalJob, IStatus): void
        
        endWorker(Worker): void
        
        incrementBusyThreads(): void
        
        jobQueued(): void
        
        remove(Worker): boolean
        
        setDaemon(boolean): void
        
        shutdown(): void
        
        sleep(long): void
        
        startJob(Worker): InternalJob
    - runtime
      - jobs
        
        IJobChangeEvent
        
        getDelay(): long
        
        getJob(): Job
        
        getResult(): IStatus
        
        getJobGroupResult(): IStatus
        
        IJobChangeListener
        
        aboutToRun(IJobChangeEvent): void
        
        awake(IJobChangeEvent): void
        
        done(IJobChangeEvent): void
        
        running(IJobChangeEvent): void
        
        scheduled(IJobChangeEvent): void
        
        sleeping(IJobChangeEvent): void
        
        IJobFunction
        
        run(IProgressMonitor): IStatus
        
        IJobManager
        
        PROP_USE_DAEMON_THREADS: String
        
        addJobChangeListener(IJobChangeListener): void
        
        beginRule(ISchedulingRule, IProgressMonitor): void
        
        cancel(Object): void
        
        createProgressGroup(): IProgressMonitor
        
        currentRule(): ISchedulingRule
        
        currentJob(): Job
        
        endRule(ISchedulingRule): void
        
        find(Object): Job[]
        
        isIdle(): boolean
        
        isSuspended(): boolean
        
        join(Object, IProgressMonitor): void
        
        newLock(): ILock
        
        removeJobChangeListener(IJobChangeListener): void
        
        resume(ISchedulingRule): void
        
        resume(): void
        
        setLockListener(LockListener): void
        
        setProgressProvider(ProgressProvider): void
        
        suspend(): void
        
        suspend(ISchedulingRule, IProgressMonitor): void
        
        sleep(Object): void
        
        transferRule(ISchedulingRule, Thread): void
        
        wakeUp(Object): void
        
        IJobStatus
        
        getJob(): Job
        
        ILock
        
        getDepth(): int
        
        release(): void
        
        acquire(long): boolean
        
        acquire(): void
        
        ISchedulingRule
        
        contains(ISchedulingRule): boolean
        
        isConflicting(ISchedulingRule): boolean
        
        Job
        
        ASYNC_FINISH: IStatus
        
        INTERACTIVE: int
        
        SHORT: int
        
        LONG: int
        
        BUILD: int
        
        DECORATE: int
        
        NONE: int
        
        SLEEPING: int
        
        WAITING: int
        
        RUNNING: int
        
        getJobManager(): IJobManager
        
        create(String, IJobFunction): Job
        
        $1
        
        run(IProgressMonitor): IStatus
        
        create(String, ICoreRunnable): Job
        
        $2
        
        run(IProgressMonitor): IStatus
        
        createSystem(String, IJobFunction): Job
        
        createSystem(String, ICoreRunnable): Job
        
        createSystem(ICoreRunnable): Job
        
        Job(String): void
        
        addJobChangeListener(IJobChangeListener): void
        
        belongsTo(Object): boolean
        
        cancel(): boolean
        
        canceling(): void
        
        done(IStatus): void
        
        getName(): String
        
        getPriority(): int
        
        getProperty(QualifiedName): Object
        
        getResult(): IStatus
        
        getRule(): ISchedulingRule
        
        getState(): int
        
        getThread(): Thread
        
        getJobGroup(): JobGroup
        
        isBlocking(): boolean
        
        isSystem(): boolean
        
        isUser(): boolean
        
        join(): void
        
        join(long, IProgressMonitor): boolean
        
        removeJobChangeListener(IJobChangeListener): void
        
        run(IProgressMonitor): IStatus
        
        schedule(): void
        
        schedule(long): void
        
        setName(String): void
        
        setPriority(int): void
        
        setProgressGroup(IProgressMonitor, int): void
        
        setProperty(QualifiedName, Object): void
        
        setRule(ISchedulingRule): void
        
        setSystem(boolean): void
        
        setUser(boolean): void
        
        setThread(Thread): void
        
        setJobGroup(JobGroup): void
        
        shouldRun(): boolean
        
        shouldSchedule(): boolean
        
        sleep(): boolean
        
        toString(): String
        
        wakeUp(): void
        
        wakeUp(long): void
        
        yieldRule(IProgressMonitor): Job
        
        JobChangeAdapter
        
        aboutToRun(IJobChangeEvent): void
        
        awake(IJobChangeEvent): void
        
        done(IJobChangeEvent): void
        
        running(IJobChangeEvent): void
        
        scheduled(IJobChangeEvent): void
        
        sleeping(IJobChangeEvent): void
        
        JobGroup
        
        getActiveJobs(): List<Job>
        
        NONE: int
        
        ACTIVE: int
        
        CANCELING: int
        
        JobGroup(String, int, int): void
        
        getName(): String
        
        getMaxThreads(): int
        
        getResult(): MultiStatus
        
        getState(): int
        
        cancel(): void
        
        join(long, IProgressMonitor): boolean
        
        shouldCancel(IStatus, int, int): boolean
        
        computeGroupResult(List<IStatus>): MultiStatus
        
        LockListener
        
        manager: LockManager
        
        aboutToWait(Thread): boolean
        
        aboutToRelease(): void
        
        canBlock(): boolean
        
        isLockOwnerThread(): boolean
        
        MultiRule
        
        rules: ISchedulingRule[]
        
        combine(ISchedulingRule[]): ISchedulingRule
        
        combine(ISchedulingRule, ISchedulingRule): ISchedulingRule
        
        flatten(ISchedulingRule[]): ISchedulingRule[]
        
        MultiRule(ISchedulingRule[]): void
        
        MultiRule(): void
        
        getChildren(): ISchedulingRule[]
        
        contains(ISchedulingRule): boolean
        
        isConflicting(ISchedulingRule): boolean
        
        toString(): String
        
        ProgressProvider
        
        createMonitor(Job): IProgressMonitor
        
        createProgressGroup(): IProgressMonitor
        
        createMonitor(Job, IProgressMonitor, int): IProgressMonitor
        
        getDefaultMonitor(): IProgressMonitor

directory

Java files

org/eclipse/core/

directory

Class files

org/eclipse/core/