com.intellij.openapi.components.RoamingType Java Examples

public BaseToolManager(ActionManager actionManagerEx, SchemesManagerFactory factory) {
  myActionManager = actionManagerEx;

  mySchemesManager = factory.createSchemesManager(
    getSchemesPath(), createProcessor(), RoamingType.PER_USER);

  mySchemesManager.loadSchemes();
  registerActions();
}
 

public void testCreateStateStorageAssertionThrownWhenUnknownMacro() {
  try {
    myStateStorageManager.getStateStorage("$UNKNOWN_MACRO$/test.xml", RoamingType.PER_USER);
    fail("Exception expected");
  }
  catch (IllegalArgumentException e) {
    assertEquals("Unknown macro: $UNKNOWN_MACRO$ in storage file spec: $UNKNOWN_MACRO$/test.xml", e.getMessage());
  }
}
 

@Override
public <T extends Named, E extends ExternalizableScheme> SchemesManager<T, E> createSchemesManager(final String fileSpec,
                                                                                                    final SchemeProcessor<E> processor,
                                                                                                    final RoamingType roamingType) {
  final Application application = ApplicationManager.getApplication();
  if (!(application instanceof ApplicationEx2)) return null;
  String baseDirPath = ((ApplicationEx2)application).getStateStore().getStateStorageManager().expandMacros(fileSpec);

  StreamProvider
          provider = ((ApplicationEx2)ApplicationManager.getApplication()).getStateStore().getStateStorageManager().getStreamProvider();
  SchemesManagerImpl<T, E> manager = new SchemesManagerImpl<T, E>(fileSpec, processor, roamingType, provider, new File(baseDirPath));
  myRegisteredManagers.add(manager);
  return manager;
}
 

public void updatedFromStreamProvider(@Nonnull Set<String> changedComponentNames, boolean deleted) {
  if (myRoamingType == RoamingType.DISABLED) {
    // storage roaming was changed to DISABLED, but settings repository has old state
    return;
  }

  try {
    Element newElement = deleted ? null : loadDataFromStreamProvider();
    if (newElement == null) {
      StorageUtil.deleteFile(myFile, this, myCachedVirtualFile);
      // if data was loaded, mark as changed all loaded components
      if (myLoadedData != null) {
        changedComponentNames.addAll(myLoadedData.getComponentNames());
        myLoadedData = null;
      }
    }
    else if (myLoadedData != null) {
      StorageData newStorageData = createStorageData();
      loadState(newStorageData, newElement);
      changedComponentNames.addAll(myLoadedData.getChangedComponentNames(newStorageData, myPathMacroSubstitutor));
      myLoadedData = newStorageData;
    }
  }
  catch (Throwable e) {
    LOG.error(e);
  }
}
 

private void doSaveForProvider(@Nonnull Element element, @Nonnull RoamingType roamingType, @Nullable byte[] content) throws IOException {
  if (content == null) {
    StorageUtil.sendContent(myStreamProvider, myFileSpec, element, roamingType);
  }
  else {
    myStreamProvider.saveContent(myFileSpec, content, myRoamingType);
  }
}
 

protected XmlElementStorage(@Nonnull String fileSpec,
                            @Nullable RoamingType roamingType,
                            @Nullable TrackingPathMacroSubstitutor pathMacroSubstitutor,
                            @Nonnull String rootElementName,
                            @Nullable StreamProvider streamProvider) {
  super(pathMacroSubstitutor);

  myFileSpec = fileSpec;
  myRoamingType = roamingType == null ? RoamingType.PER_USER : roamingType;
  myRootElementName = rootElementName;
  myStreamProvider = myRoamingType == RoamingType.DISABLED ? null : streamProvider;
}
 

public IoFileBasedStorage(@Nonnull String filePath,
                          @Nonnull String fileSpec,
                          @Nullable RoamingType roamingType,
                          @Nullable TrackingPathMacroSubstitutor pathMacroManager,
                          @Nonnull String rootElementName,
                          @Nonnull Disposable parentDisposable,
                          @Nullable final Listener listener,
                          @Nullable StreamProvider streamProvider,
                          boolean useXmlProlog) {
  super(fileSpec, roamingType, pathMacroManager, rootElementName, streamProvider);

  myFilePath = filePath;
  myUseXmlProlog = useXmlProlog;
  myFile = new File(filePath);
}
 

