package objectAdapter;

import java.net.*;
import java.io.*;

public class Datei
{
 private File file=null;

 public static final char separatorChar=File.separatorChar;
 public static final String separator=File.separator;
 public static final char pathSeparatorChar=File.pathSeparatorChar;
 public static final String pathSeparator=File.pathSeparator;

 public Datei();
 public Datei(File parent, String child);
 public Datei(String pathname);
 public Datei(String parent, String child);

  public String getName();
  public String getParent();
  public boolean canRead();
  public boolean canWrite();
  public boolean exists();
  public boolean isDirectory();
  public boolean isFile();
  public long lastModified();
  public long length();
  public boolean createNewFile();
  public boolean delete();
  public String[] list();
  public Datei[] listFiles();
  public boolean mkdir();
  public boolean mkdirs();
}
  

package objectAdapter;

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.zip.*;

public class ZipFileAdapter extends Datei
{
 private ZipFile zipFile=null;
 private ArrayList children=new ArrayList();

// opens the ZIP-file by its name
 public ZipFileAdapter(String zipFileName) throws IOException
 {
  super(zipFileName);
  zipFile=new ZipFile(zipFileName);
  findChildren();
 }

// sucht die Root-Objecte heraus
 private void findChildren()
 {
  Enumeration einträge=zipFile.entries();
  while (einträge.hasMoreElements())
  {
   ZipEntry eintrag=(ZipEntry)einträge.nextElement();
   if (getPath(eintrag.getName()).equals(""))
   {
    children.add(new ZipEntryAdapter(this, eintrag, zipFile));
   }
  }
 }

// Zielmethoden
 public boolean canRead(){return true;} // Es kann eigentlich immer gelesen werden
 public boolean canWrite(){return false;} // Das Schreiben in ein Archiv verbieten wir mal schön

 public boolean createNewFile(){return false;} // wir erlauben hier kein erstellen eines Archives
 public boolean delete(){return false;} // ebenfalls löschen wir auch keine Archive

 public boolean isDirectory(){return true;} // wir behandeln das ZIP-File als Verzeichnis
 public boolean isFile(){return false;} // natürlich ist das kein normales File

 public boolean exists() {return true;} // Blöde Frage, na klar existiert das File

 public boolean mkdir(){return false;} // kein Verzeichnis dieser Art erstellen
 public boolean mkdirs(){return false;} // gleicher Grund
 public long lastModified() {return 0;} // Wir geben dem kein Datum
 public long length(){return 0;} // Ein Verzeichnis hat keine Größe

 public String[] list() // Falls es ein Verzeichnis ist dessen Unterverzeichnisse/-dateien liefern
 {
  if (children!=null)
  {
   String liste[]=new String[children.size()];
   int i;
    for (i=0;i<children.size();i++)
    {
     liste[i]=((ZipEntryAdapter)children.get(i)).getName();
    }
   return liste;
  } else {return null;}
 }

 public Datei[] listFiles() // Falls es ein Verzeichnis ist dessen Unterverzeichnisse/-dateien liefern
 {
  if (children!=null)
  {
   Datei liste[]=new Datei[children.size()];
   int i;
    for (i=0;i<children.size();i++)
    {
     liste[i]=(Datei)children.get(i);
    }
   return liste;
  } else return null;
 }

 private String getPath(String s)
 {
  int i;
  if (((i=s.lastIndexOf(Datei.separator))!=-1)&&(!s.endsWith(Datei.separator)))  {return s.substring(0, i);}
  else { String str=s.substring(0, i);
         if ((i=str.lastIndexOf(Datei.separator))!=-1) return str.substring(0,i);
         else return "";
       }
 }
}
  

package objectAdapter;

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.zip.*;

class ZipEntryAdapter extends Datei
{
 protected ZipEntry zipEntry=null;
 protected Datei parent=null;
 protected ArrayList children=null;
 protected ZipFile zipFile=null;

