vcs-impl/src/com/intellij/lifecycle/ControlledAlarmFactory.java

   1 package com.intellij.lifecycle;
   2
   3 import com.intellij.openapi.application.Application;
   4 import com.intellij.openapi.application.ApplicationManager;
   5 import com.intellij.openapi.diagnostic.Logger;
   6 import com.intellij.openapi.project.Project;
   7 import org.jetbrains.annotations.NotNull;
   8
   9 import java.util.concurrent.ExecutorService;
  10 import java.util.concurrent.Future;
  11 import java.util.concurrent.ScheduledExecutorService;
  12 import java.util.concurrent.TimeUnit;
  13
  14 public class ControlledAlarmFactory {
  15   private static final Logger LOG = Logger.getInstance("#com.intellij.lifecycle.ControlledAlarmFactory");
  16   private ControlledAlarmFactory() {
  17   }
  18
  19   public static SlowlyClosingAlarm createOnOwnThread(@NotNull final Project project, @NotNull final String name) {
  20     return new SlowlyClosingAlarm(project, name);
  21   }
  22
  23   public static SlowlyClosingAlarm createOnSharedThread(@NotNull final Project project, @NotNull final String name,
  24                                                         final @NotNull ExecutorService executor) {
  25     return new SlowlyClosingAlarm(project, name, createExecutorWrapper(executor), true);
  26   }
  27
  28   public static ScheduledSlowlyClosingAlarm createScheduledOnSharedThread(@NotNull final Project project, @NotNull final String name,
  29                                                         final @NotNull ScheduledExecutorService executor) {
  30     return new ScheduledSlowlyClosingAlarm(project, name, new MyScheduledExecutorServiceWrapper(executor), true);
  31   }
  32
  33   public static SlowlyClosingAlarm createOnApplicationPooledThread(@NotNull final Project project) {
  34     return new SlowlyClosingAlarm(project, "Application pooled thread controlled alarm", new MyApplicationPooledThreadExecutorWrapper(), true);
  35   }
  36
  37   static MyExecutorWrapper createExecutorWrapper(final ExecutorService executorService) {
  38     return new MyExecutorServiceWrapper(executorService);
  39   }
  40
  41   interface MyExecutorWrapper {
  42     Future<?> submit(final Runnable runnable);
  43     void shutdown();
  44     Future<?> schedule(final Runnable runnable, final long delay, final TimeUnit timeUnit);
  45     boolean supportsScheduling();
  46   }
  47
  48   private static class MyExecutorServiceWrapper implements MyExecutorWrapper {
  49     private final ExecutorService myExecutorService;
  50
  51     public MyExecutorServiceWrapper(final ExecutorService executorService) {
  52       myExecutorService = executorService;
  53     }
  54
  55     public Future<?> submit(Runnable runnable) {
  56       return myExecutorService.submit(runnable);
  57     }
  58
  59     public void shutdown() {
  60       myExecutorService.shutdown();
  61     }
  62
  63     public Future<?> schedule(Runnable runnable, long delay, TimeUnit timeUnit) {
  64       throw new UnsupportedOperationException();
  65     }
  66
  67     public boolean supportsScheduling() {
  68       return false;
  69     }
  70   }
  71
  72   private static class MyScheduledExecutorServiceWrapper implements MyExecutorWrapper {
  73     private final ScheduledExecutorService myScheduledExecutorService;
  74
  75     public MyScheduledExecutorServiceWrapper(final ScheduledExecutorService scheduledExecutorService) {
  76       myScheduledExecutorService = scheduledExecutorService;
  77     }
  78
  79     public Future<?> submit(Runnable runnable) {
  80       return myScheduledExecutorService.submit(runnable);
  81     }
  82
  83     public void shutdown() {
  84       myScheduledExecutorService.shutdown();
  85     }
  86
  87     public Future<?> schedule(Runnable runnable, long delay, TimeUnit timeUnit) {
  88       return myScheduledExecutorService.schedule(runnable, delay, timeUnit);
  89     }
  90
  91     public boolean supportsScheduling() {
  92       return true;
  93     }
  94   }
  95
  96   private static class MyApplicationPooledThreadExecutorWrapper implements MyExecutorWrapper {
  97     private Application myApplication;
  98
  99     private MyApplicationPooledThreadExecutorWrapper() {
 100       myApplication = ApplicationManager.getApplication();
 101     }
 102
 103     public Future<?> submit(Runnable runnable) {
 104       return myApplication.executeOnPooledThread(runnable);
 105     }
 106
 107     public void shutdown() {
 108       //do not kill shared
 109     }
 110
 111     public Future<?> schedule(final Runnable runnable, long delay, TimeUnit timeUnit) {
 112       throw new UnsupportedOperationException();
 113     }
 114
 115     public boolean supportsScheduling() {
 116       return false;
 117     }
 118   }
 119 }