@Nullable
public InputStream loadContent(String fileSpec, RoamingType roamingType, StateStorageManager stateStorageManager) throws IOException {
  Ref<byte[]> ref = myQueue.getContent(fileSpec, roamingType);
  if (ref != null) {
    byte[] bytes = ref.get();
    if (bytes == null) {
      return null;
    }
    else {
      Pair<byte[], Integer> pair = DataCompressor.uncompress(new UnsyncByteArrayInputStream(bytes));
      return new UnsyncByteArrayInputStream(pair.getFirst());
    }
  }

  InputStream stream = null;
  int mod = -1;
  File file = new File(myProxyDirectory, buildFileSpec(roamingType, fileSpec));
  if (file.exists()) {
    try (FileInputStream inputStream = new FileInputStream(file)) {
      Pair<byte[], Integer> compressedPair = DataCompressor.uncompress(inputStream);

      stream = new UnsyncByteArrayInputStream(compressedPair.getFirst());
      mod = compressedPair.getSecond();
    }
  }

  myQueue.wantLoad(fileSpec, roamingType, mod, stateStorageManager);
  return stream;
}
 

@Nonnull
public Collection<String> listSubFiles(@Nonnull String fileSpec, @Nonnull RoamingType roamingType) {
  fileSpec = buildFileSpec(roamingType, fileSpec);

  File proxy = new File(myProxyDirectory, fileSpec);
  if (proxy.isDirectory() && proxy.isDirectory()) {
    return Arrays.asList(proxy.list());
  }
  return Collections.emptyList();
}
 

public static void sendContent(@Nonnull StreamProvider provider, @Nonnull String fileSpec, @Nonnull Parent element, @Nonnull RoamingType type) {
  if (!provider.isApplicable(fileSpec, type)) {
    return;
  }

  try {
    doSendContent(provider, fileSpec, element, type);
  }
  catch (IOException e) {
    LOG.warn(e);
  }
}
 

public boolean deleteWithoutServer(@Nonnull String fileSpec, @Nonnull RoamingType roamingType) {
  fileSpec = buildFileSpec(roamingType, fileSpec);

  File file = new File(myProxyDirectory, fileSpec);
  if (file.exists()) {
    return file.delete();
  }
  return false;
}
 

@Nonnull
public static String buildFileSpec(@Nonnull RoamingType roamingType, @Nonnull String fileSpec) {
  switch (roamingType) {
    case PER_PLATFORM:
      return "$OS$/" + getOsPrefix() + "/" + fileSpec;
    case PER_USER:
      return "$GLOBAL$/" + fileSpec;
    default:
      throw new UnsupportedOperationException(roamingType.name());
  }
}
 

/**
 * fileSpec Only main fileSpec, not version
 */
public boolean isApplicable(@Nonnull String fileSpec, @Nonnull RoamingType roamingType) {
  return true;
}
 

@Nullable
public Ref<byte[]> getContent(String fileSpec, RoamingType roamingType) {
  return myLoadedBytes.remove(ExternalStorage.buildFileSpec(roamingType, fileSpec));
}
 

@Nullable
public abstract InputStream loadContent(@Nonnull String fileSpec, @Nonnull RoamingType roamingType) throws IOException;
 

@Nonnull
public Collection<String> listSubFiles(@Nonnull String fileSpec, @Nonnull RoamingType roamingType) {
  return Collections.emptyList();
}
 

public static void delete(@Nonnull StreamProvider provider, @Nonnull String fileSpec, @Nonnull RoamingType type) {
  if (provider.isApplicable(fileSpec, type)) {
    provider.delete(fileSpec, type);
  }
}
 

/**
 * You must call {@link StreamProvider#isApplicable(String, com.intellij.openapi.components.RoamingType)} before
 */
public static void doSendContent(@Nonnull StreamProvider provider, @Nonnull String fileSpec, @Nonnull Parent element, @Nonnull RoamingType type) throws IOException {
  // we should use standard line-separator (\n) - stream provider can share file content on any OS
  byte[] content = elementToBytes(element, false);
  provider.saveContent(fileSpec, content, type);
}
 

