import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
protected void paste(Path destination) {
  if (resources == null || resources.length == 0) {
    Log.debug(getClass(), "Resources to process was not found");
    return;
  }

  final Resource[] resourcesToProcess = copyOf(resources, resources.length);
  final Path lastCopiedResource =
      destination.append(resourcesToProcess[resourcesToProcess.length - 1].getName());

  pasteSuccessively(promises.resolve(null), resourcesToProcess, 0, destination)
      .then(
          ignored -> {
            eventBus.fireEvent(new RevealResourceEvent(lastCopiedResource));
          });
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
@Inject
public HelloWorldViewPresenter(final HelloWorldView helloWorldView) {
  this.helloWorldView = helloWorldView;

  ScriptInjector.fromUrl(GWT.getModuleBaseURL() + Constants.JAVASCRIPT_FILE_ID)
      .setWindow(ScriptInjector.TOP_WINDOW)
      .setCallback(
          new Callback<Void, Exception>() {
            @Override
            public void onSuccess(final Void result) {
              Log.info(HelloWorldViewPresenter.class, Constants.JAVASCRIPT_FILE_ID + " loaded.");
              sayHello("Hello from Java Script!");
            }

            @Override
            public void onFailure(final Exception e) {
              Log.error(
                  HelloWorldViewPresenter.class,
                  "Unable to load " + Constants.JAVASCRIPT_FILE_ID,
                  e);
            }
          })
      .inject();
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
private void addPremiumSupportHelpAction() {
  // userVoice init
  ScriptInjector.fromUrl(resources.userVoice().getSafeUri().asString())
      .setWindow(ScriptInjector.TOP_WINDOW)
      .setCallback(
          new Callback<Void, Exception>() {
            @Override
            public void onSuccess(Void aVoid) {
              // add action
              actionManager.registerAction(
                  localizationConstant.createSupportTicketAction(), createSupportTicketAction);

              helpGroup.addSeparator();
              helpGroup.add(createSupportTicketAction);
            }

            @Override
            public void onFailure(Exception e) {
              Log.error(getClass(), "Unable to inject UserVoice", e);
            }
          })
      .inject();
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
private <R> Promise<R> doAfterKeycloakInitAndUpdate(Sender<R> sender) {
  return keycloakProvider
      .getUpdatedToken(5)
      .thenPromise(
          new Function<String, Promise<R>>() {
            @Override
            public Promise<R> apply(String keycloakToken) {
              addAuthorizationHeader(keycloakToken);
              try {
                return sender.doSend();
              } catch (Throwable t) {
                Log.error(getClass(), t);
                throw t;
              }
            }
          });
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
@Override
public void actionPerformed(ActionEvent event) {
  List<EditorPartPresenter> dirtyEditors = editorAgent.getDirtyEditors();
  if (dirtyEditors.isEmpty()) {
    performAction();
    return;
  }

  AsyncCallback<Void> savingOperationCallback =
      new AsyncCallback<Void>() {
        @Override
        public void onFailure(Throwable caught) {
          Log.error(getClass(), caught);
        }

        @Override
        public void onSuccess(Void result) {
          performAction();
        }
      };

  dialogFactory
      .createConfirmDialog(
          locale.unsavedDataDialogTitle(),
          locale.unsavedDataDialogPromptSaveChanges(),
          () -> editorAgent.saveAll(savingOperationCallback),
          null)
      .show();
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
@Override
public void onValueChanged(Variable variable, long threadId, int frameIndex) {
  if (view.getSelectedThreadId() == threadId && view.getSelectedFrameIndex() == frameIndex) {
    Debugger debugger = debuggerManager.getActiveDebugger();
    if (debugger != null && debugger.isSuspended()) {
      Promise<? extends SimpleValue> promise = debugger.getValue(variable, threadId, frameIndex);
      promise
          .then(
              value -> {
                MutableVariable updatedVariable =
                    variable instanceof MutableVariable
                        ? ((MutableVariable) variable)
                        : new MutableVariableImpl(variable);
                updatedVariable.setValue(value);
                view.updateVariable(updatedVariable);
              })
          .catchError(
              error -> {
                Log.error(DebuggerPresenter.class, error.getCause());
              });
    }
  }
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
private void selectKeyMode(Keymap keymap) {
  resetKeyModes();
  Keymap usedKeymap = keymap;
  if (usedKeymap == null) {
    usedKeymap = KeyMode.DEFAULT;
  }
  if (KeyMode.DEFAULT.equals(usedKeymap)) {
    // nothing to do
  } else if (EMACS.equals(usedKeymap)) {
    this.editorOverlay.getTextView().addKeyMode(keyModeInstances.getInstance(EMACS));
  } else if (VI.equals(usedKeymap)) {
    this.editorOverlay.getTextView().addKeyMode(keyModeInstances.getInstance(VI));
  } else {
    usedKeymap = KeyMode.DEFAULT;
    Log.error(
        OrionEditorWidget.class,
        "Unknown keymap type: " + keymap + " - changing to default one.");
  }
  this.keymap = usedKeymap;
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
/**
 * Add an inline annotation.
 *
 * @param annotationModel the annotation model
 * @param annotation the annotation to add
 * @param decorations the available decorations
 */
private void addAnnotationItem(
    AnnotationModel annotationModel, Annotation annotation, Map<String, String> decorations) {
  if (this.hasTextMarkers != null) {
    final String className = decorations.get(annotation.getType());
    if (className == null) {
      return;
    }

    final Position position = annotationModel.getPosition(annotation);
    if (position == null) {
      Log.warn(InlineAnnotationRenderer.class, "Can't add annotation with no position");
      return;
    }

    final TextPosition from = this.document.getPositionFromIndex(position.getOffset());
    final TextPosition to =
        this.document.getPositionFromIndex(position.getOffset() + position.getLength());

    final MarkerRegistration registration =
        this.hasTextMarkers.addMarker(new TextRange(from, to), className);
    if (registration != null) {
      this.markers.put(annotation, registration);
    }
  }
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
private void addAnnotationItem(
    final AnnotationModel model,
    final Annotation annotation,
    final Map<String, String> decorations) {
  final Position position = model.getPosition(annotation);
  if (position == null) {
    Log.warn(MinimapAnnotationRenderer.class, "No position for annotation " + annotation);
    return;
  }
  //        final TextPosition textPosition =
  // this.document.getPositionFromIndex(position.getOffset());
  //        final int line = textPosition.getLine();

  final String style = decorations.get(annotation.getType());
  this.minimap.addMark(position.getOffset(), style, annotation.getLayer(), annotation.getText());
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
/**
 * Creates a new keymap instance.
 *
 * @param key the key (must not already exist)
 * @param displayString the name displayed to a user
 * @return a new keymap instance
 */
public static Keymap newKeymap(final String key, final String displayString) {
  if (key == null) {
    throw new IllegalArgumentException("Keymap key can't be null");
  }
  if (displayString == null) {
    throw new IllegalArgumentException("Keymap display string can't be null");
  }
  if (fromKey(key) != null) {
    throw new RuntimeException("Keymap with key " + key + " already exists");
  }

  Log.debug(Keymap.class, "Creation of new keymap " + key);
  Keymap keymap = new Keymap(key, displayString);
  instances.put(key, keymap);
  return keymap;
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
@Override
public List<String> identifyType(final VirtualFile file) {
  Log.debug(MultipleMethodFileIdentifier.class, "Try identification by file name.");
  final List<String> firstTry = this.fileNameFileTypeIdentifier.identifyType(file);
  if (firstTry != null && !firstTry.isEmpty()) {
    return firstTry;
  }
  Log.debug(MultipleMethodFileIdentifier.class, "Try identification by file name suffix.");
  final List<String> secondTry = this.extensionFileTypeIdentifier.identifyType(file);
  if (secondTry != null && !secondTry.isEmpty()) {
    return secondTry;
  }
  // try harder
  Log.debug(MultipleMethodFileIdentifier.class, "Try identification by looking at the content.");
  final List<String> thirdTry = this.firstLineFileTypeIdentifier.identifyType(file);
  if (thirdTry != null && !thirdTry.isEmpty()) {
    return thirdTry;
  }
  // other means may be added later
  Log.debug(MultipleMethodFileIdentifier.class, "No identification method gave an answer.");
  return null;
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
@Override
public List<String> identifyType(final VirtualFile file) {
  final String filename = file.getName();
  if (filename != null) {
    final int dotPos = filename.lastIndexOf('.');
    if (dotPos
        < 1) { // either -1 (not found) or 0 (first position, for example .project or .che etc.
      Log.debug(ExtensionFileTypeIdentifier.class, "File name has no suffix ");
      return null;
    }
    final String suffix = filename.substring(dotPos + 1);
    Log.debug(ExtensionFileTypeIdentifier.class, "Looking for a type for suffix " + suffix);
    List<String> result = mappings.get(suffix);
    Log.debug(ExtensionFileTypeIdentifier.class, "Found mime-types: " + printList(result));
    return result;
  }
  return null;
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
@Override
public List<String> identifyType(final VirtualFile file) {
  // TODO: file's content retrieved asynchronously
  final String content = "" /*file.getContent()*/;
  if (isXml(content)) {
    Log.debug(FirstLineFileTypeIdentifier.class, "Identified file as XML.");
    return Collections.singletonList("application/xml");
  }
  final String shebangLoader = getShebang(content);
  if (shebangLoader != null) {
    final int lastSlash = shebangLoader.lastIndexOf('/');
    // need to consider \ as path separator for a feature that exists mostly on unixes ?
    final String basename = shebangLoader.substring(lastSlash + 1);
    final String shebangResult = matchShebang(basename);
    if (shebangResult != null) {
      return Collections.singletonList(shebangResult);
    }
  }

  return null;
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
private void detectTests(TextEditor editor) {
  this.currentEditor = editor;
  TestDetectionContext context = dtoFactory.createDto(TestDetectionContext.class);
  context.setFilePath(currentEditor.getEditorInput().getFile().getLocation().toString());
  context.setOffset(currentEditor.getCursorOffset());
  Resource resource = appContext.getResource();
  Project project =
      (resource == null || resource.getProject() == null)
          ? appContext.getRootProject()
          : resource.getProject();
  context.setProjectPath(project.getPath());
  client
      .detectTests(context)
      .onSuccess(
          testDetectionResult -> {
            isEnable = testDetectionResult.isTestFile();
            testPosition = testDetectionResult.getTestPosition();
          })
      .onFailure(
          jsonRpcError -> {
            Log.error(getClass(), jsonRpcError);
            isEnable = false;
            notificationManager.notify("Can't detect test methods");
          });
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
public final void addAction(Action action, Constraints constraint, ActionManager actionManager) {
  if (action == this) {
    throw new IllegalArgumentException("Cannot add a group to itself");
  }

  // Check that action isn't already registered
  if (!(action instanceof Separator)) {
    for (Action actionInList : actionList) {
      if (action.equals(actionInList)) {
        Log.error(getClass(), "Can not add an action twice: " + action);
        return;
      }
    }
  }
  actionList.add(action);
  constraintsList.add(constraint);

  needSorting = true;
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
@Override
public void open() {
  final int delay = propertyManager.getConnectionDelay(url);

  if (isClosed() || isClosing()) {
    if (delay == 0) {
      webSocketJsoWrapper = WebSocketJsoWrapper.connect(url, endpoint);
    } else {
      new Timer() {
        @Override
        public void run() {
          webSocketJsoWrapper = WebSocketJsoWrapper.connect(url, endpoint);
        }
      }.schedule(delay);
    }
  } else {
    Log.warn(getClass(), "Opening already opened or connecting web socket.");
  }
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
@Override
public void visitTestingMessage(ClientTestingMessage message) {

  if (TestingMessageNames.TESTING_STARTED.equals(message.getName())) {
    if (processor != null) {
      processor.onStartTesting();
    }
    return;
  }
  if (TestingMessageNames.FINISH_TESTING.equals(message.getName())) {
    if (processor != null) {
      processor.onFinishTesting();
    }
    return;
  }
  Log.error(getClass(), "Unexpected test message: " + message.getName());
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
@Override
public void actionPerformed(ActionEvent event) {
  if (event.getParameters() == null) {
    Log.error(getClass(), localizationConstant.runCommandEmptyParamsMessage());
    return;
  }

  final String name = event.getParameters().get(NAME_PARAM_ID);
  if (name == null) {
    Log.error(getClass(), localizationConstant.runCommandEmptyNameMessage());
    return;
  }

  wsAgentServerUtil
      .getWsAgentServerMachine()
      .ifPresent(
          m ->
              commandManager
                  .getCommand(name)
                  .ifPresent(command -> commandExecutor.executeCommand(command, m.getName())));
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
protected static Map<String, String> parseActionParameters(String actionParam) {
  Log.info(StartUpActionsParser.class, " parametersMap " + actionParam);
  final String[] parametersQuery = actionParam.split(";");
  Map<String, String> params = new HashMap<>(parametersQuery.length);
  for (int i = 0; i < parametersQuery.length; i++) {
    final String parameterString = parametersQuery[i];
    final String[] param = parameterString.split("=");
    final String paramName = param[0];
    if (param.length > 1) {
      final String paramValue = param[1];
      params.put(paramName, paramValue);
    } else {
      params.put(paramName, null);
    }
  }
  return params;
}
 

import org.eclipse.che.ide.util.loging.Log; //导入依赖的package包/类
private Promise<Void> restoreState(JsonObject settings) {
  try {
    if (settings.hasKey(WORKSPACE)) {
      JsonObject workspace = settings.getObject(WORKSPACE);
      Promise<Void> sequentialRestore = promises.resolve(null);
      for (String key : workspace.keys()) {
        Optional<StateComponent> stateComponent =
            stateComponentRegistry.get().getComponentById(key);
        if (stateComponent.isPresent()) {
          StateComponent component = stateComponent.get();
          Log.debug(getClass(), "Restore state for the component ID: " + component.getId());
          sequentialRestore =
              sequentialRestore.thenPromise(
                  ignored -> component.loadState(workspace.getObject(key)));
        }
      }
      return sequentialRestore;
    }
  } catch (JsonException e) {
    Log.error(getClass(), e);
  }
  return promises.resolve(null);
}