geronimo-scm mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d...@apache.org
Subject svn commit: r394860 [2/3] - in /geronimo/branches/1.1: applications/console-standard/src/java/org/apache/geronimo/console/configmanager/ modules/connector-builder/src/test/org/apache/geronimo/connector/deployment/ modules/deploy-tool/src/java/org/apach...
Date Tue, 18 Apr 2006 06:44:21 GMT
Added: geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/LifecycleMonitor.java
URL: http://svn.apache.org/viewcvs/geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/LifecycleMonitor.java?rev=394860&view=auto
==============================================================================
--- geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/LifecycleMonitor.java (added)
+++ geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/LifecycleMonitor.java Mon Apr 17 23:44:17 2006
@@ -0,0 +1,104 @@
+/**
+ *
+ * Copyright 2005 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.geronimo.kernel.config;
+
+import org.apache.geronimo.kernel.repository.Artifact;
+
+/**
+ * This interface can be used to monitor the progress of an operation on the
+ * configuration manager.  Typically, the monitor will receive a number of
+ * calls to addConfiguration as the configuration manager decides which
+ * configurations will be effected by the operations.  This is followed by a
+ * call to loading, starting, stopping or unloading and then a call to
+ * succeeded or failed for each configuration added.
+ *
+ *
+ * The one notable exception to this is the load operation which calls
+ * addConfiguration and and immediately follows it with a reading and then
+ * succeeded or failed.  This is because the load operation needs to read each
+ * configuration to determine which additional configurations will need to be
+ * loaded.
+ *
+ * When an operation fails, the failed method is called with the cause.  The
+ * configuration manager normally will follow the failure with compensating
+ * actions to bring the server back to the original state.  For example, if it
+ * loaded a configuration, it will unload it.  Each of the compensating
+ * actions will cause events to be fired.
+ *
+ * When the, operation is completed, the finished method will be called.  This
+ *  should be called event if the operation ultimately fails and throws an
+ * exception.  It is recommended that you do not rely the finished method to
+ * be called in the case of an Exception as there are cases that will cause
+ * the configuration manager to immediately return without notification (such
+ * as an AssertionError).
+ * @version $Rev$ $Date$
+ */
+public interface LifecycleMonitor {
+    /**
+     * Adds a configuration to be monitored.
+     * @param configurationId the configuration identifier
+     */
+    void addConfiguration(Artifact configurationId);
+
+    /**
+     * The configuration manager has started reading the specified configuration.
+     * @param configurationId the configuration identifier
+     */
+    void reading(Artifact configurationId);
+
+    /**
+     * The configuration manager has begun loading the specified configuration.
+     * @param configurationId the configuration identifier
+     */
+    void loading(Artifact configurationId);
+
+    /**
+     * The configuration manager has begun starting the specified configuration.
+     * @param configurationId the configuration identifier
+     */
+    void starting(Artifact configurationId);
+
+    /**
+     * The configuration manager has begun stopping the specified configuration.
+     * @param configurationId the configuration identifier
+     */
+    void stopping(Artifact configurationId);
+
+    /**
+     * The configuration manager has begun unloading the specified configuration.
+     * @param configurationId the configuration identifier
+     */
+    void unloading(Artifact configurationId);
+
+    /**
+     * The previous operation on the specified configuration has completed successfully.
+     * @param configurationId the configuration identifier
+     */
+    void succeeded(Artifact configurationId);
+
+    /**
+     * The previous operation on the specified configuration has failed due to the specified exception.
+     * @param configurationId the configuration identifier
+     */
+    void failed(Artifact configurationId, Throwable cause);
+
+    /**
+     * The operation on the configuration manager has finished.
+     */
+    void finished();
+}
+