@Inject
public ShelveChangesManager(Project project, ProjectPathMacroManager projectPathMacroManager, SchemesManagerFactory schemesManagerFactory, ChangeListManager changeListManager) {
  myProject = project;
  myPathMacroSubstitutor = projectPathMacroManager.createTrackingSubstitutor();
  myBus = project.getMessageBus();
  mySchemeManager = schemesManagerFactory.createSchemesManager(SHELVE_MANAGER_DIR_PATH, new BaseSchemeProcessor<ShelvedChangeList>() {
    @Nullable
    @Override
    public ShelvedChangeList readScheme(@Nonnull Element element, boolean duringLoad) throws InvalidDataException {
      return readOneShelvedChangeList(element);
    }

    @Nonnull
    @Override
    public Parent writeScheme(@Nonnull ShelvedChangeList scheme) throws WriteExternalException {
      Element child = new Element(ELEMENT_CHANGELIST);
      scheme.writeExternal(child);
      myPathMacroSubstitutor.collapsePaths(child);
      return child;
    }
  }, RoamingType.PER_USER);

  myCleaningFuture = JobScheduler.getScheduler().scheduleWithFixedDelay(new Runnable() {
    @Override
    public void run() {
      cleanSystemUnshelvedOlderOneWeek();
    }
  }, 1, 1, TimeUnit.DAYS);
  Disposer.register(project, new Disposable() {
    @Override
    public void dispose() {
      stopCleanScheduler();
    }
  });

  File shelfDirectory = mySchemeManager.getRootDirectory();
  myFileProcessor = new CompoundShelfFileProcessor(shelfDirectory);
  // do not try to ignore when new project created,
  // because it may lead to predefined ignore creation conflict; see ConvertExcludedToIgnoredTest etc
  if (shelfDirectory.exists()) {
    changeListManager.addDirectoryToIgnoreImplicitly(shelfDirectory.getAbsolutePath());
  }
}
 

private File writeLocalFile(@Nonnull File proxyDirectory, @Nonnull String fileSpec, RoamingType roamingType, byte[] compressedData) throws IOException {
  File file = new File(proxyDirectory, ExternalStorage.buildFileSpec(roamingType, fileSpec));
  FileUtil.createParentDirs(file);
  FileUtil.writeToFile(file, compressedData);
  return file;
}
 

@Override
public <T extends Named,E extends ExternalizableScheme> SchemesManager<T,E> createSchemesManager(final String fileSpec,
                                                                 final SchemeProcessor<E> processor, final RoamingType roamingType) {
  return new EmptySchemesManager();
}
 

LoadItem(String fileSpec, RoamingType roamingType, int modCount, StateStorageManager stateStorageManager) {
  myFileSpec = fileSpec;
  myRoamingType = roamingType;
  myModCount = modCount;
  myStateStorageManager = stateStorageManager;
}
 

public void saveContent(@Nonnull String fileSpec, @Nonnull RoamingType roamingType, byte[] content) throws IOException {
  // compress data with -1 mod count - for local, server wull update it after pushing data
  byte[] compress = DataCompressor.compress(content, -1);

  myQueue.wantSaveToServer(myProxyDirectory, fileSpec, roamingType, compress);
}
 

@Override
public void delete(@Nonnull String fileSpec, @Nonnull RoamingType roamingType) {
  myStorage.delete(fileSpec, roamingType);
}
 

@Nullable
@Override
public InputStream loadContent(@Nonnull String fileSpec, @Nonnull RoamingType roamingType) throws IOException {
  return myStorage.loadContent(fileSpec, roamingType, myStateStorageManager);
}
 

@Override
public void saveContent(@Nonnull String fileSpec, @Nonnull byte[] content, @Nonnull RoamingType roamingType) throws IOException {
  myStorage.saveContent(fileSpec, roamingType, content);
}
 

@Nonnull
@Override
public Collection<String> listSubFiles(@Nonnull String fileSpec, @Nonnull RoamingType roamingType) {
  return myStorage.listSubFiles(fileSpec, roamingType);
}
 

public abstract <T extends Named, E extends ExternalizableScheme> SchemesManager<T,E> createSchemesManager(String fileSpec, SchemeProcessor<E> processor,
RoamingType roamingType);
 

public MyXmlElementStorage(Element element) throws StateStorageException {
  super("", RoamingType.PER_USER, new MyPathMacroManager(), "root", null);
  myElement = element;
}
 

public void testCreateFileStateStorageMacroSubstitutedWhenExpansionHas$() {
  myStateStorageManager.addMacro("$DOLLAR_MACRO$", "/temp/d$");
  StateStorage data = myStateStorageManager.getStateStorage("$DOLLAR_MACRO$/test.xml", RoamingType.PER_USER);
  assertThat(data, is(notNullValue()));
}