/*
* Copyright 2016 Red Hat, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.wildfly.arquillian.domain;
import java.io.OutputStream;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import org.jboss.shrinkwrap.api.Archive;
import org.jboss.shrinkwrap.api.ArchiveEventHandler;
import org.jboss.shrinkwrap.api.ArchiveFormat;
import org.jboss.shrinkwrap.api.ArchivePath;
import org.jboss.shrinkwrap.api.Assignable;
import org.jboss.shrinkwrap.api.Filter;
import org.jboss.shrinkwrap.api.IllegalArchivePathException;
import org.jboss.shrinkwrap.api.Node;
import org.jboss.shrinkwrap.api.asset.Asset;
import org.jboss.shrinkwrap.api.asset.NamedAsset;
import org.jboss.shrinkwrap.api.exporter.StreamExporter;
import org.jboss.shrinkwrap.api.formatter.Formatter;
/**
* Allows an archive to be wrapped and return the server group names this archive should be associated with.
*
* @author <a href="mailto:jperkins@redhat.com">James R. Perkins</a>
*/
public class ServerGroupArchive<T extends Archive<T>> implements Archive<T> {
private final Archive<T> delegate;
private final Set<String> serverGroups;
ServerGroupArchive(final Archive<T> delegate, final Set<String> serverGroups) {
this.delegate = delegate;
this.serverGroups = serverGroups;
}
/**
* THe server groups this archive should be associated with.
*
* @return a set of server groups
*/
public Set<String> getServerGroups() {
return serverGroups;
}
@Override
public String getName() {
return delegate.getName();
}
@Override
public String getId() {
return delegate.getId();
}
@Override
public T add(final Asset asset, final ArchivePath target) throws IllegalArgumentException {
return delegate.add(asset, target);
}
@Override
public T add(final Asset asset, final ArchivePath target, final String name) throws IllegalArgumentException {
return delegate.add(asset, target, name);
}
@Override
public T add(final Asset asset, final String target, final String name) throws IllegalArgumentException {
return delegate.add(asset, target, name);
}
@Override
public T add(final NamedAsset namedAsset) throws IllegalArgumentException {
return delegate.add(namedAsset);
}
@Override
public T add(final Asset asset, final String target) throws IllegalArgumentException {
return delegate.add(asset, target);
}
@Override
public T addAsDirectory(final String path) throws IllegalArgumentException {
return delegate.addAsDirectory(path);
}
@Override
public T addAsDirectories(final String... paths) throws IllegalArgumentException {
return delegate.addAsDirectories(paths);
}
@Override
public T addAsDirectory(final ArchivePath path) throws IllegalArgumentException {
return delegate.addAsDirectory(path);
}
@Override
public T addAsDirectories(final ArchivePath... paths) throws IllegalArgumentException {
return delegate.addAsDirectories(paths);
}
@Override
public T addHandlers(final ArchiveEventHandler... handlers) {
return delegate.addHandlers(handlers);
}
@Override
public Node get(final ArchivePath path) throws IllegalArgumentException {
return delegate.get(path);
}
@Override
public Node get(final String path) throws IllegalArgumentException {
return delegate.get(path);
}
@Override
public <X extends Archive<X>> X getAsType(final Class<X> type, final String path) {
return delegate.getAsType(type, path);
}
@Override
public <X extends Archive<X>> X getAsType(final Class<X> type, final ArchivePath path) {
return delegate.getAsType(type, path);
}
@Override
public <X extends Archive<X>> Collection<X> getAsType(final Class<X> type, final Filter<ArchivePath> filter) {
return delegate.getAsType(type, filter);
}
@Override
public <X extends Archive<X>> X getAsType(final Class<X> type, final String path, final ArchiveFormat archiveFormat) {
return delegate.getAsType(type, path, archiveFormat);
}
@Override
public <X extends Archive<X>> X getAsType(final Class<X> type, final ArchivePath path, final ArchiveFormat archiveFormat) {
return delegate.getAsType(type, path, archiveFormat);
}
@Override
public <X extends Archive<X>> Collection<X> getAsType(final Class<X> type, final Filter<ArchivePath> filter, final ArchiveFormat archiveFormat) {
return delegate.getAsType(type, filter, archiveFormat);
}
@Override
public boolean contains(final ArchivePath path) throws IllegalArgumentException {
return delegate.contains(path);
}
@Override
public boolean contains(final String path) throws IllegalArgumentException {
return delegate.contains(path);
}
@Override
public Node delete(final ArchivePath path) throws IllegalArgumentException {
return delegate.delete(path);
}
@Override
public Node delete(final String archivePath) throws IllegalArgumentException {
return delegate.delete(archivePath);
}
@Override
public Map<ArchivePath, Node> getContent() {
return delegate.getContent();
}
@Override
public Map<ArchivePath, Node> getContent(final Filter<ArchivePath> filter) {
return delegate.getContent(filter);
}
@Override
public T filter(final Filter<ArchivePath> filter) {
return delegate.filter(filter);
}
@Override
public T add(final Archive<?> archive, final ArchivePath path, final Class<? extends StreamExporter> exporter) throws IllegalArgumentException {
return delegate.add(archive, path, exporter);
}
@Override
public T add(final Archive<?> archive, final String path, final Class<? extends StreamExporter> exporter) throws IllegalArgumentException {
return delegate.add(archive, path, exporter);
}
@Override
public T merge(final Archive<?> source) throws IllegalArgumentException {
return delegate.merge(source);
}
@Override
public T merge(final Archive<?> source, final Filter<ArchivePath> filter) throws IllegalArgumentException {
return delegate.merge(source, filter);
}
@Override
public T merge(final Archive<?> source, final ArchivePath path) throws IllegalArgumentException {
return delegate.merge(source, path);
}
@Override
public T merge(final Archive<?> source, final String path) throws IllegalArgumentException {
return delegate.merge(source, path);
}
@Override
public T merge(final Archive<?> source, final ArchivePath path, final Filter<ArchivePath> filter) throws IllegalArgumentException {
return delegate.merge(source, path, filter);
}
@Override
public T merge(final Archive<?> source, final String path, final Filter<ArchivePath> filter) throws IllegalArgumentException {
return delegate.merge(source, path, filter);
}
@Override
public T move(final ArchivePath source, final ArchivePath target) throws IllegalArgumentException, IllegalArchivePathException {
return delegate.move(source, target);
}
@Override
public T move(final String source, final String target) throws IllegalArgumentException, IllegalArchivePathException {
return delegate.move(source, target);
}
@Override
public String toString() {
return delegate.toString();
}
@Override
public String toString(final boolean verbose) {
return delegate.toString(verbose);
}
@Override
public String toString(final Formatter formatter) throws IllegalArgumentException {
return delegate.toString(formatter);
}
@Override
public void writeTo(final OutputStream outputStream, final Formatter formatter) throws IllegalArgumentException {
delegate.writeTo(outputStream, formatter);
}
@Override
public Archive<T> shallowCopy() {
return delegate.shallowCopy();
}
@Override
public Archive<T> shallowCopy(final Filter<ArchivePath> filter) {
return delegate.shallowCopy(filter);
}
@Override
public <TYPE extends Assignable> TYPE as(final Class<TYPE> clazz) {
return delegate.as(clazz);
}
}