Source code: dr/davmgr/protocol/DefaultUrls.java

   package dr.davmgr.protocol;
   
   import java.util.Hashtable;
   import java.util.Vector;
   import java.util.Enumeration;
   import java.util.ListIterator;
   import java.util.List;
   import java.net.URL;
   
  import dr.mime.MIMEType;
  
  public class DefaultUrls implements Urls
  {
    protected Hashtable attributes = new Hashtable();
  
    protected boolean collection = false;
  
    protected boolean read = false;
    protected boolean writeable = false;
    protected boolean readable = false;
    protected boolean locked   = false;
    protected boolean lockable = false;
  
    protected Vector childUrls = null;
    protected Urls parent = null;
  
    protected ProtocolHandler protocolHandler = null;
  
    protected boolean reading = true;
  
    public URL getURL() { return (URL)getAttribute(A_URL); }
    
    public String getFilename() { 
      return (String)getAttribute(A_FILENAME);
    }  
  
    public long getLastModified() {
      Long v;
      if ((v=(Long)getAttribute(A_LASTMODIFIED))==null) return -1;
      long vl;
      try {
        vl=((Long)v).longValue();
      } catch (NumberFormatException nfe) {
        return -1;
      }  
      return vl;
    }
    
    public MIMEType getMIMEType() { 
      return (MIMEType)getAttribute(A_MIMETYPE);
    }
  
    
    public Hashtable getAttributes() { return attributes; }
    
    public Object getAttribute(Object attribute) {
      if ((attributes==null)||(attribute==null)) return null;
      return attributes.get(attribute);
    }
    public void addAttribute(String attribute, Object value) {
      if ((attribute==null)||(value==null)) return;
      if (attributes==null) attributes=new Hashtable();
      attributes.put(attribute, value);
    }
    public boolean isReadable() { return readable; }
    public boolean isWriteable() { return writeable; }
    public boolean isLockable() { return lockable; }
    public boolean isLocked()   { return locked; }
    
    public boolean isCollection() { return collection; }  
    public boolean isLeaf() { return !isCollection(); }
    public boolean isRead() { return read; }
  
    public ProtocolHandler getProtocolHandler() {
      return protocolHandler;
    }  
  
    public void setUnread() {
      if (childUrls!=null) {
        DefaultUrls du;
        for (Enumeration e = childUrls.elements(); e.hasMoreElements();) {
    du = (DefaultUrls)e.nextElement();
    du.setParent(null);
    du.setUnread();
        }
      }
      childUrls=null;
      setRead(false);
    }
    public List getAll() { return childUrls; }
    public List getCollections() {
      if (childUrls==null) return null;
      Vector c = new Vector();
      for (Enumeration e=childUrls.elements(); e.hasMoreElements();) {
        Urls urls = (Urls) e.nextElement();
        if (urls.isCollection()) c.add(urls);
      }
      if (c.size()==0) return null;
      return c;
   }
   public List getFiles() {
     if (childUrls==null) return null;
     Vector f = new Vector();
     for (Enumeration e=childUrls.elements(); e.hasMoreElements();) {
       Urls urls = (Urls) e.nextElement();
       if (!urls.isCollection()) f.add(urls);
     }
     if (f.size()==0) return null;
     return f;
   }
 
   public Urls getParent() {
     return parent;
   }  
 
   public boolean isReading() {
     return reading;
   }
 
   public int compareTo(Object o) {
     return toString().compareTo(o.toString());
   }
   public String toString() {
     if (attributes==null) return super.toString();
     if (attributes.get(A_FILENAME)!=null) 
       return (String)attributes.get(A_FILENAME);
     else if (attributes.get(A_URL)!=null) 
       return ((URL)attributes.get(A_URL)).toString();
     return super.toString();  
   }
 
 // for convenience :  
   public void setURL(URL url) {
     addAttribute(A_URL, url);
   }
   
   public void setFilename(String filename) {
     addAttribute(A_FILENAME, filename);
   }
 
   public void setLastModified(long lastModified) {
     addAttribute(A_LASTMODIFIED, new Long(lastModified));
   }
   
   public void setMIMEType(MIMEType mimeType) {
     addAttribute(A_MIMETYPE, mimeType);
   }
 
   public void setCollection(boolean collection) {
     this.collection=collection;
     addAttribute(A_COLLECTION, new Boolean(collection));
   }  
 
   public void setReadable(boolean readable) { 
     this.readable=readable; 
     addAttribute(A_READABLE, new Boolean(readable));
   }
   
   public void setWriteable(boolean writeable) { 
     this.writeable=writeable;
     addAttribute(A_WRITEABLE, new Boolean(writeable));
   }
   
   public void setLockable(boolean lockable) { 
     this.lockable=lockable; 
     addAttribute(A_LOCKABLE, new Boolean(lockable));
   }
   
   public void setLocked(boolean locked) { 
     this.locked=locked; 
     addAttribute(A_LOCKED, new Boolean(locked));
   }
 
   public void setRead(boolean read) { 
     this.read=read; 
     addAttribute(A_READ, new Boolean(locked));
   }
 
   public void addChildUrls(Urls urls) {
     if (childUrls==null) childUrls = new Vector();
     childUrls.add(urls);
     collection=true;
   }
   public boolean removeChildUrls(Urls urls) {
     if ((childUrls==null)||(urls==null)) return false;
     return childUrls.remove(urls);
   }
   
   public void setParent(Urls parent) { this.parent=parent; }
 
   public void setProtocolHandler(ProtocolHandler protocolHandler) {
     this.protocolHandler=protocolHandler;
   }
 
   public void setAttributes(Hashtable attributes) {
     this.attributes=attributes;
   }
   public void setChildUrls(Vector childUrls) {
     this.childUrls=childUrls;
   }
 
   public void setReading(boolean reading) {
     this.reading=reading;
   }
 }