Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   **** BEGIN LICENSE BLOCK *****
   * Version: EPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Eclipse Public
   * License Version 1.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.eclipse.org/legal/epl-v10.html
   *
  * Software distributed under the License is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * rights and limitations under the License.
  *
  * Copyright (C) 2001-2011 The JRuby Community (and contribs)
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the EPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the EPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 package org.jruby.util.cli;
 
 import java.util.List;

Represents a single option, with a category, name, value type, options, default value, and description. This type should be subclassed for specific types of values.

Parameters:
<T> the type of value associated with the option
 
 public abstract class Option<T> {
    
Create a new option with the given values.

Parameters:
<C> an enumeration type
prefix the prefix used for loading this option from properties
name the rest of the property name
type the value type of the option
category the category to which this option belongs
options a list of supported for the option, or null if the set is not applicable
defval the default value for the option
description a description for the option
 
     public Option(String prefixString nameClass<T> typeEnum category, T[] options, T defvalString description) {
         this. = category;
         this. = prefix;
         this. = name;
         this. = prefix + "." + name;
         this. = name;
         this. = type;
         this. = options == null ? new String[]{type.getSimpleName()} : options;
         this. = defval;
         this. = description;
         this. = false;
     }
    
    
Create a new option with the given values.

Parameters:
<C> an enumeration type
longName the property name
type the value type of the option
category the category to which this option belongs
options a list of supported for the option, or null if the set is not applicable
defval the default value for the option
description a description for the option
 
     public Option(String longNameClass<T> typeEnum category, T[] options, T defvalString description) {
         this. = category;
         this. = null;
         this. = null;
         this. = longName;
         this. = longName;
         this. = type;
         this. = options == null ? new String[]{type.getSimpleName()} : options;
         this. = defval;
         this. = description;
         this. = false;
     }
     
     public static Option<Stringstring(String prefixString nameEnum categoryString description) {
         return new StringOption(prefixnamecategorynullnulldescription);
    }
    
    public static Option<Stringstring(String longNameEnum categoryString description) {
        return new StringOption(longNamecategorynullnulldescription);
    }
    
    public static Option<Stringstring(String prefixString nameEnum categoryString defvalString description) {
        return new StringOption(prefixnamecategorynulldefvaldescription);
    }
    
    public static Option<Stringstring(String longNameEnum categoryString defvalString description) {
        return new StringOption(longNamecategorynulldefvaldescription);
    }
    
    public static Option<Stringstring(String prefixString nameEnum categoryString[] optionsString description) {
        return new StringOption(prefixnamecategoryoptionsnulldescription);
    }
    
    public static Option<Stringstring(String longNameEnum categoryString[] optionsString description) {
        return new StringOption(longNamecategoryoptionsnulldescription);
    }
    
    public static Option<Stringstring(String prefixString nameEnum categoryString[] optionsString defvalString description) {
        return new StringOption(prefixnamecategoryoptionsdefvaldescription);
    }
    
    public static Option<Stringstring(String longNameEnum categoryString[] optionsString defvalString description) {
        return new StringOption(longNamecategoryoptionsdefvaldescription);
    }
    
    public static Option<Booleanbool(String prefixString nameEnum categoryString description) {
        return new BooleanOption(prefixnamecategorynulldescription);
    }
    
    public static Option<Booleanbool(String longNameEnum categoryString description) {
        return new BooleanOption(longNamecategorynulldescription);
    }
    
    public static Option<Booleanbool(String prefixString nameEnum categoryBoolean defvalString description) {
        return new BooleanOption(prefixnamecategorydefvaldescription);
    }
    
    public static Option<Booleanbool(String longNameEnum categoryBoolean defvalString description) {
        return new BooleanOption(longNamecategorydefvaldescription);
    }
    
    public static Option<Integerinteger(String prefixString nameEnum categoryString description) {
        return new IntegerOption(prefixnamecategorynulldescription);
    }
    
    public static Option<Integerinteger(String longNameEnum categoryString description) {
        return new IntegerOption(longNamecategorynulldescription);
    }
    
    public static Option<Integerinteger(String prefixString nameEnum categoryInteger defvalString description) {
        return new IntegerOption(prefixnamecategorydefvaldescription);
    }
    
    public static Option<Integerinteger(String longNameEnum categoryInteger defvalString description) {
        return new IntegerOption(longNamecategorydefvaldescription);
    }
    
    public static Option<Integerinteger(String prefixString nameEnum categoryInteger[] optionsInteger defvalString description) {
        return new IntegerOption(prefixnamecategoryoptionsdefvaldescription);
    }
    
    public static Option<Integerinteger(String longNameEnum categoryInteger[] optionsInteger defvalString description) {
        return new IntegerOption(longNamecategoryoptionsdefvaldescription);
    }
    
    public static <T extends Enum<T>> Option<T> enumeration(String prefixString nameEnum categoryClass<T> enumClassString description) {
        return new EnumerationOption(prefixnamecategoryenumClassnulldescription);
    }
    
    public static <T extends Enum<T>> Option<T> enumeration(String longNameEnum categoryClass<T> enumClassString description) {
        return new EnumerationOption(longNamecategoryenumClassnulldescription);
    }
    
    public static <T extends Enum<T>> Option<T> enumeration(String prefixString nameEnum categoryClass<T> enumClass, T defvalString description) {
        return new EnumerationOption(prefixnamecategoryenumClassdefvaldescription);
    }
    
    public static <T extends Enum<T>> Option<T> enumeration(String longNameEnum categoryClass<T> enumClass, T defvalString description) {
        return new EnumerationOption(longNamecategoryenumClassdefvaldescription);
    }
    
    public static String formatValues(Collection<Optionoptions) {
        StringBuilder sb = new StringBuilder();
        List<Optionsorted = new ArrayList<Option>(options);
        Collections.sort(sorted);
        
        Enum category = null;
        for (Option option : sorted) {
            if (category != option.category) {
                category = option.category;
                sb.append('\n').append(category).append('\n');
            }
            sb
                    .append(option.displayName)
                    .append('=')
                    .append(encodeWhitespace(option.load()))
                    .append('\n');
        }
        return sb.toString();
    }
    public static String formatOptions(Collection<Optionoptions) {
        StringBuilder sb = new StringBuilder();
        List<Optionsorted = new ArrayList<Option>(options);
        Collections.sort(sorted);
        
        Enum category = null;
        for (Option option : sorted) {
            if (category != option.category) {
                category = option.category;
                sb.append("\n################################################################################");
                sb.append("\n# ").append(category);
                sb.append("\n################################################################################\n\n");
            }
            sb.append("# ").append(option.description).append('\n');
            
            sb.append("# Options: ").append(Arrays.toString(option.options)).append(", Default: ").append(encodeWhitespace(option.defval)).append(".\n");
            
            sb.append("\n#");
            sb.append(option.displayName).append('=').append(outputForValue(option.load()));
            
            sb.append("\n\n");
        }
        return sb.toString();
    }
    
    private static Comparator<OptionOptionComparator = new Comparator<Option>() {
        public int compare(Option o1Option o2) {
            int catComp = o1.category.compareTo(o2.category);
            if (catComp != 0) return catComp;
            return o1.displayName.compareTo(o2.displayName);
        }
    };
    
    private static String encodeWhitespace(Object obj) {
        if (obj == nullreturn "null";
        
        String str = obj.toString();
        StringBuilder sb = new StringBuilder(str.length() * 2);
        
        boolean hasWhitespace = false;
        
        for (char c : str.toCharArray()) {
            if (Character.isWhitespace(c)) {
                hasWhitespace = true;
                switch (c) {
                    case '\t':
                        sb.append("\\t");
                        break;
                    case '\n':
                        sb.append("\\n");
                        break;
                    default:
                        sb.append(c);
                        break;
                }
            } else {
                sb.append(c);
            }
        }
        
        if (hasWhitespace) {
            return "\"" + sb.toString() + "\"";
        } else {
            return str;
        }
    }
    
    private static String outputForValue(Object obj) {
        if (obj == null) {
            return "";
        } else {
            return encodeWhitespace(obj);
        }
    }
    @Override
    public String toString() {
        return ;
    }
    public String loadProperty() {
        String value = null;
        try {
            value = System.getProperty();
        } catch (SecurityException se) {
        }
        
        if (value != null = true;
        return value;
    }
    public boolean isSpecified() {
        return ;
    }
    public T load() {
        if (this. != nullreturn ;
        
         = reload();
        
        return ;
    }
    
    public abstract T reload();
    public final Enum category;
    public final String prefix;
    public final String name;
    public final String longName;
    public final String displayName;
    public final Class<T> type;
    public final Object[] options;
    public final T defval;
    public final String description;
    public T value;
    private boolean specified;
New to GrepCode? Check out our FAQ X