/** * @param descriptor the identifier to clone */ public DefaultExtensionRepositoryDescriptor(ExtensionRepositoryDescriptor descriptor) { this(descriptor.getId(), descriptor.getType(), descriptor.getURI()); setProperties(descriptor.getProperties()); }
/** * @param priority the priority in the list of repositories * @param repository add an existing repository * @since 8.3M1 */ default void addRepository(ExtensionRepository repository, int priority) { addRepository(repository); }
@Override public boolean isSortable() { return this.repositories.isSortable(); }
@Override public boolean equals(Object obj) { if (obj instanceof ExtensionRepositoryDescriptor) { ExtensionRepositoryDescriptor repository = (ExtensionRepositoryDescriptor) obj; return Objects.equal(getId(), repository.getId()) && Objects.equal(getType(), repository.getType()) && Objects.equal(getURI(), repository.getURI()) && Objects.equal(getProperties(), repository.getProperties()); } return false; }
public void addRepository(ExtensionRepositoryId repositoryId) throws ExtensionRepositoryException { try { ExtensionRepositoryFactory repositoryFactory = this.componentManager.lookup(ExtensionRepositoryFactory.class, repositoryId.getType()); addRepository(repositoryFactory.createRepository(repositoryId)); } catch (ComponentLookupException e) { throw new ExtensionRepositoryException("Unsupported repository type[" + repositoryId.getType() + "]", e); } }
@Override public Extension getAccessibleExtension(String feature, Namespace namespace) { // Try installed extension Extension extension = this.installedExtensionRepository.getInstalledExtension(feature, namespace.serialize()); if (extension == null) { // Try core extension extension = this.coreExtensionRepository.getCoreExtension(feature); } return extension; }
@Override public Extension resolve(ExtensionId extensionId) throws ResolveException { for (ExtensionRepository remoteRepository : this.repositories.getRepositories()) { Extension extension = remoteRepository.resolve(extensionId); if (extension != null && RepositoryUtils.matches(this.filters, extension)) { return extension; } } return null; }
@Override @Deprecated public Extension resolveExtension(ExtensionDependency extensionDependency) throws ResolveException { try { return this.coreExtensionRepository.resolve(extensionDependency); } catch (ResolveException notACoreExtension) { try { return this.localExtensionRepository.resolve(extensionDependency); } catch (ResolveException notALocalExtension) { return this.repositoryManager.resolve(extensionDependency); } } }
@Override public void initialize() throws InitializationException { this.standardRepositories.put(this.coreExtensionRepository.getDescriptor().getId(), this.coreExtensionRepository); this.standardRepositories.put(this.localExtensionRepository.getDescriptor().getId(), this.localExtensionRepository); this.standardRepositories.put(this.installedExtensionRepository.getDescriptor().getId(), this.installedExtensionRepository); }
/** * @return all the remote repositories */ private Collection<ExtensionRepository> getRepositories() { return this.repositoryManager.getRepositories(); }
/** * Search installed extensions based of the provided query. * * @param query the extension query used to filter and order the result * @return the found extensions descriptors, empty list if nothing could be found * @throws SearchException error when trying to search provided pattern * @since 8.1RC1 */ default IterableResult<InstalledExtension> searchInstalledExtensions(ExtensionQuery query) throws SearchException { return searchInstalledExtensions((String) null, query); }
/** * @param id the repository identifier * @deprecated since 4.3M1 use {@link #AbstractExtensionRepository(ExtensionRepositoryDescriptor)} instead */ @Deprecated protected AbstractExtensionRepository(ExtensionRepositoryId id) { setId(new ExtensionRepositoryId(id)); }
@Override public ExtensionRepositoryId getId() { return new ExtensionRepositoryId(this.descriptor); }
@Override public boolean exists(ExtensionId extensionId) { for (ExtensionRepository repository : this.repositories) { if (repository.exists(extensionId)) { return true; } } return false; }
/** * Default constructor. */ public DefaultCoreExtensionRepository() { super(new DefaultExtensionRepositoryDescriptor("core", "xwiki-core", null)); }
@Override public ExtensionRepository createRepository(ExtensionRepositoryId repositoryId) throws ExtensionRepositoryException { return createRepository((ExtensionRepositoryDescriptor) repositoryId); } }
@Override public boolean isFilterable() { return this.repositories.isFilterable(); }
/** * @param descriptor the repository descriptor * @since 4.3M1 */ protected AbstractExtensionRepository(ExtensionRepositoryDescriptor descriptor) { setDescriptor(descriptor); }