Added: geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/LifecycleResults.java
URL: http://svn.apache.org/viewcvs/geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/LifecycleResults.java?rev=394860&view=auto
==============================================================================
--- geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/LifecycleResults.java (added)
+++ geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/LifecycleResults.java Mon Apr 17 23:44:17 2006
@@ -0,0 +1,288 @@
+/**
+ *
+ * Copyright 2005 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.geronimo.kernel.config;
+
+import java.util.LinkedHashSet;
+import java.util.LinkedHashMap;
+import java.util.Set;
+import java.util.Map;
+import java.util.Collections;
+import java.io.Serializable;
+
+import org.apache.geronimo.kernel.repository.Artifact;
+
+/**
+ * This class contains the results of a lifecycle operation on the configuation manager.
+ * @version $Rev$ $Date$
+ */
+public class LifecycleResults implements Serializable {
+    private static final long serialVersionUID = 4660197333193740244L;
+    private final Set loaded = new LinkedHashSet();
+    private final Set unloaded = new LinkedHashSet();
+    private final Set started = new LinkedHashSet();
+    private final Set stopped = new LinkedHashSet();
+    private final Set restarted = new LinkedHashSet();
+    private final Set reloaded = new LinkedHashSet();
+    private final Map failed = new LinkedHashMap();
+
+    /**
+     * Was the specified configuration loaded.
+     * @param configurationId the configuration identifier
+     * @return true if the specified configuration was loaded during the lifecycle operation
+     */
+    public boolean wasLoaded(Artifact configurationId) {
+        return loaded.contains(configurationId);
+    }
+
+    /**
+     * Gets the configuration identifiers (Artifact) of the configurations loaded.
+     * @return the configuration identifiers (Artifact)
+     */
+    public Set getLoaded() {
+        return Collections.unmodifiableSet(loaded);
+    }
+
+    /**
+     * Adds a configuration the set of loaded configurations.
+     * @param configurationId the configuration identifiers (Artifact)
+     */
+    public void addLoaded(Artifact configurationId) {
+        loaded.add(configurationId);
+    }
+
+    /**
+     * Clears the existing loaded set and add alls the specified configurations to the set
+     * @param loaded the configuration identifiers (Artifact)
+     */
+    public void setLoaded(Set loaded) {
+        this.loaded.clear();
+        this.loaded.addAll(loaded);
+    }
+
+    /**
+     * Was the specified configuration unloaded.
+     * @param configurationId the configuration identifier
+     * @return true if the specified configuration was unloaded during the lifecycle operation
+     */
+    public boolean wasUnloaded(Artifact configurationId) {
+        return unloaded.contains(configurationId);
+    }
+
+    /**
+     * Gets the configuration identifiers (Artifact) of the configurations unloaded.
+     * @return the configuration identifiers (Artifact)
+     */
+    public Set getUnloaded() {
+        return Collections.unmodifiableSet(unloaded);
+    }
+
+    /**
+     * Adds a configuration the set of unloaded configurations.
+     * @param configurationId the configuration identifiers (Artifact)
+     */
+    public void addUnloaded(Artifact configurationId) {
+        unloaded.add(configurationId);
+    }
+
+    /**
+     * Clears the existing unloaded set and add alls the specified configurations to the set
+     * @param unloaded the configuration identifiers (Artifact)
+     */
+    public void setUnloaded(Set unloaded) {
+        this.unloaded.clear();
+        this.unloaded.addAll(unloaded);
+    }
+
+    /**
+     * Was the specified configuration started.
+     * @param configurationId the configuration identifier
+     * @return true if the specified configuration was started during the lifecycle operation
+     */
+    public boolean wasStarted(Artifact configurationId) {
+        return started.contains(configurationId);
+    }
+
+    /**
+     * Gets the configuration identifiers (Artifact) of the configurations started.
+     * @return the configuration identifiers (Artifact)
+     */
+    public Set getStarted() {
+        return Collections.unmodifiableSet(started);
+    }
+
+    /**
+     * Adds a configuration the set of started configurations.
+     * @param configurationId the configuration identifiers (Artifact)
+     */
+    public void addStarted(Artifact configurationId) {
+        started.add(configurationId);
+    }
+
+    /**
+     * Clears the existing started set and add alls the specified configurations to the set
+     * @param started the configuration identifiers (Artifact)
+     */
+    public void setStarted(Set started) {
+        this.started.clear();
+        this.started.addAll(started);
+    }
+
+    /**
+     * Was the specified configuration stopped.
+     * @param configurationId the configuration identifier
+     * @return true if the specified configuration was stopped during the lifecycle operation
+     */
+    public boolean wasStopped(Artifact configurationId) {
+        return stopped.contains(configurationId);
+    }
+
+    /**
+     * Gets the configuration identifiers (Artifact) of the configurations stopped.
+     * @return the configuration identifiers (Artifact)
+     */
+    public Set getStopped() {
+        return Collections.unmodifiableSet(stopped);
+    }
+
+    /**
+     * Adds a configuration the set of stopped configurations.
+     * @param configurationId the configuration identifiers (Artifact)
+     */
+    public void addStopped(Artifact configurationId) {
+        stopped.add(configurationId);
+    }
+
+    /**
+     * Clears the existing stopped set and add alls the specified configurations to the set
+     * @param stopped the configuration identifiers (Artifact)
+     */
+    public void setStopped(Set stopped) {
+        this.stopped.clear();
+        this.stopped.addAll(stopped);
+    }
+
+    /**
+     * Was the specified configuration restarted.
+     * @param configurationId the configuration identifier
+     * @return true if the specified configuration was restarted during the lifecycle operation
+     */
+    public boolean wasRestarted(Artifact configurationId) {
+        return restarted.contains(configurationId);
+    }
+
+    /**
+     * Gets the configuration identifiers (Artifact) of the configurations restarted.
+     * @return the configuration identifiers (Artifact)
+     */
+    public Set getRestarted() {
+        return Collections.unmodifiableSet(restarted);
+    }
+
+    /**
+     * Adds a configuration the set of restarted configurations.
+     * @param configurationId the configuration identifiers (Artifact)
+     */
+    public void addRestarted(Artifact configurationId) {
+        restarted.add(configurationId);
+    }
+
+    /**
+     * Clears the existing restarted set and add alls the specified configurations to the set
+     * @param restarted the configuration identifiers (Artifact)
+     */
+    public void setRestarted(Set restarted) {
+        this.restarted.clear();
+        this.restarted.addAll(restarted);
+    }
+
+    /**
+     * Was the specified configuration reloaded.
+     * @param configurationId the configuration identifier
+     * @return true if the specified configuration was reloaded during the lifecycle operation
+     */
+    public boolean wasReloaded(Artifact configurationId) {
+        return reloaded.contains(configurationId);
+    }
+
+    /**
+     * Gets the configuration identifiers (Artifact) of the configurations reloaded.
+     * @return the configuration identifiers (Artifact)
+     */
+    public Set getReloaded() {
+        return Collections.unmodifiableSet(reloaded);
+    }
+
+    /**
+     * Adds a configuration the set of reloaded configurations.
+     * @param configurationId the configuration identifiers (Artifact)
+     */
+    public void addReloaded(Artifact configurationId) {
+        reloaded.add(configurationId);
+    }
+
+    /**
+     * Clears the existing reloaded set and add alls the specified configurations to the set
+     * @param reloaded the configuration identifiers (Artifact)
+     */
+    public void setReloaded(Set reloaded) {
+        this.reloaded.clear();
+        this.reloaded.addAll(reloaded);
+    }
+
+    /**
+     * Was the specified configuration failed the operation and threw an exception.
+     * @param configurationId the configuration identifier
+     * @return true if the specified configuration failed the operation and threw an exception during the lifecycle operation
+     */
+    public boolean wasFailed(Artifact configurationId) {
+        return failed.containsKey(configurationId);
+    }
+
+    /**
+     * Gets the exception that caused the operation on the specified configuration to fail.
+     * @return the configuration identifiers (Artifact)
+     */
+    public Throwable getFailedCause(Artifact configurationId) {
+        return (Throwable) failed.get(configurationId);
+    }
+
+    /**
+     * Gets the configuration identifiers (Artifact) of the configurations that failed the operation and threw an exception.
+     * @return the configuration identifiers (Artifact)
+     */
+    public Map getFailed() {
+        return Collections.unmodifiableMap(failed);
+    }
+
+    /**
+     * Adds a configuration and associated causal exception to this result.
+     * @param configurationId the configuration identifiers (Artifact)
+     * @param cause the exception that caused the operation on the specified configuration to fail
+     */
+    public void addFailed(Artifact configurationId, Throwable cause) {
+        failed.put(configurationId, cause);
+    }
+
+    /**
+     * Clears the existing failed map and add alls the specified configurations to the map
+     * @param failed a map from configuration identifier (Artifact) to causal exception
+     */
+    public void setFailed(Map failed) {
+        this.failed.clear();
+        this.failed.putAll(failed);
+    }
+}

