CompressResource.java

package railo.commons.io.res.type.compress;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import railo.commons.io.res.Resource;
import railo.commons.io.res.ResourceProvider;
import railo.commons.io.res.util.ResourceSupport;
import railo.commons.io.res.util.ResourceUtil;
import railo.commons.lang.StringUtil;

public final class CompressResource extends ResourceSupport {

	private final CompressResourceProvider provider;
	private final Compress zip;
	private final String path;
	private final String name;
	private final String parent;
	private final boolean caseSensitive; 

	/**
	 * Constructor of the class
	 * @param provider
	 * @param zip
	 * @param path
	 * @param caseSensitive
	 */
	CompressResource(CompressResourceProvider provider, Compress zip, String path, boolean caseSensitive) {
		if(StringUtil.isEmpty(path)) path="/";
		this.provider=provider;
		this.zip=zip; 
		this.path=path;
		
		if("/".equals(path)) {
			this.parent=null;
			this.name="";
		}
		else {
			String[] pn = ResourceUtil.translatePathName(path);
			this.parent=pn[0];
			this.name=pn[1];
		}
		
		this.caseSensitive=caseSensitive;
	}

	/**
	 * @return return ram resource that contain the data
	 */
	private Resource getRamResource() {
		return zip.getRamProviderResource(path);
	}

	@Override
	public boolean exists() {
		try {
			provider.read(this);
		} 
		catch (IOException e) {
			return false;
		}
		return getRamResource().exists();
	}

	@Override
	public InputStream getInputStream() throws IOException {
		ResourceUtil.checkGetInputStreamOK(this);
		return getRamResource().getInputStream();
	}
	
	public Resource getCompressResource() {
		return zip.getCompressFile();
	}
	
	public String getCompressPath() {
		return path;
	}

	@Override
	public String getName() {
		return name;
	}

	@Override
	public String getParent() {
		if(StringUtil.isEmpty(parent))return null;
		return provider.getScheme().concat("://").concat(zip.getCompressFile().getPath()).concat("!").concat(parent);
	}

	@Override
	public Resource getParentResource() {
		if(StringUtil.isEmpty(parent))return null;
		return new CompressResource(provider,zip,parent,caseSensitive);
	}

	@Override
	public String getPath() {
		return provider.getScheme().concat("://").concat(zip.getCompressFile().getPath()).concat("!").concat(path);
	}

	@Override
	public Resource getRealResource(String realpath) {
		realpath=ResourceUtil.merge(path, realpath);
		if(realpath.startsWith("../"))return null;
		return new CompressResource(provider,zip,realpath,caseSensitive);
	}

	@Override
	public ResourceProvider getResourceProvider() {
		return provider;
	}

	@Override
	public boolean isAbsolute() {
		return getRamResource().isAbsolute();
	}

	@Override
	public boolean isDirectory() {
		return getRamResource().isDirectory();
	}

	@Override
	public boolean isFile() {
		return getRamResource().isFile();
	}

	@Override
	public boolean isReadable() {
		return getRamResource().isReadable();
	}

	@Override
	public boolean isWriteable() {
		return getRamResource().isWriteable();
	}

	@Override
	public long lastModified() {
		return getRamResource().lastModified();
	}

	@Override
	public long length() {
		return getRamResource().length();
	}

	@Override
	public Resource[] listResources() {
		String[] names = list();
		if(names==null) return null;
		Resource[] children = new Resource[names.length];
		for(int i=0;i<children.length;i++) {
			children[i]=new CompressResource(provider,zip,path.concat("/").concat(names[i]),caseSensitive);
		}
		return children;
	}
	
	@Override
	public String[] list() {
		return getRamResource().list();
	}

	@Override
	public void remove(boolean force) throws IOException {
		Resource rr = getRamResource();
		if(rr.getParent()==null) 
			throw new IOException("can't remove root resource ["+getPath()+"]");
		
		if(!rr.exists())
			throw new IOException("can't remove resource ["+getPath()+"],resource does not exist");
		
		Resource[] children = listResources();
		if(children!=null && children.length>0) {
			if(!force) {
				throw new IOException("can't delete directory ["+getPath()+"], directory is not empty");
			}
			for(int i=0;i<children.length;i++) {
				children[i].remove(true);
			}
		}
		rr.remove(force);
	}

	@Override
	public boolean setLastModified(long time) {
		boolean lm = getRamResource().setLastModified(time);
		zip.synchronize(provider.async);
		return lm;
	}
	
	@Override
	public void createDirectory(boolean createParentWhenNotExists) throws IOException {
		ResourceUtil.checkCreateDirectoryOK(this,createParentWhenNotExists);
		getRamResource().createDirectory(createParentWhenNotExists);
		zip.synchronize(provider.async);
	}

	@Override
	public void createFile(boolean createParentWhenNotExists) throws IOException {
		ResourceUtil.checkCreateFileOK(this,createParentWhenNotExists);
		getRamResource().createFile(createParentWhenNotExists);
		zip.synchronize(provider.async);
	}

	@Override
	public OutputStream getOutputStream() throws IOException {
		ResourceUtil.checkGetOutputStreamOK(this);
		//Resource res = getRamResource();
		//Resource p = res.getParentResource();
		//if(p!=null && !p.exists())p.mkdirs();
		return new CompressOutputStreamSynchronizer(getRamResource().getOutputStream(),zip,provider.async);
	}

	@Override
	public OutputStream getOutputStream(boolean append) throws IOException {
		return new CompressOutputStreamSynchronizer(getRamResource().getOutputStream(append),zip,provider.async);
	}

	@Override
	public int getMode() {
		return getRamResource().getMode();
	}

	@Override
	public void setMode(int mode) throws IOException {
		getRamResource().setMode(mode);
		zip.synchronize(provider.async);
		
	}

	@Override
	public boolean setReadable(boolean value) {
		if(!isFile())return false;
		getRamResource().setReadable(value);
		zip.synchronize(provider.async);
		return true;
	}

	@Override
	public boolean setWritable(boolean value) {
		if(!isFile())return false;
		getRamResource().setWritable(value);
		zip.synchronize(provider.async);
		return true;
	}

}