 ZipEntryAdapter(Datei parent, ZipEntry entry, ZipFile zipFile)
 {
  this.zipFile=zipFile;
  this.parent=parent;
  zipEntry=entry;
  if (isDirectory()==true){findSubEntries();}
 }

// Hilfsmethode zum Suchen der Unterdateien/-verzeichnisse
 private void findSubEntries()
 {
  children=new ArrayList();
  Enumeration einträge=zipFile.entries();
  while (einträge.hasMoreElements()==true)
  {
   ZipEntry eintrag=(ZipEntry)einträge.nextElement();
    if ((eintrag!=zipEntry)&&(zipEntry.getName().equals(getPath(eintrag.getName())+Datei.separator)))
    {
     children.add(new ZipEntryAdapter(this, eintrag, zipFile));
    }
  }
 }

// Zielmethoden
 public boolean canRead(){return true;} // Es kann eigentlich immer gelesen werden
 public boolean canWrite(){return false;} // Das Schreiben in ein Archiv verbieten wir mal schön

 public boolean createNewFile(){return false;} // wir erlauben hier kein erstellen eines Archives
 public boolean delete(){return false;} // ebenfalls löschen wir auch keine Archive

 public boolean isDirectory(){return zipEntry.isDirectory();} // dieser Eintrag ist nur eine stinknormale Datei
 public boolean isFile(){return !zipEntry.isDirectory();} // natürlich ist das ein normales File

 public boolean exists() {return true;} // Blöde Frage, na klar existiert das File

 public boolean mkdir(){return false;} // kein Verzeichnis dieser Art erstellen
 public boolean mkdirs(){return false;} // gleicher Grund
 public long lastModified() {return zipEntry.getTime();} // Datum vom Zip übernehmen
 public long length(){return zipEntry.getSize();} // Größe liefern

 public String getParent(){return parent.getName();}

 public String getName() {return zipEntry.getName();}

 public String[] list() // Falls es ein Verzeichnis ist dessen Unterverzeichnisse/-dateien liefern
 {
  if (children!=null)
  {
   String liste[]=new String[children.size()];
   int i;
    for (i=0;i<children.size();i++)
    {
     liste[i]=((ZipEntryAdapter)children.get(i)).getName();
    }
   return liste;
  } else {return null;}
 }

 public Datei[] listFiles() // Falls es ein Verzeichnis ist dessen Unterverzeichnisse/-dateien liefern
 {
  if (children!=null)
  {
   Datei liste[]=new Datei[children.size()];
   int i;
    for (i=0;i<children.size();i++)
    {
     liste[i]=(Datei)children.get(i);
    }
   return liste;
  } else return null;
 }

 private String getPath(String s)
 {
  int i;
  if (((i=s.lastIndexOf(Datei.separator))!=-1)&&(!s.endsWith(Datei.separator)))  {return s.substring(0, i);}
  else { String str=s.substring(0, i);
         if ((i=str.lastIndexOf(Datei.separator))!=-1) return str.substring(0,i);
         else return "";
       }
 }
}
  

package objectAdapter;

import java.io.*;
import java.util.*;

public class test
{
 ZipFileAdapter zipFile;

  private void listF(Datei file)
  {
   System.out.print(file.getName()+"; ");
   if (file.isDirectory()) {System.out.print("directory; ");} else {System.out.print(file.length()); System.out.print(";  ");}
   System.out.println(new Date(file.lastModified()).toString());
   if (file.isDirectory())
   {
    Datei f[]=file.listFiles();
    int i;
     for (i=0;i<f.length;i++)
     {
      listF(f[i]);
     }
   }
  }

  public test(String fileName) throws IOException
  {
   zipFile=new ZipFileAdapter(fileName);
   listF(zipFile);
  }

  public static void main(String[] args)
  {
   try
   {
    new test("test.zip");
   } catch (IOException e) {System.out.println(e.toString());};
  }
}
  

class ZipFile  
 creation Init
 feature {NONE}
  dateiName: String;
  
 feature
  init(FileName: String) is do dateiName:=FileName; end
  entries:Array[ZipEntry] is local a: Array[ZipEntry] do !!a.make(0,0); result:=a; end
  getEntry(entryName:String):ZipEntry is do result:=void; end
  getName:String is do result:=dateiName; end
  size:Integer is do result:=0; end
end
  

class ZipEntry
 feature {NONE}
  zipEntryName: String;
  groesse: Integer;
  zeit: Date;
  directory: boolean;
 feature
  getName: String is do result:=zipEntryName; end
  getSize: Integer is do result:=groesse; end
  getTime: Date is do result:=zeit; end
  isDirectory: boolean is do result:=directory; end
end
  

