gt:                     URI id = new URI(elem.getTextValue());
context: /*
   *  Copyright (c) 2001 Sun Microsystems, Inc.  All rights
   *  reserved.
   *
   *  Redistribution and use in source and binary forms, with or without
   *  modification, are permitted provided that the following conditions
   *  are met:
   *
   *  1. Redistributions of source code must retain the above copyright
   *  notice, this list of conditions and the following disclaimer.
   *
   *  2. Redistributions in binary form must reproduce the above copyright
   *  notice, this list of conditions and the following disclaimer in
   *  the documentation and/or other materials provided with the
   *  distribution.
   *
   *  3. The end-user documentation included with the redistribution,
   *  if any, must include the following acknowledgment:
   *  "This product includes software developed by the
   *  Sun Microsystems, Inc. for Project JXTA."
   *  Alternately, this acknowledgment may appear in the software itself,
   *  if and wherever such third-party acknowledgments normally appear.
   *
   *  4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
   *  not be used to endorse or promote products derived from this
   *  software without prior written permission. For written
   *  permission, please contact Project JXTA at http://www.jxta.org.
   *
   *  5. Products derived from this software may not be called "JXTA",
   *  nor may "JXTA" appear in their name, without prior written
   *  permission of Sun.
   *
   *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   *  DISCLAIMED.  IN NO EVENT SHALL SUN MICROSYSTEMS OR
   *  ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   *  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   *  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   *  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   *  SUCH DAMAGE.
   *  ====================================================================
   *
   *  This software consists of voluntary contributions made by many
   *  individuals on behalf of Project JXTA.  For more
   *  information on Project JXTA, please see
   *  <http://www.jxta.org/>.
   *
   *  This license is based on the BSD license adopted by the Apache Foundation.
   *
   *  $Id: AccessList.java,v 1.1 2007/01/16 11:01:51 thomas Exp $
   */
  package net.jxta.impl.access;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.InputStream;
  import java.io.IOException;
  import java.lang.reflect.UndeclaredThrowableException;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Iterator;
  import net.jxta.document.Attributable;
  import net.jxta.document.Attribute;
  import net.jxta.document.Document;
  import net.jxta.document.Element;
  import net.jxta.document.MimeMediaType;
  import net.jxta.document.StructuredDocument;
  import net.jxta.document.StructuredDocumentFactory;
  import net.jxta.document.StructuredTextDocument;
  import net.jxta.document.TextElement;
  import net.jxta.id.ID;
  import net.jxta.id.IDFactory;
  
  import org.apache.log4j.Level;
  import org.apache.log4j.Logger;
  
  
  /**
   *  PeerView ACL is described as follows <p/>
   */
  public class AccessList {
      private final static String peerTag = "peer";
      private final static String nameTag = "name";
      private final static String descriptionTag = "description";
      private final static String accessTag = "access";
      private final static String grantAllTag = "grantAll";
      private final static String deny = "deny";
      private final static String grant = "grant";
      private final static String idTag = "ID";
      protected Map accessMap = new HashMap();
      String description = null;
      boolean grantAll = false;
      /**
       *  Log4J Logger
       **/
      private static final transient Logger LOG = Logger.getLogger(AccessList.class.getName());
      /**
       *  Default Constructor
       */
      public AccessList() { }
      /**
       *  Intialize access list from an InputStream
       */
      public AccessList(InputStream stream) throws IOException {
          init(stream);
      }
      
      /**
       *  Intialize access list from a file
       *  @param fromFile file to init from
       *  @throws IOException if an io error occurs
       */
      public void init(File fromFile) throws IOException {
          InputStream is = new FileInputStream(fromFile);
          init(is);
          is.close();
      }
  
      public void refresh(File file) {
          if (file.exists()) {
              try {
                  InputStream is = new FileInputStream(file);
                  refresh(is);
                  is.close();
              } catch (IOException io) {
                  //bad input
              }
          }
      }
      
      public void refresh(InputStream stream) throws IOException {
          AccessList tmp = new AccessList(stream);
          refresh(tmp);
      }
  
      
      private void init(InputStream stream) throws IOException {
          StructuredTextDocument doc = (StructuredTextDocument)
                                       StructuredDocumentFactory.newStructuredDocument(
                                           MimeMediaType.XMLUTF8, stream);
          initialize(doc);
      }
  
      /**
       *  Constructor for the HealthMessage object
       *
       *@param  srcID
       *@param  entries
       */
      public AccessList(Map map) {
          this.accessMap = map;
      }
  
      /**
       *  Construct from a StructuredDocument
       *
       *@param  root  root element
       */
      public AccessList(Element root) {
          TextElement doc = (TextElement) root;
  
          if (!getAdvertisementType().equals(doc.getName())) {
              throw new IllegalArgumentException("Could not construct : " +
                                                 getClass().getName() + "from doc containing a " + doc.getName());
          }
          initialize(doc);
      }
  
      /**
       *  gets the description
       *
       *@return  the document description
       */
      public String getDescrption() {
          return description;
      }
  
      /**
       *  gets the description
       *
       *@return  the document description
       */
      public boolean getGrantAll() {
          return grantAll;
      }
      /**
       *  gets the description
       *
       *@return  the document description
       */
      public void setGrantAll(boolean grantAll) {
          this.grantAll = grantAll;
      }
  
      /**
       *  sets description
       *
       *@param  description  The new description
       */
      public void setDescrption(String description) {
          this.description = description;
      }
  
      /**
       *  sets the entries list
       *
       *@param  list  The new entries value
       */
      public void setEntries(Map map) {
          this.accessMap =map;
      }
  
      /**
       *  sets the entries list
       *
       *@param  list  The new entries value
       */
      private void refresh(AccessList acl) {
          this.accessMap.putAll(acl.accessMap);
      }
  
      public void add(Entry entry) {
          if (!accessMap.containsKey(entry.id)) {
              accessMap.put(entry.id, entry);
          }
      }
  
      public void remove(Entry entry) {
          if (accessMap.containsKey(entry.id)) {
              accessMap.remove(entry.id);
          }
      }
  
      public boolean isAllowed(ID id) {
          if (grantAll) {
              return true;
          } else if (accessMap.containsKey(id)) {
              Entry entry = (Entry) accessMap.get(id);
              return entry.access;
          } else {
              return false;
          }
      }
  
      /**
       *  gets the entries list
       *
       *@return     The entries value
       *@returns    List The List containing Entries
       */
      public Map getAccessMap() {
          return accessMap;
      }
      
      /**
       *  {@inheritDoc}
       *
       *@param  asMimeType  mime type encoding
       *@return             The document value
       */
      public Document getDocument(MimeMediaType asMimeType) {
          StructuredDocument adv = (StructuredTextDocument)
                                   StructuredDocumentFactory.newStructuredDocument(asMimeType, getAdvertisementType());
          if (adv instanceof Attributable) {
              ((Attributable) adv).addAttribute("xmlns:jxta", "http://jxta.org");
          }
          Element e;
          e = adv.createElement(grantAllTag, Boolean.valueOf(grantAll).toString());
           adv.appendChild(e);
          if (description != null) {
              e = adv.createElement(descriptionTag, description);
              adv.appendChild(e);
          }
          Iterator it = accessMap.values().iterator();
          while (it.hasNext()) {
              Entry entry = (Entry) it.next();
              if (entry.id == null && entry.name == null) {
                  //skip bad entries
                  continue;
              }
              e = adv.createElement(peerTag, entry.id.toString());
              adv.appendChild(e);
              ((Attributable) e).addAttribute(nameTag, entry.name);
              if (entry.access) {
                  ((Attributable) e).addAttribute(accessTag, grant);
              } else {
                  ((Attributable) e).addAttribute(accessTag, deny);
              }
          }
          return adv;
      }
  
      /**
       *  Process an individual element from the document.
       *
       *@param  doc
       */
      protected void initialize(TextElement doc) {
  
          Enumeration elements = doc.getChildren();
  
          while (elements.hasMoreElements()) {
              TextElement elem = (TextElement) elements.nextElement();
              if (elem.getName().equals(grantAllTag)) {
                  grantAll = Boolean.getBoolean(elem.getTextValue());
                  if (LOG.isEnabledFor(Level.INFO)) {
                      LOG.info("Grant all access = [ "+grantAll+" ]");
                  }
  
              }
              if (elem.getName().equals(descriptionTag)) {
                  description = elem.getTextValue();
                  if (LOG.isEnabledFor(Level.INFO)) {
                      LOG.info("Loading [ "+description+" ] access list :");
                  }
  
              }
              if (elem.getName().equals(peerTag)) {
                  String name = "NA";
                  Attribute nameAttr = ((Attributable) elem).getAttribute(nameTag);
                  if (nameAttr != null) {
                      name = nameAttr.getValue();
                  }
                  String access = "grant";
                  Attribute accessAttr = ((Attributable) elem).getAttribute(accessTag);
                  if (accessAttr != null) {
                      access = accessAttr.getValue();
                  }
                  ID pid = ID.nullID;
                  try {
  