Modified: geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/NullConfigurationStore.java
URL: http://svn.apache.org/viewcvs/geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/NullConfigurationStore.java?rev=394860&r1=394859&r2=394860&view=diff
==============================================================================
--- geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/NullConfigurationStore.java (original)
+++ geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/NullConfigurationStore.java Mon Apr 17 23:44:17 2006
@@ -23,8 +23,7 @@
 import java.io.File;
 import java.io.OutputStream;
 import java.util.List;
-import java.net.URL;
-import java.net.URI;
+import java.util.Set;
 import java.net.MalformedURLException;
 
 /**
@@ -36,7 +35,7 @@
     public boolean isInPlaceConfiguration(Artifact configId) throws NoSuchConfigException, IOException {
         return false;
     }
-    
+
     public void install(ConfigurationData configurationData) throws IOException, InvalidConfigException {
     }
 
@@ -67,7 +66,7 @@
         return null;
     }
 
-    public URL resolve(Artifact configId, String moduleName, URI uri) throws NoSuchConfigException, MalformedURLException {
+    public Set resolve(Artifact configId, String moduleName, String path) throws NoSuchConfigException, MalformedURLException {
         return null;
     }
 

Added: geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/NullLifecycleMonitor.java
URL: http://svn.apache.org/viewcvs/geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/NullLifecycleMonitor.java?rev=394860&view=auto
==============================================================================
--- geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/NullLifecycleMonitor.java (added)
+++ geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/NullLifecycleMonitor.java Mon Apr 17 23:44:17 2006
@@ -0,0 +1,53 @@
+/**
+ *
+ * Copyright 2005 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.geronimo.kernel.config;
+
+import org.apache.geronimo.kernel.repository.Artifact;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class NullLifecycleMonitor implements LifecycleMonitor {
+    public static final NullLifecycleMonitor INSTANCE = new NullLifecycleMonitor();
+
+    public void addConfiguration(Artifact configurationId) {
+    }
+
+    public void reading(Artifact configurationId) {
+    }
+
+    public void loading(Artifact configurationId) {
+    }
+
+    public void starting(Artifact configurationId) {
+    }
+
+    public void stopping(Artifact configurationId) {
+    }
+
+    public void unloading(Artifact configurationId) {
+    }
+
+    public void succeeded(Artifact configurationId) {
+    }
+
+    public void failed(Artifact configurationId, Throwable cause) {
+    }
+
+    public void finished() {
+    }
+}

Added: geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/Os.java
URL: http://svn.apache.org/viewcvs/geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/Os.java?rev=394860&view=auto
==============================================================================
--- geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/Os.java (added)
+++ geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/Os.java Mon Apr 17 23:44:17 2006
@@ -0,0 +1,231 @@
+/**
+ *
+ * Copyright 2005 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.geronimo.kernel.config;
+
+import java.util.Locale;
+
+/**
+ * Condition that tests the OS type.
+ *
+ * @version $Rev$ $Date$
+ */
+public class Os {
+    private static final String OS_NAME = System.getProperty("os.name").toLowerCase(Locale.US);
+    private static final String OS_ARCH = System.getProperty("os.arch").toLowerCase(Locale.US);
+    private static final String OS_VERSION = System.getProperty("os.version").toLowerCase(Locale.US);
+    private static final String PATH_SEP = System.getProperty("path.separator");
+
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_WINDOWS = "windows";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_9X = "win9x";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_NT = "winnt";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_OS2 = "os/2";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_NETWARE = "netware";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_DOS = "dos";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_MAC = "mac";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_TANDEM = "tandem";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_UNIX = "unix";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_VMS = "openvms";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_ZOS = "z/os";
+    /**
+     * OS family that can be tested for. {@value}
+     */
+    public static final String FAMILY_OS400 = "os/400";
+
+    private Os() {
+        //default
+    }
+
+    /**
+     * Determines if the OS on which Ant is executing matches the
+     * given OS family.
+     * @param family the family to check for
+     * @return true if the OS matches
+     * @since 1.5
+     */
+    public static boolean isFamily(String family) {
+        return isOs(family, null, null, null);
+    }
+
+    /**
+     * Determines if the OS on which Ant is executing matches the
+     * given OS name.
+     *
+     * @param name  The OS family type desired<br />
+     *               Possible values:<br />
+     *               <ul>
+     *               <li>dos</li>
+     *               <li>mac</li>
+     *               <li>netware</li>
+     *               <li>os/2</li>
+     *               <li>tandem</li>
+     *               <li>unix</li>
+     *               <li>windows</li>
+     *               <li>win9x</li>
+     *               <li>z/os</li>
+     *               <li>os/400</li>
+     *               </ul>
+     * @return true if the OS matches
+     * @since 1.7
+     */
+    public static boolean isName(String name) {
+        return isOs(null, name, null, null);
+    }
+
+    /**
+     * Determines if the OS on which Ant is executing matches the
+     * given OS architecture.
+     *
+     * @param arch the OS architecture to check for
+     * @return true if the OS matches
+     * @since 1.7
+     */
+    public static boolean isArch(String arch) {
+        return isOs(null, null, arch, null);
+    }
+
+    /**
+     * Determines if the OS on which Ant is executing matches the
+     * given OS version.
+     *
+     * @param version the OS version to check for
+     * @return true if the OS matches
+     * @since 1.7
+     */
+    public static boolean isVersion(String version) {
+        return isOs(null, null, null, version);
+    }
+
+    /**
+     * Determines if the OS on which Ant is executing matches the
+     * given OS family, name, architecture and version
+     *
+     * @param family   The OS family
+     * @param name   The OS name
+     * @param arch   The OS architecture
+     * @param version   The OS version
+     * @return true if the OS matches
+     * @since 1.7
+     */
+    public static boolean isOs(String family, String name, String arch,
+                               String version) {
+        boolean retValue = false;
+
+        if (family != null || name != null || arch != null
+            || version != null) {
+
+            boolean isFamily = true;
+            boolean isName = true;
+            boolean isArch = true;
+            boolean isVersion = true;
+
+            if (family != null) {
+
+                //windows probing logic relies on the word 'windows' in
+                //the OS
+                boolean isWindows = OS_NAME.indexOf(FAMILY_WINDOWS) > -1;
+                boolean is9x = false;
+                boolean isNT = false;
+                if(isWindows) {
+                    //there are only four 9x platforms that we look for
+                    is9x = (OS_NAME.indexOf("95") >= 0
+                            || OS_NAME.indexOf("98") >= 0
+                            || OS_NAME.indexOf("me") >= 0
+                            //wince isn't really 9x, but crippled enough to
+                            //be a muchness. Ant doesnt run on CE, anyway.
+                            || OS_NAME.indexOf("ce") >= 0);
+                    isNT = !is9x;
+                }
+                if (family.equals(FAMILY_WINDOWS)) {
+                    isFamily = isWindows;
+                } else if (family.equals(FAMILY_9X)) {
+                    isFamily = isWindows && is9x;
+                } else if (family.equals(FAMILY_NT)) {
+                    isFamily = isWindows && isNT;
+                } else if (family.equals(FAMILY_OS2)) {
+                    isFamily = OS_NAME.indexOf(FAMILY_OS2) > -1;
+                } else if (family.equals(FAMILY_NETWARE)) {
+                    isFamily = OS_NAME.indexOf(FAMILY_NETWARE) > -1;
+                } else if (family.equals(FAMILY_DOS)) {
+                    isFamily = PATH_SEP.equals(";") && !isFamily(FAMILY_NETWARE);
+                } else if (family.equals(FAMILY_MAC)) {
+                    isFamily = OS_NAME.indexOf(FAMILY_MAC) > -1;
+                } else if (family.equals(FAMILY_TANDEM)) {
+                    isFamily = OS_NAME.indexOf("nonstop_kernel") > -1;
+                } else if (family.equals(FAMILY_UNIX)) {
+                    isFamily = PATH_SEP.equals(":")
+                        && !isFamily(FAMILY_VMS)
+                        && (!isFamily(FAMILY_MAC) || OS_NAME.endsWith("x"));
+                } else if (family.equals(FAMILY_ZOS)) {
+                    isFamily = OS_NAME.indexOf(FAMILY_ZOS) > -1
+                        || OS_NAME.indexOf("os/390") > -1;
+                } else if (family.equals(FAMILY_OS400)) {
+                    isFamily = OS_NAME.indexOf(FAMILY_OS400) > -1;
+                } else if (family.equals(FAMILY_VMS)) {
+                    isFamily = OS_NAME.indexOf(FAMILY_VMS) > -1;
+                } else {
+                    throw new IllegalArgumentException(
+                        "Don\'t know how to detect os family \""
+                        + family + "\"");
+                }
+            }
+            if (name != null) {
+                isName = name.equals(OS_NAME);
+            }
+            if (arch != null) {
+                isArch = arch.equals(OS_ARCH);
+            }
+            if (version != null) {
+                isVersion = version.equals(OS_VERSION);
+            }
+            retValue = isFamily && isName && isArch && isVersion;
+        }
+        return retValue;
+    }
+}
\ No newline at end of file

