public  void addScanDir(URL url,
    Comparator comp,
    FileFilter filter) 
{
      Scanner scanner = new DirScanner(url, comp, filter);
      addScanner(scanner);
}

 public  void addScanDir(String urlSpec,
    String compClassName,
    String filterClassName) throws MalformedURLException 
{
      
      URL url = toUrl(urlSpec);
      // create a new comparator
      Comparator comp = null;
      if (compClassName != null)
      {
         try
         {
            Class compClass = Thread.currentThread().getContextClassLoader().loadClass("compClassName");
            comp = (Comparator)compClass.newInstance();
         } catch (Exception e)
         {
            log.warn("Unable to create instance of Comparator.  Ignoring.", e);
         }
      }
      // create a new filter
      FileFilter filter = null;
      if (filterClassName != null)
      {
         try
         {
            Class filterClass = Thread.currentThread().getContextClassLoader().loadClass(filterClassName);
            filter = (FileFilter)filterClass.newInstance();
         } catch (Exception e)
         {
            log.warn("Unable to create instance of Filter.  Ignoring.", e);
         }
      }
      addScanDir(url, comp, filter);
}

 public  void addScanURL(URL url) 
{
   
      Scanner scanner = new Scanner(url);
      addScanner(scanner);
}

 public  void addScanURL(String url) throws MalformedURLException 
{
      addScanURL(toUrl(url));
}

 Deployer getDeployerObj() 
{
      return deployer;
}

This is a workaround for a bug in Sun's JVM 1.3 on windows (any others??). Inner classes can not directly access protected members from the outer-class's super class.

 public String getFilter() 
{
      if (defaultFilter == null)
      {
         return null;
      }
      return defaultFilter.getClass().getName();
}

 public String getURLComparator() 
{
      if (defaultComparator == null)
      {
         return null;
      }
      return defaultComparator.getClass().getName();
}

 public ObjectName preRegister(MBeanServer server,
    ObjectName name) throws Exception 
{
      
      // get server's home for relative paths, need this for setting
      // attribute final values, so we need todo it here
      serverHome = ServerConfigLocator.locate().getServerHomeDir();
      return super.preRegister(server, name);
}

Obtain the Service values. This was copied from Jason Dillons URLDeploymentScanner. Thanks Jason!

 public  void removeScanURL(URL url) 
{
      synchronized (scanners)
      {
         if (isScanEnabled())
         {
            // Scan is enabled, so apply changes to a local copy
            // this enables the scan to occur while things are added
            ArrayList localScanners = new ArrayList(scanners);
            HashMap localMap = new HashMap(urlScannerMap);
            Scanner scanner = (Scanner)localMap.remove(url);
            if (scanner != null)
            {
               localScanners.remove(scanner);
            }
            scanners = localScanners;
            urlScannerMap = localMap;
         } else
         {
            // no need for precautions... just remove
            Scanner scanner = (Scanner)urlScannerMap.remove(url);
            if (scanner != null)
            {
               scanners.remove(scanner);
            }
         }
      }
}

 public  void scan() 
{
      log.trace("Scanning urls...");
      // just scan all the scanners
      for (Iterator iter = scanners.iterator(); iter.hasNext(); )
      {
         ((Scanner)iter.next()).scan();
      }
}

Scan all urls.

 public  void setFilter(String filterClassName) 
{
      log.debug("Setting Filter: " + filterClassName);
      try
      {
         defaultFilter = (FileFilter)Thread.currentThread().getContextClassLoader().loadClass(filterClassName).newInstance();
      } catch (Exception e)
      {
         log.warn("Unable to create URLComparator.", e);
      }
}

 public  void setURLComparator(String comparatorClassName) 
{
      log.debug("Setting Comparator: " + comparatorClassName);
      try
      {
         defaultComparator = (Comparator)Thread.currentThread().getContextClassLoader().loadClass(comparatorClassName).newInstance();
      } catch (Exception e)
      {
         log.warn("Unable to create URLComparator.", e);
      }
}

 public  void setURLs(Element elem) 
{
      // create local versions of these collections
      ArrayList localScanners = new ArrayList();
      HashMap localMap = new HashMap();
      NodeList list = elem.getChildNodes();
      synchronized (scanners)
      {
         // clear lists
         scanners.clear();
         urlScannerMap.clear();
         // populate from xml....
         for (int i = 0; i <  list.getLength(); i++)
         {
            Node node = list.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
               NamedNodeMap nodeMap = node.getAttributes();
               String name = getNodeValue(nodeMap.getNamedItem("name"));
               if (name == null)
               {
                  log.warn("No name specified in URLDirectoryScanner config: " +
                  node + ".  Ignoring");
                  continue;
               }
               try
               {
                  if (node.getNodeName().equals("dir"))
                  {
                     // get the filter and comparator
                     String filter = getNodeValue(nodeMap.getNamedItem("filter"));
                     String comp = getNodeValue(nodeMap.getNamedItem("comparator"));
                     addScanDir(name, comp, filter);
                  } else if (node.getNodeName().equals("url"))
                  {
                     addScanURL(name);
                  }
               } catch (MalformedURLException e)
               {
                  log.warn("Invalid url in DeploymentScanner.  Ignoring.", e);
               }
            }
         }
      }
}