Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014-2015 the original author or authors.
   *
   * 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.dbflute.cbean.coption.parts;
 
 import java.util.List;
 
The interface of condition-option.

Author(s):
jflute
 
 public class SplitOptionParts implements Serializable {
 
     // ===================================================================================
     //                                                                          Definition
     //                                                                          ==========
     
The serial version UID for object serialization. (Default)
 
     private static final long serialVersionUID = 1L;
 
     // ===================================================================================
     //                                                                           Attribute
     //                                                                           =========
     protected String _delimiter;
     protected List<String_subDelimiterList;
     protected int _splitLimitCount;
 
     // ===================================================================================
     //                                                                               Split
     //                                                                               =====
     public void splitByBlank() {
          = " ";
         addSubDelimiter("\u3000");
         addSubDelimiter("\t");
         addSubDelimiter("\r");
         addSubDelimiter("\n");
     }
 
     public void splitBySpace() {
          = " ";
     }
 
     public void splitBySpaceContainsDoubleByte() {
         splitBySpace();
         addSubDelimiter("\u3000");
     }
 
     public void splitBySpaceContainsDoubleByte(int splitLimitCount) {
          = splitLimitCount;
     }
 
     public void splitByPipeLine() {
          = "|";
     }
 
     public void splitByVarious(List<StringdelimiterList) {
         if (delimiterList == null || delimiterList.isEmpty()) {
             String msg = "The delimiterList should not be null or empty: delimiterList=" + delimiterList;
             throw new IllegalArgumentException(msg);
         }
         final List<StringacceptList = new ArrayList<String>(delimiterList);
          = delimiterList.remove(0);
         addSubDelimiter(acceptList);
     }
 
     public void limitSplit(int splitLimitCount) {
         if ( == null) {
             String msg = "The limitSplit() needs splitBy...() but not called.";
             throw new IllegalConditionBeanOperationException(msg);
         }
          = splitLimitCount;
     }
 
     // ===================================================================================
     //                                                                       Sub Delimiter
     //                                                                       =============
     protected void addSubDelimiter(String delimiter) {
         if ( == null) {
              = new ArrayList<String>();
         }
         .add(delimiter);
    }
    protected void addSubDelimiter(List<StringdelimiterList) {
        if ( == null) {
             = new ArrayList<String>();
        }
        .addAll(delimiterList);
    }
    // ===================================================================================
    //                                                                       Determination
    //                                                                       =============
    public boolean isSplit() {
        return  != null;
    }
    // ===================================================================================
    //                                                                          Real Value
    //                                                                          ==========
    public String[] generateSplitValueArray(String value) {
        if (value == null) {
            String msg = "The argument[value] should not be null!";
            throw new IllegalArgumentException(msg);
        }
        value = resolveSubSplit(value);
        final StringTokenizer st = new StringTokenizer(value);
        final String[] tokenizedValues = new String[st.countTokens()];
        int count = 0;
        while (st.hasMoreTokens()) {
            tokenizedValues[count] = st.nextToken();
            count++;
        }
        // "FOO|BAR||QUX" should be treated as "FOO, BAR, QUX" (three elements)
        final String[] values = removeInvalidValue(tokenizedValues);
        if ( > 0 && values.length > ) {
            final String[] realValues = new String[];
            for (int i = 0; i < values.lengthi++) {
                if (i == ) {
                    break;
                }
                realValues[i] = values[i];
            }
            return realValues;
        } else {
            return values;
        }
    }
    protected String resolveSubSplit(String value) {
        if (value == null ||  == null ||  == null) {
            return value;
        }
        for (String subSplit : ) {
            value = replace(valuesubSplit);
        }
        return value;
    }
    protected String[] removeInvalidValue(String[] values) {
        final List<Stringls = new ArrayList<String>();
        for (int i = 0; i < values.lengthi++) {
            final String value = values[i];
            if (value == null || value.equals("")) { // don't trim
                continue;
            }
            ls.add(value);
        }
        final String[] resultArray = new String[ls.size()];
        for (int i = 0; i < ls.size(); i++) {
            resultArray[i] = (Stringls.get(i);
        }
        return resultArray;
    }
    // ===================================================================================
    //                                                                      General Helper
    //                                                                      ==============
    protected final String replace(String strString fromStrString toStr) {
        return Srl.replace(strfromStrtoStr);
    }
    // =====================================================================================
    //                                                                             Deep Copy
    //                                                                             =========
    public Object createDeepCopy() {
        final SplitOptionParts deepCopy = new SplitOptionParts();
        deepCopy._delimiter = ;
        deepCopy._subDelimiterList = ;
        deepCopy._splitLimitCount = ;
        return deepCopy;
    }
New to GrepCode? Check out our FAQ X