Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.util;
 
 
 import java.util.List;
Splits and joins strings on a separator. Similar to Google's Splitter http://guava-libraries.googlecode.com/svn/tags/release09/javadoc/com/google/common/base/Splitter.html and Joiner http://guava-libraries.googlecode.com/svn/tags/release09/javadoc/com/google/common/base/Joiner.html. Immutable, configuration methods return new instances.
 
 public class Separator {
    
Whitespace delimited lists. Skip empty because I want to ignore heading/tailing whitespace
 
     public static final Separator SPACE = Separator.on(" ", Pattern.compile("\\s+")).skipEmpty();

    
Separator in user-supplied lists.
 
     public static final Separator COMMA = Separator.on(',').trim().skipEmpty().forNull("null");

    
Skip empty remove the last line
 
     public static final Separator RAW_LINE = Separator.on("\n".).trim(..).skipEmpty();
 
     public static Separator on(char c) {
         return on(Character.toString(c));
     }
 
     public static Separator on(String separator) {
         return new Separator(separator, Pattern.compile(Pattern.quote(separator)));
     }
 
     public static Separator on(String separatorPattern pattern) {
         return new Separator(separatorpattern);
     }
 
     //--
 
     private final String separator;
     private final Pattern pattern;
     private final LineFormat.Trim trim;
     private final boolean skipEmpty;
     private final String forNull;
     private final boolean skipNull;
 
     public Separator(String separatorPattern pattern) {
         this(separatorpattern..falsenullfalse);
     }
 
     public Separator(String separatorPattern patternLineFormat.Trim trimboolean skipEmptyString forNullboolean skipNull) {
         if (separator.isEmpty()) {
             throw new IllegalArgumentException("Empty separator");
         }
         if (pattern.matcher("").find()) {
             throw new IllegalArgumentException(pattern.pattern() + " matches the empty string");
         }
         if (!pattern.matcher(separator).find()) {
             throw new IllegalArgumentException("Separtor " + separator + " does not match pattern " + pattern.pattern());
         }
         this. = separator;
         this. = pattern;
         this. = trim;
         this. = skipEmpty;
         this. = forNull;
         this. = skipNull;
     }
 
     public Separator(Separator orig) {
         this(orig.separatororig.patternorig.trimorig.skipEmptyorig.forNullorig.skipNull);
     }
 
     //--
 
     public String getSeparator() {
         return ;
     }
 
     //-- configuration
 
    
Trim elements before joining or after splitting
 
    public Separator trim() {
        return trim(..);
    }

    
Trim elements before joining or after splitting
    public Separator trim(LineFormat.Trim trim) {
        return new Separator(trim);
    }

    
Do not join empty elements and to not return them from splitting.
    public Separator skipEmpty() {
        return new Separator(true);
    }
    public Separator forNull(String forNull) {
        return new Separator(forNull);
    }
    public Separator skipNull() {
        return new Separator(true);
    }
    //-- joining
    public String join(Object[] array) {
        return join(java.util.Arrays.asList(array));
    }
    public String join(Iterable<?> lst) {
        StringBuilder result;
        result = new StringBuilder();
        joinTo(resultlst);
        return result.toString();
    }
    public String join(Object firstObject secondObject ... rest) {
        int count;
        StringBuilder result;
        result = new StringBuilder();
        try {
            count = joinTo(result, 0, java.util.Arrays.asList(first));
            count = joinTo(resultcount, java.util.Arrays.asList(second));
            joinTo(resultcount, java.util.Arrays.asList(rest));
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
        return result.toString();
    }
    //--
    public void joinTo(StringBuilder destIterable<?> lst) {
        try {
            joinTo(dest, 0, lst);
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }

    

Returns:
number of objects appended
    public int joinTo(Appendable destint countIterable<?> lstthrows IOException {
        String str;
        for (Object obj : lst) {
            if (obj == null) {
                if ( != null) {
                    obj = ;
                } else if () {
                    continue;
                } else {
                    throw new NullPointerException();
                }
            }
            str = obj.toString();
            if ( == ..) {
                str = str.trim();
            }
            if ( && str.isEmpty()) {
                continue;
            }
            if (count > 0) {
                dest.append();
            }
            count++;
            dest.append(str);
        }
        return count;
    }
    //-- split
    public List<Stringsplit(CharSequence str) {
        List<Stringlst;
        lst = new ArrayList<String>();
        splitTo(lststr);
        return lst;
    }
    public void splitTo(List<StringdestCharSequence str) {
        int length;
        Matcher matcher;
        int prev;
        length = str.length();
        if (length == 0) {
            return;
        }
        matcher = .matcher(str);
        prev = 0;
        while (matcher.find()) {
            add(deststr.subSequence(prev == .. ? matcher.end() : matcher.start()));
            prev = matcher.end();
        }
        if (prev <= length) {
            add(deststr.subSequence(prevlength));
        }
    }
    private void add(List<StringresultCharSequence cs) {
        String str;
        str = cs.toString();
        if ( == ..) {
            str = str.trim();
        }
        if ( && str.isEmpty()) {
            return;
        }
        result.add(str);
    }
New to GrepCode? Check out our FAQ X