package org.codehaus.plexus.util;
   
   /*
    * The Apache Software License, Version 1.1
    *
    * Copyright (c) 2001-2003 The Apache Software Foundation.  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 acknowledgement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgement may appear in the software itself,
   *    if and wherever such third-party acknowledgements normally appear.
   *
   * 4. The names "Ant" and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Group.
   *
   * 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 THE APACHE SOFTWARE FOUNDATION 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 the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  import java.util.HashSet;
  import java.util.Locale;
  import java.util.Set;
  
  /**
   * Condition that tests the OS type.
   *
   * @author Stefan Bodewig
   * @author Magesh Umasankar
   * @author Brian Fox
   * @since 1.0
   *
   */
  public class Os {
      // define the families for easier reference
      public static final String FAMILY_DOS = "dos";
  
      public static final String FAMILY_MAC = "mac";
  
      public static final String FAMILY_NETWARE = "netware";
  
      public static final String FAMILY_OS2 = "os/2";
  
      public static final String FAMILY_TANDEM = "tandem";
  
      public static final String FAMILY_UNIX = "unix";
  
      public static final String FAMILY_WINDOWS = "windows";
  
      public static final String FAMILY_WIN9X = "win9x";
  
      public static final String FAMILY_ZOS = "z/os";
  
      public static final String FAMILY_OS400 = "os/400";
  
      public static final String FAMILY_OPENVMS = "openvms";
  
      // store the valid families
      private static final Set<String> validFamilies = setValidFamilies();
  
      // get the current info
      private static final String PATH_SEP = System.getProperty("path.separator");
  
     public static final String OS_NAME = System.getProperty("os.name").toLowerCase(Locale.US);
 
     public static final String OS_ARCH = System.getProperty("os.arch").toLowerCase(Locale.US);
 
     public static final String OS_VERSION = System.getProperty("os.version").toLowerCase(Locale.US);
 
     // Make sure this method is called after static fields it depends on have been set!
     public static final String OS_FAMILY = getOsFamily();
 
     private String family;
 
     private String name;
 
     private String version;
 
     private String arch;
 
     /**
      * Default constructor
      */
     public Os() {}
 
     /**
      * Constructor that sets the family attribute
      *
      * @param family a String value
      */
     public Os(String family) {
         setFamily(family);
     }
 
     /**
      * Initializes the set of valid families.
      */
     private static Set<String> setValidFamilies() {
         Set<String> valid = new HashSet<String>();
         valid.add(FAMILY_DOS);
         valid.add(FAMILY_MAC);
         valid.add(FAMILY_NETWARE);
         valid.add(FAMILY_OS2);
         valid.add(FAMILY_TANDEM);
         valid.add(FAMILY_UNIX);
         valid.add(FAMILY_WINDOWS);
         valid.add(FAMILY_WIN9X);
         valid.add(FAMILY_ZOS);
         valid.add(FAMILY_OS400);
         valid.add(FAMILY_OPENVMS);
 
         return valid;
     }
 
     /**
      * Sets the desired OS family type
      *
      * @param f The OS family type desired<br>
      *            Possible values:
      *            <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>
      *            <li>openvms</li>
      *            </ul>
      */
     public void setFamily(String f) {
         family = f.toLowerCase(Locale.US);
     }
 
     /**
      * Sets the desired OS name
      *
      * @param name The OS name
      */
     public void setName(String name) {
         this.name = name.toLowerCase(Locale.US);
     }
 
     /**
      * Sets the desired OS architecture
      *
      * @param arch The OS architecture
      */
     public void setArch(String arch) {
         this.arch = arch.toLowerCase(Locale.US);
     }
 
     /**
      * Sets the desired OS version
      *
      * @param version The OS version
      */
     public void setVersion(String version) {
         this.version = version.toLowerCase(Locale.US);
     }
 
     /**
      * @return Determines if the current OS matches the type of that set in setFamily.
      *
      * @see Os#setFamily(String)
      * @throws Exception any errir
      */
     public boolean eval() throws Exception {
         return isOs(family, name, arch, version);
     }
 
     /**
      * Determines if the current OS matches the given OS family.
      *
      * @param family the family to check for
      * @return true if the OS matches
      * @since 1.0
      */
     public static boolean isFamily(String family) {
         return isOs(family, null, null, null);
     }
 
     /**
      * Determines if the current OS matches the given OS name.
      *
      * @param name the OS name to check for
      * @return true if the OS matches
      * @since 1.0
      */
     public static boolean isName(String name) {
         return isOs(null, name, null, null);
     }
 
     /**
      * Determines if the current OS matches the given OS architecture.
      *
      * @param arch the OS architecture to check for
      * @return true if the OS matches
      * @since 1.0
      */
     public static boolean isArch(String arch) {
         return isOs(null, null, arch, null);
     }
 
     /**
      * Determines if the current OS matches the given OS version.
      *
      * @param version the OS version to check for
      * @return true if the OS matches
      * @since 1.0
      */
     public static boolean isVersion(String version) {
         return isOs(null, null, null, version);
     }
 
     /**
      * Determines if the current OS matches the given OS family, name, architecture and version. The name, architecture
      * and version are compared to the System properties os.name, os.version and os.arch in a case-independent way.
      *
      * @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.0
      */
     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) {
                 if (family.equalsIgnoreCase(FAMILY_WINDOWS)) {
                     isFamily = OS_NAME.contains(FAMILY_WINDOWS);
                 } else if (family.equalsIgnoreCase(FAMILY_OS2)) {
                     isFamily = OS_NAME.contains(FAMILY_OS2);
                 } else if (family.equalsIgnoreCase(FAMILY_NETWARE)) {
                     isFamily = OS_NAME.contains(FAMILY_NETWARE);
                 } else if (family.equalsIgnoreCase(FAMILY_DOS)) {
                     isFamily = PATH_SEP.equals(";")
                             && !isFamily(FAMILY_NETWARE)
                             && !isFamily(FAMILY_WINDOWS)
                             && !isFamily(FAMILY_WIN9X);
 
                 } else if (family.equalsIgnoreCase(FAMILY_MAC)) {
                     isFamily = OS_NAME.contains(FAMILY_MAC);
                 } else if (family.equalsIgnoreCase(FAMILY_TANDEM)) {
                     isFamily = OS_NAME.contains("nonstop_kernel");
                 } else if (family.equalsIgnoreCase(FAMILY_UNIX)) {
                     isFamily = PATH_SEP.equals(":")
                             && !isFamily(FAMILY_OPENVMS)
                             && (!isFamily(FAMILY_MAC) || OS_NAME.endsWith("x"));
                 } else if (family.equalsIgnoreCase(FAMILY_WIN9X)) {
                     isFamily = isFamily(FAMILY_WINDOWS)
                             && (OS_NAME.contains("95")
                                     || OS_NAME.contains("98")
                                     || OS_NAME.contains("me")
                                     || OS_NAME.contains("ce"));
                 } else if (family.equalsIgnoreCase(FAMILY_ZOS)) {
                     isFamily = OS_NAME.contains(FAMILY_ZOS) || OS_NAME.contains("os/390");
                 } else if (family.equalsIgnoreCase(FAMILY_OS400)) {
                     isFamily = OS_NAME.contains(FAMILY_OS400);
                 } else if (family.equalsIgnoreCase(FAMILY_OPENVMS)) {
                     isFamily = OS_NAME.contains(FAMILY_OPENVMS);
                 } else {
                     isFamily = OS_NAME.contains(family.toLowerCase(Locale.US));
                 }
             }
             if (name != null) {
                 isName = name.toLowerCase(Locale.US).equals(OS_NAME);
             }
             if (arch != null) {
                 isArch = arch.toLowerCase(Locale.US).equals(OS_ARCH);
             }
             if (version != null) {
                 isVersion = version.toLowerCase(Locale.US).equals(OS_VERSION);
             }
             retValue = isFamily && isName && isArch && isVersion;
         }
         return retValue;
     }
 
     /**
      * Helper method to determine the current OS family.
      *
      * @return name of current OS family.
      * @since 1.4.2
      */
     private static String getOsFamily() {
         // in case the order of static initialization is
         // wrong, get the list
         // safely.
         Set<String> families = null;
         if (!validFamilies.isEmpty()) {
             families = validFamilies;
         } else {
             families = setValidFamilies();
         }
         for (String fam : families) {
             if (Os.isFamily(fam)) {
                 return fam;
             }
         }
         return null;
     }
 
     /**
      * Helper method to check if the given family is in the following list:
      * <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>
      * <li>openvms</li>
      * </ul>
      *
      * @param theFamily the family to check.
      * @return true if one of the valid families.
      * @since 1.4.2
      */
     public static boolean isValidFamily(String theFamily) {
         return (validFamilies.contains(theFamily));
     }
 
     /**
      * @return a copy of the valid families
      * @since 1.4.2
      */
     public static Set<String> getValidFamilies() {
         return new HashSet<String>(validFamilies);
     }
 }