Added: geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/SelectorUtils.java
URL: http://svn.apache.org/viewcvs/geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/SelectorUtils.java?rev=394860&view=auto
==============================================================================
--- geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/SelectorUtils.java (added)
+++ geronimo/branches/1.1/modules/kernel/src/java/org/apache/geronimo/kernel/config/SelectorUtils.java Mon Apr 17 23:44:17 2006
@@ -0,0 +1,714 @@
+/**
+ *
+ * Copyright 2005 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.geronimo.kernel.config;
+
+import java.io.File;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+/**
+ * <p>This is a utility class used by selectors and DirectoryScanner. The
+ * functionality more properly belongs just to selectors, but unfortunately
+ * DirectoryScanner exposed these as protected methods. Thus we have to
+ * support any subclasses of DirectoryScanner that may access these methods.
+ * </p>
+ * <p>This is a Singleton.</p>
+ *
+ * @version $Rev$ $Date$
+ */
+public final class SelectorUtils {
+    private static SelectorUtils instance = new SelectorUtils();
+
+    private static boolean onNetWare = Os.isFamily("netware");
+    private static boolean onDos = Os.isFamily("dos");
+
+    /**
+     * Private Constructor
+     */
+    private SelectorUtils() {
+    }
+
+    /**
+     * Retrieves the instance of the Singleton.
+     * @return singleton instance
+     */
+    public static SelectorUtils getInstance() {
+        return instance;
+    }
+
+    /**
+     * Tests whether or not a given path matches the start of a given
+     * pattern up to the first "**".
+     * <p>
+     * This is not a general purpose test and should only be used if you
+     * can live with false positives. For example, <code>pattern=**\a</code>
+     * and <code>str=b</code> will yield <code>true</code>.
+     *
+     * @param pattern The pattern to match against. Must not be
+     *                <code>null</code>.
+     * @param str     The path to match, as a String. Must not be
+     *                <code>null</code>.
+     *
+     * @return whether or not a given path matches the start of a given
+     * pattern up to the first "**".
+     */
+    public static boolean matchPatternStart(String pattern, String str) {
+        return matchPatternStart(pattern, str, true);
+    }
+
+    /**
+     * Tests whether or not a given path matches the start of a given
+     * pattern up to the first "**".
+     * <p>
+     * This is not a general purpose test and should only be used if you
+     * can live with false positives. For example, <code>pattern=**\a</code>
+     * and <code>str=b</code> will yield <code>true</code>.
+     *
+     * @param pattern The pattern to match against. Must not be
+     *                <code>null</code>.
+     * @param str     The path to match, as a String. Must not be
+     *                <code>null</code>.
+     * @param isCaseSensitive Whether or not matching should be performed
+     *                        case sensitively.
+     *
+     * @return whether or not a given path matches the start of a given
+     * pattern up to the first "**".
+     */
+    public static boolean matchPatternStart(String pattern, String str,
+                                            boolean isCaseSensitive) {
+        // When str starts with a File.separator, pattern has to start with a
+        // File.separator.
+        // When pattern starts with a File.separator, str has to start with a
+        // File.separator.
+        if (str.startsWith(File.separator)
+                != pattern.startsWith(File.separator)) {
+            return false;
+        }
+
+        String[] patDirs = tokenizePathAsArray(pattern);
+        String[] strDirs = tokenizePathAsArray(str);
+
+        int patIdxStart = 0;
+        int patIdxEnd = patDirs.length - 1;
+        int strIdxStart = 0;
+        int strIdxEnd = strDirs.length - 1;
+
+        // up to first '**'
+        while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) {
+            String patDir = patDirs[patIdxStart];
+            if (patDir.equals("**")) {
+                break;
+            }
+            if (!match(patDir, strDirs[strIdxStart], isCaseSensitive)) {
+                return false;
+            }
+            patIdxStart++;
+            strIdxStart++;
+        }
+
+        if (strIdxStart > strIdxEnd) {
+            // String is exhausted
+            return true;
+        } else if (patIdxStart > patIdxEnd) {
+            // String not exhausted, but pattern is. Failure.
+            return false;
+        } else {
+            // pattern now holds ** while string is not exhausted
+            // this will generate false positives but we can live with that.
+            return true;
+        }
+    }
+
+    /**
+     * Tests whether or not a given path matches a given pattern.
+     *
+     * @param pattern The pattern to match against. Must not be
+     *                <code>null</code>.
+     * @param str     The path to match, as a String. Must not be
+     *                <code>null</code>.
+     *
+     * @return <code>true</code> if the pattern matches against the string,
+     *         or <code>false</code> otherwise.
+     */
+    public static boolean matchPath(String pattern, String str) {
+        return matchPath(pattern, str, true);
+    }
+
+    /**
+     * Tests whether or not a given path matches a given pattern.
+     *
+     * @param pattern The pattern to match against. Must not be
+     *                <code>null</code>.
+     * @param str     The path to match, as a String. Must not be
+     *                <code>null</code>.
+     * @param isCaseSensitive Whether or not matching should be performed
+     *                        case sensitively.
+     *
+     * @return <code>true</code> if the pattern matches against the string,
+     *         or <code>false</code> otherwise.
+     */
+    public static boolean matchPath(String pattern, String str,
+                                    boolean isCaseSensitive) {
+        String[] patDirs = tokenizePathAsArray(pattern);
+        String[] strDirs = tokenizePathAsArray(str);
+
+        int patIdxStart = 0;
+        int patIdxEnd = patDirs.length - 1;
+        int strIdxStart = 0;
+        int strIdxEnd = strDirs.length - 1;
+
+        // up to first '**'
+        while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) {
+            String patDir = patDirs[patIdxStart];
+            if (patDir.equals("**")) {
+                break;
+            }
+            if (!match(patDir, strDirs[strIdxStart], isCaseSensitive)) {
+                patDirs = null;
+                strDirs = null;
+                return false;
+            }
+            patIdxStart++;
+            strIdxStart++;
+        }
+        if (strIdxStart > strIdxEnd) {
+            // String is exhausted
+            for (int i = patIdxStart; i <= patIdxEnd; i++) {
+                if (!patDirs[i].equals("**")) {
+                    patDirs = null;
+                    strDirs = null;
+                    return false;
+                }
+            }
+            return true;
+        } else {
+            if (patIdxStart > patIdxEnd) {
+                // String not exhausted, but pattern is. Failure.
+                patDirs = null;
+                strDirs = null;
+                return false;
+            }
+        }
+
+        // up to last '**'
+        while (patIdxStart <= patIdxEnd && strIdxStart <= strIdxEnd) {
+            String patDir = patDirs[patIdxEnd];
+            if (patDir.equals("**")) {
+                break;
+            }
+            if (!match(patDir, strDirs[strIdxEnd], isCaseSensitive)) {
+                patDirs = null;
+                strDirs = null;
+                return false;
+            }
+            patIdxEnd--;
+            strIdxEnd--;
+        }
+        if (strIdxStart > strIdxEnd) {
+            // String is exhausted
+            for (int i = patIdxStart; i <= patIdxEnd; i++) {
+                if (!patDirs[i].equals("**")) {
+                    patDirs = null;
+                    strDirs = null;
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) {
+            int patIdxTmp = -1;
+            for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
+                if (patDirs[i].equals("**")) {
+                    patIdxTmp = i;
+                    break;
+                }
+            }
+            if (patIdxTmp == patIdxStart + 1) {
+                // '**/**' situation, so skip one
+                patIdxStart++;
+                continue;
+            }
+            // Find the pattern between padIdxStart & padIdxTmp in str between
+            // strIdxStart & strIdxEnd
+            int patLength = (patIdxTmp - patIdxStart - 1);
+            int strLength = (strIdxEnd - strIdxStart + 1);
+            int foundIdx = -1;
+            strLoop:
+                        for (int i = 0; i <= strLength - patLength; i++) {
+                            for (int j = 0; j < patLength; j++) {
+                                String subPat = patDirs[patIdxStart + j + 1];
+                                String subStr = strDirs[strIdxStart + i + j];
+                                if (!match(subPat, subStr, isCaseSensitive)) {
+                                    continue strLoop;
+                                }
+                            }
+
+                            foundIdx = strIdxStart + i;
+                            break;
+                        }
+
+            if (foundIdx == -1) {
+                patDirs = null;
+                strDirs = null;
+                return false;
+            }
+
+            patIdxStart = patIdxTmp;
+            strIdxStart = foundIdx + patLength;
+        }
+
+        for (int i = patIdxStart; i <= patIdxEnd; i++) {
+            if (!patDirs[i].equals("**")) {
+                patDirs = null;
+                strDirs = null;
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Tests whether or not a string matches against a pattern.
+     * The pattern may contain two special characters:<br>
+     * '*' means zero or more characters<br>
+     * '?' means one and only one character
+     *
+     * @param pattern The pattern to match against.
+     *                Must not be <code>null</code>.
+     * @param str     The string which must be matched against the pattern.
+     *                Must not be <code>null</code>.
+     *
+     * @return <code>true</code> if the string matches against the pattern,
+     *         or <code>false</code> otherwise.
+     */
+    public static boolean match(String pattern, String str) {
+        return match(pattern, str, true);
+    }
+
+    /**
+     * Tests whether or not a string matches against a pattern.
+     * The pattern may contain two special characters:<br>
+     * '*' means zero or more characters<br>
+     * '?' means one and only one character
+     *
+     * @param pattern The pattern to match against.
+     *                Must not be <code>null</code>.
+     * @param str     The string which must be matched against the pattern.
+     *                Must not be <code>null</code>.
+     * @param isCaseSensitive Whether or not matching should be performed
+     *                        case sensitively.
+     *
+     *
+     * @return <code>true</code> if the string matches against the pattern,
+     *         or <code>false</code> otherwise.
+     */
+    public static boolean match(String pattern, String str,
+                                boolean isCaseSensitive) {
+        char[] patArr = pattern.toCharArray();
+        char[] strArr = str.toCharArray();
+        int patIdxStart = 0;
+        int patIdxEnd = patArr.length - 1;
+        int strIdxStart = 0;
+        int strIdxEnd = strArr.length - 1;
+        char ch;
+
+        boolean containsStar = false;
+        for (int i = 0; i < patArr.length; i++) {
+            if (patArr[i] == '*') {
+                containsStar = true;
+                break;
+            }
+        }
+
+        if (!containsStar) {
+            // No '*'s, so we make a shortcut
+            if (patIdxEnd != strIdxEnd) {
+                return false; // Pattern and string do not have the same size
+            }
+            for (int i = 0; i <= patIdxEnd; i++) {
+                ch = patArr[i];
+                if (ch != '?') {
+                    if (isCaseSensitive && ch != strArr[i]) {
+                        return false; // Character mismatch
+                    }
+                    if (!isCaseSensitive && Character.toUpperCase(ch)
+                            != Character.toUpperCase(strArr[i])) {
+                        return false;  // Character mismatch
+                    }
+                }
+            }
+            return true; // String matches against pattern
+        }
+
+        if (patIdxEnd == 0) {
+            return true; // Pattern contains only '*', which matches anything
+        }
+
+        // Process characters before first star
+        while ((ch = patArr[patIdxStart]) != '*' && strIdxStart <= strIdxEnd) {
+            if (ch != '?') {
+                if (isCaseSensitive && ch != strArr[strIdxStart]) {
+                    return false; // Character mismatch
+                }
+                if (!isCaseSensitive && Character.toUpperCase(ch)
+                        != Character.toUpperCase(strArr[strIdxStart])) {
+                    return false; // Character mismatch
+                }
+            }
+            patIdxStart++;
+            strIdxStart++;
+        }
+        if (strIdxStart > strIdxEnd) {
+            // All characters in the string are used. Check if only '*'s are
+            // left in the pattern. If so, we succeeded. Otherwise failure.
+            for (int i = patIdxStart; i <= patIdxEnd; i++) {
+                if (patArr[i] != '*') {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        // Process characters after last star
+        while ((ch = patArr[patIdxEnd]) != '*' && strIdxStart <= strIdxEnd) {
+            if (ch != '?') {
+                if (isCaseSensitive && ch != strArr[strIdxEnd]) {
+                    return false; // Character mismatch
+                }
+                if (!isCaseSensitive && Character.toUpperCase(ch)
+                        != Character.toUpperCase(strArr[strIdxEnd])) {
+                    return false; // Character mismatch
+                }
+            }
+            patIdxEnd--;
+            strIdxEnd--;
+        }
+        if (strIdxStart > strIdxEnd) {
+            // All characters in the string are used. Check if only '*'s are
+            // left in the pattern. If so, we succeeded. Otherwise failure.
+            for (int i = patIdxStart; i <= patIdxEnd; i++) {
+                if (patArr[i] != '*') {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        // process pattern between stars. padIdxStart and patIdxEnd point
+        // always to a '*'.
+        while (patIdxStart != patIdxEnd && strIdxStart <= strIdxEnd) {
+            int patIdxTmp = -1;
+            for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
+                if (patArr[i] == '*') {
+                    patIdxTmp = i;
+                    break;
+                }
+            }
+            if (patIdxTmp == patIdxStart + 1) {
+                // Two stars next to each other, skip the first one.
+                patIdxStart++;
+                continue;
+            }
+            // Find the pattern between padIdxStart & padIdxTmp in str between
+            // strIdxStart & strIdxEnd
+            int patLength = (patIdxTmp - patIdxStart - 1);
+            int strLength = (strIdxEnd - strIdxStart + 1);
+            int foundIdx = -1;
+            strLoop:
+            for (int i = 0; i <= strLength - patLength; i++) {
+                for (int j = 0; j < patLength; j++) {
+                    ch = patArr[patIdxStart + j + 1];
+                    if (ch != '?') {
+                        if (isCaseSensitive && ch != strArr[strIdxStart + i
+                                + j]) {
+                            continue strLoop;
+                        }
+                        if (!isCaseSensitive
+                            && Character.toUpperCase(ch)
+                                != Character.toUpperCase(strArr[strIdxStart + i + j])) {
+                            continue strLoop;
+                        }
+                    }
+                }
+
+                foundIdx = strIdxStart + i;
+                break;
+            }
+
+            if (foundIdx == -1) {
+                return false;
+            }
+
+            patIdxStart = patIdxTmp;
+            strIdxStart = foundIdx + patLength;
+        }
+
+        // All characters in the string are used. Check if only '*'s are left
+        // in the pattern. If so, we succeeded. Otherwise failure.
+        for (int i = patIdxStart; i <= patIdxEnd; i++) {
+            if (patArr[i] != '*') {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Breaks a path up into a Vector of path elements, tokenizing on
+     * <code>File.separator</code>.
+     *
+     * @param path Path to tokenize. Must not be <code>null</code>.
+     *
+     * @return a Vector of path elements from the tokenized path
+     */
+    public static Vector tokenizePath (String path) {
+        return tokenizePath(path, File.separator);
+    }
+
+    /**
+     * Verifies that the specified filename represents an absolute path.
+     * Differs from new java.io.File("filename").isAbsolute() in that a path
+     * beginning with a double file separator--signifying a Windows UNC--must
+     * at minimum match "\\a\b" to be considered an absolute path.
+     * @param filename the filename to be checked.
+     * @return true if the filename represents an absolute path.
+     * @throws java.lang.NullPointerException if filename is null.
+     * @since Ant 1.6.3
+     */
+    public static boolean isAbsolutePath(String filename) {
+        int len = filename.length();
+        if (len == 0) {
+            return false;
+        }
+        char sep = File.separatorChar;
+        filename = filename.replace('/', sep).replace('\\', sep);
+        char c = filename.charAt(0);
+        if (!(onDos || onNetWare)) {
+            return (c == sep);
+        }
+        if (c == sep) {
+            if (!(onDos && len > 4 && filename.charAt(1) == sep)) {
+                return false;
+            }
+            int nextsep = filename.indexOf(sep, 2);
+            return nextsep > 2 && nextsep + 1 < len;
+        }
+        int colon = filename.indexOf(':');
+        return (Character.isLetter(c) && colon == 1
+            && filename.length() > 2 && filename.charAt(2) == sep)
+            || (onNetWare && colon > 0);
+    }
+
+    /**
+     * Dissect the specified absolute path.
+     * @param path the path to dissect.
+     * @return String[] {root, remaining path}.
+     * @throws java.lang.NullPointerException if path is null.
+     */
+    public static String[] dissect(String path) {
+        char sep = File.separatorChar;
+        path = path.replace('/', sep).replace('\\', sep);
+
+        // make sure we are dealing with an absolute path
+        if (!isAbsolutePath(path)) {
+            throw new IllegalArgumentException(path + " is not an absolute path");
+        }
+        String root = null;
+        int colon = path.indexOf(':');
+        if (colon > 0 && (onDos || onNetWare)) {
+
+            int next = colon + 1;
+            root = path.substring(0, next).toUpperCase();
+            char[] ca = path.toCharArray();
+            root += sep;
+            //remove the initial separator; the root has it.
+            next = (ca[next] == sep) ? next + 1 : next;
+
+            StringBuffer sbPath = new StringBuffer();
+            // Eliminate consecutive slashes after the drive spec:
+            for (int i = next; i < ca.length; i++) {
+                if (ca[i] != sep || ca[i - 1] != sep) {
+                    sbPath.append(ca[i]);
+                }
+            }
+            path = sbPath.toString();
+        } else if (path.length() > 1 && path.charAt(1) == sep) {
+            // UNC drive
+            int nextsep = path.indexOf(sep, 2);
+            nextsep = path.indexOf(sep, nextsep + 1);
+            root = (nextsep > 2) ? path.substring(0, nextsep + 1) : path;
+            path = path.substring(root.length());
+        } else {
+            root = File.separator;
+            path = path.substring(1);
+        }
+        return new String[] {root, path};
+    }
+
+
+    /**
+     * Breaks a path up into a Vector of path elements, tokenizing on
+     *
+     * @param path Path to tokenize. Must not be <code>null</code>.
+     * @param separator the separator against which to tokenize.
+     *
+     * @return a Vector of path elements from the tokenized path
+     * @since Ant 1.6
+     */
+    public static Vector tokenizePath (String path, String separator) {
+        Vector ret = new Vector();
+        if (isAbsolutePath(path)) {
+            String[] s = dissect(path);
+            ret.add(s[0]);
+            path = s[1];
+        }
+        StringTokenizer st = new StringTokenizer(path, separator);
+        while (st.hasMoreTokens()) {
+            ret.addElement(st.nextToken());
+        }
+        return ret;
+    }
+
+    /**
+     * Same as {@link #tokenizePath tokenizePath} but hopefully faster.
+     */
+    private static String[] tokenizePathAsArray(String path) {
+        String root = null;
+        if (isAbsolutePath(path)) {
+            String[] s = dissect(path);
+            root = s[0];
+            path = s[1];
+        }
+        char sep = File.separatorChar;
+        int start = 0;
+        int len = path.length();
+        int count = 0;
+        for (int pos = 0; pos < len; pos++) {
+            if (path.charAt(pos) == sep) {
+                if (pos != start) {
+                    count++;
+                }
+                start = pos + 1;
+            }
+        }
+        if (len != start) {
+            count++;
+        }
+        String[] l = new String[count + ((root == null) ? 0 : 1)];
+
+        if (root != null) {
+            l[0] = root;
+            count = 1;
+        } else {
+            count = 0;
+        }
+        start = 0;
+        for (int pos = 0; pos < len; pos++) {
+            if (path.charAt(pos) == sep) {
+                if (pos != start) {
+                    String tok = path.substring(start, pos);
+                    l[count++] = tok;
+                }
+                start = pos + 1;
+            }
+        }
+        if (len != start) {
+            String tok = path.substring(start);
+            l[count/*++*/] = tok;
+        }
+        return l;
+    }
+
+
+    /**
+     * Returns dependency information on these two files. If src has been
+     * modified later than target, it returns true. If target doesn't exist,
+     * it likewise returns true. Otherwise, target is newer than src and
+     * is not out of date, thus the method returns false. It also returns
+     * false if the src file doesn't even exist, since how could the
+     * target then be out of date.
+     *
+     * @param src the original file
+     * @param target the file being compared against
+     * @param granularity the amount in seconds of slack we will give in
+     *        determining out of dateness
+     * @return whether the target is out of date
+     */
+    public static boolean isOutOfDate(File src, File target, int granularity) {
+        if (!src.exists()) {
+            return false;
+        }
+        if (!target.exists()) {
+            return true;
+        }
+        if ((src.lastModified() - granularity) > target.lastModified()) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * "Flattens" a string by removing all whitespace (space, tab, linefeed,
+     * carriage return, and formfeed). This uses StringTokenizer and the
+     * default set of tokens as documented in the single arguement constructor.
+     *
+     * @param input a String to remove all whitespace.
+     * @return a String that has had all whitespace removed.
+     */
+    public static String removeWhitespace(String input) {
+        StringBuffer result = new StringBuffer();
+        if (input != null) {
+            StringTokenizer st = new StringTokenizer(input);
+            while (st.hasMoreTokens()) {
+                result.append(st.nextToken());
+            }
+        }
+        return result.toString();
+    }
+
+    /**
+     * Tests if a string contains stars or question marks
+     * @param input a String which one wants to test for containing wildcard
+     * @return true if the string contains at least a star or a question mark
+     */
+    public static boolean hasWildcards(String input) {
+        return (input.indexOf('*') != -1 || input.indexOf('?') != -1);
+    }
+
+    /**
+     * removes from a pattern all tokens to the right containing wildcards
+     * @param input the input string
+     * @return the leftmost part of the pattern without wildcards
+     */
+    public static String rtrimWildcardTokens(String input) {
+        Vector v = tokenizePath(input, File.separator);
+        StringBuffer sb = new StringBuffer();
+        for (int counter = 0; counter < v.size(); counter++) {
+            if (hasWildcards((String) v.elementAt(counter))) {
+                break;
+            }
+            if (counter > 0 && sb.charAt(sb.length() - 1) != File.separatorChar) {
+                sb.append(File.separator);
+            }
+            sb.append((String) v.elementAt(counter));
+        }
+        return sb.toString();
+    }
+}
+



Mime
View raw message