consulo.util.pointers.Named Java Examples

@Nonnull
private String checkFileNameIsFree(@Nonnull String subPath, @Nonnull String schemeName) {
  for (Named scheme : mySchemes) {
    if (scheme instanceof ExternalizableScheme) {
      String name = ((ExternalizableScheme)scheme).getExternalInfo().getCurrentFileName();
      if (name != null &&
          !schemeName.equals(scheme.getName()) &&
          subPath.length() == (name.length() + mySchemeExtension.length()) &&
          subPath.startsWith(name) &&
          subPath.endsWith(mySchemeExtension)) {
        return UniqueNameGenerator.generateUniqueName(FileUtil.sanitizeName(schemeName), collectAllFileNames());
      }
    }
  }
  return subPath;
}
 

@Override
public Component getListCellRendererComponent(@Nonnull JList list, Object val, int i, boolean isSelected, boolean cellHasFocus) {
  Named c = (Named)val;
  myNameLabel.setText(c.getName());

  updateColors(isSelected);
  return myPanel;
}
 

@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;
}
 

/**
 * Finds extensions supporting the given <code>schemeClass</code>
 * @param schemeClass The class of the scheme to search extensions for.
 * @return A collection of importers capable of importing schemes of the given class. An empty collection is returned if there are
 *         no matching importers.
 */
@Nonnull
public static <S extends Named> Collection<SchemeImporterEP<S>> getExtensions(Class<S> schemeClass) {
  List<SchemeImporterEP<S>> importers = new ArrayList<SchemeImporterEP<S>>();
  for (SchemeImporterEP<?> importerEP : EP_NAME.getExtensions()) {
    if (schemeClass.getName().equals(importerEP.schemeClass)) {
      //noinspection unchecked
      importers.add((SchemeImporterEP<S>)importerEP);
    }
  }
  return importers;
}
 

/**
 * Find an importer for the given name and scheme class. It is allowed for importers to have the same name but different scheme classes.
 * @param name        The importer name as defined in plug-in configuration.
 * @param schemeClass The scheme class the importer has to support.
 * @return The found importer or null if there are no importers for the given name and scheme class.
 */
@Nullable
public static <S extends Named> SchemeImporter<S> getImporter(@Nonnull String name, Class<S> schemeClass) {
  for (SchemeImporterEP<S> importerEP : getExtensions(schemeClass)) {
    if (name.equals(importerEP.name)) {
      return importerEP.getInstance();
    }
  }
  return null;
}
 

@Override
protected void schemeDeleted(@Nonnull Named scheme) {
  super.schemeDeleted(scheme);

  if (scheme instanceof ExternalizableScheme) {
    ContainerUtilRt.addIfNotNull(myFilesToDelete, ((ExternalizableScheme)scheme).getExternalInfo().getCurrentFileName());
  }
}
 

@Nonnull
@SuppressWarnings("unchecked")
public static <T extends Named> EmptyModuleInheritableNamedPointer<T> empty()
{
	return ourInstance;
}
 

@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();
}
 

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

public void init(Named scheme){
  myShareSchemePanel.setName(scheme.getName());
}
 

@Override
public void addNewScheme(@Nonnull final Named scheme, final boolean replaceExisting) {
}
 

@Override
public Named findSchemeByName(@Nonnull String schemeName) {
  return null;
}
 

@Override
public Named getCurrentScheme() {
  return null;
}
 

@Override
public void removeScheme(@Nonnull Named scheme) {
}
 

protected void checkCurrentScheme(@Nonnull Named scheme) {
  if (myCurrentScheme == null && Objects.equals(scheme.getName(), myCurrentSchemeName)) {
    //noinspection unchecked
    myCurrentScheme = (T)scheme;
  }
}
 

protected void schemeDeleted(@Nonnull Named scheme) {
  if (myCurrentScheme == scheme) {
    myCurrentScheme = null;
  }
}