class Datei
 creation Init

 feature {NONE}
  dateiName: String;
  parent: Datei;
  read, write, directory, file: boolean;
  groesse: Integer;
  datum: Date;

 feature {ANY}
  Init(fileName: String) is do dateiName:=fileName; !!datum.set_to_now; end

  getName: String is do result:=dateiName; end
  getParent: String is do result:=parent.getName; end
  canRead: Boolean is do result:=read; end
  canWrite: Boolean is do result:=write; end
  exists: Boolean is do result:=true; end
  isDirectory: Boolean is do result:=directory end
  isFile: Boolean is do result:=file end
  lastModified: Date is do result:=datum; end
  length: Integer is do result:=groesse; end
  createNewFile: boolean is do result:=true; end
  delete: boolean is do result:=true end
  list: Array[String] is do result:=void end
  listFiles: Array[Datei] is do result:=void end
  mkdir: boolean is do result:=true end
  mkdirs: boolean is do result:=true end
end
  

class ZipFileAdapter
 inherit Datei
  rename Init as DateiInit

  redefine canRead, canWrite, createNewFile, delete, isDirectory, isFile, exists, mkdir, mkdirs, lastModified, length, list, listFiles
 end

 creation Init

 feature {NONE}
  zipDatei: ZipFile;

 feature {ANY}
  Init(ZipFileName: String) is
  do 
   DateiInit(ZipFileName);
   !!zipDatei.Init(ZipFileName);
  end

  canRead: boolean is do result:=true; end
  canWrite: boolean is do result:=false; end
  createNewFile: boolean is do result:=false; end
  delete: boolean is do result:=false; end
  isDirectory: boolean is do result:=true; end
  isFile: boolean is do result:=false; end
  exists: boolean is do result:=true; end
  mkdir: boolean is do result:=false; end
  mkdirs: boolean is do result:=false; end
  lastModified: Date is local d: Date do !!d.set_date(1970, 1, 1); result:=d; end
  length: Integer is do result:=0; end
  
  list: Array[String] is
  local sa:Array[String]; za:Array[ZipEntry]; i:Integer;
  do
   za:=zipDatei.entries;
   !!sa.make(za.lower, za.upper);
   from i:=za.lower
    until i>=za.upper
    loop
     sa.put(za.item(i).getName ,i);
   end
   result:=sa; 
  end
  
  listFiles: Array[Datei] is
  local da:Array[Datei]; za:Array[ZipEntry]; i:Integer; d:Datei;
  do
   za:=zipDatei.entries;
   !!da.make(za.lower, za.upper);
   from i:=za.lower
    until i>=za.upper
    loop
     !ZipEntryAdapter!d.Init(za.item(i));
     da.put(d ,i);
   end
   result:=da;
  end
end
  

class ZipEntryAdapter
 inherit Datei
  rename Init as DateiInit
  redefine canRead, canWrite, createNewFile, delete, isDirectory, isFile, exists, mkdir, mkdirs, lastModified, length, list, listFiles
 end;
 creation Init
 feature {NONE}
  zEntry: ZipEntry;
  children: Array[ZipEntry];
  
 feature
  Init(z: ZipEntry) is
  do
   zEntry:=z;
  end

  canRead: boolean is do result:=true; end
  canWrite: boolean is do result:=false; end
  createNewFile: boolean is do result:=false; end
  delete: boolean is do result:=false; end  
  isDirectory: boolean is do result:=zEntry.isDirectory; end
  isFile: boolean is do result:=not zEntry.isDirectory; end
  exists: boolean is do result:=true; end
  mkdir: boolean is do result:=false; end
  mkdirs: boolean is do result:=false; end
  lastModified: Date is do result:=zEntry.getTime; end
  length: Integer is do result:=zEntry.getSize; end

  list: Array[String] is
  local sa:Array[String]; i:Integer
  do
   !!sa.make(children.lower, children.upper);
   from i:=children.lower
    until i>=children.upper
    loop
     sa.put(children.item(i).getName, i);
   end
   result:=sa;
  end
  
  listFiles: Array[Datei] is
  local da:Array[Datei]; i:Integer; d:Datei
  do
   !!da.make(children.lower, children.upper);
    from i:=children.lower
    until i>=children.upper
    loop
     !ZipEntryAdapter!d.init(children.item(i));
     da.put(d, i);
   end
   result:=da;
  end  
end