001package com.pi4j.util;
002
003/*
004 * #%L
005 * **********************************************************************
006 * ORGANIZATION  :  Pi4J
007 * PROJECT       :  Pi4J :: Java Library (Core)
008 * FILENAME      :  StringUtil.java  
009 * 
010 * This file is part of the Pi4J project. More information about 
011 * this project can be found here:  http://www.pi4j.com/
012 * **********************************************************************
013 * %%
014 * Copyright (C) 2012 - 2013 Pi4J
015 * %%
016 * Licensed under the Apache License, Version 2.0 (the "License");
017 * you may not use this file except in compliance with the License.
018 * You may obtain a copy of the License at
019 * 
020 *      http://www.apache.org/licenses/LICENSE-2.0
021 * 
022 * Unless required by applicable law or agreed to in writing, software
023 * distributed under the License is distributed on an "AS IS" BASIS,
024 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
025 * See the License for the specific language governing permissions and
026 * limitations under the License.
027 * #L%
028 */
029
030
031public class StringUtil {
032    
033    public static final String EMPTY = "";
034    public static final char DEFAULT_PAD_CHAR = ' ';
035
036    public static boolean isNullOrEmpty(String data, boolean trim){
037        if(data == null)
038            return true;
039        
040        // trim if requested
041        String test = data;
042        if(trim)
043            test = data.trim();
044            
045        return (test.length() <= 0);        
046    }
047    
048    public static boolean isNullOrEmpty(String data){
049        return isNullOrEmpty(data, false);        
050    }
051
052    public static boolean isNotNullOrEmpty(String data){
053        return isNotNullOrEmpty(data, false);        
054    }
055
056    public static boolean isNotNullOrEmpty(String data, boolean trim){
057        return !(isNullOrEmpty(data, trim));        
058    }
059    
060    public static boolean contains(String source, String target)  {
061        
062        if (null != source && null != target) { 
063            return source.contains(target);
064        }
065        return false;
066    }     
067
068    public static boolean contains(String source, String[] targets)  {
069        if (null != source && null != targets) { 
070            for (int i=0; i<targets.length; i++) {
071                if (source.indexOf(targets[i]) >= 0) {
072                    return true;
073                }
074            }
075        }
076        return false;
077    }     
078
079    public static boolean contains(String[] sources, String target)  {
080        if (null != sources && null != target) { 
081            for (String source : sources) {
082                if(contains(source, target))
083                    return true;
084            }
085        }
086        return false;
087    }     
088
089    public static boolean contains(String[] sources, String[] targets)  {
090        if (null != sources && null != targets) { 
091            for (String source : sources) {
092                if(contains(source, targets))
093                    return true;
094            }
095        }
096        return false;
097    }     
098    
099    public static String create(int length)  {
100        return create(DEFAULT_PAD_CHAR, length);
101    }
102    
103    public static String create(char c, int length)  {
104        StringBuilder sb = new StringBuilder(length);
105        for(int index = 0; index < length; index++)
106            sb.append(c);
107        return sb.toString();
108    }     
109    
110    public static String create(String s, int length)  {
111        StringBuilder sb = new StringBuilder(length * s.length());
112        for(int index = 0; index < length; index++)
113            sb.append(s);
114        return sb.toString();
115    }     
116
117    public static String padLeft(String data, int length)  {
118        return padLeft(data, DEFAULT_PAD_CHAR, length);
119    }
120    
121    public static String padLeft(String data, char pad, int length)  {
122        StringBuilder sb = new StringBuilder(data.length() + length);
123        for(int index = 0; index < length; index++)
124            sb.append(pad);
125        sb.append(data);
126        return sb.toString();
127    }     
128
129    public static String padLeft(String data, String pad, int length)  {
130        StringBuilder sb = new StringBuilder(data.length() + (length * pad.length()));
131        for(int index = 0; index < length; index++)
132            sb.append(pad);
133        sb.append(data);
134        return sb.toString();
135    }     
136
137    public static String padRight(String data, int length)  {
138        return padRight(data, DEFAULT_PAD_CHAR, length);
139    }
140    
141    public static String padRight(String data, char pad, int length)  {
142        StringBuilder sb = new StringBuilder(data.length() + length);
143        sb.append(data);
144        for(int index = 0; index < length; index++)
145            sb.append(pad);        
146        return sb.toString();
147    }     
148
149    public static String padRight(String data, String pad, int length)  {
150        StringBuilder sb = new StringBuilder(data.length() + (length * pad.length()));
151        sb.append(data);
152        for(int index = 0; index < length; index++)
153            sb.append(pad);
154        return sb.toString();
155    }     
156
157    public static String pad(String data, int length)  {
158        return pad(data, DEFAULT_PAD_CHAR, length);
159    }
160    
161    public static String pad(String data, char pad, int length)  {
162        StringBuilder sb = new StringBuilder(data.length() + length);
163        sb.append(create(pad, length));
164        sb.append(data);
165        sb.append(create(pad, length));
166        return sb.toString();
167    }     
168
169    public static String pad(String data, String pad, int length)  {
170        StringBuilder sb = new StringBuilder(data.length() + length);
171        sb.append(create(pad, length));
172        sb.append(data);
173        sb.append(create(pad, length));
174        return sb.toString();
175    }     
176
177    public static String padCenter(String data, int length) {
178        return padCenter(data, DEFAULT_PAD_CHAR, length);
179    }
180    
181    public static String padCenter(String data, char pad, int length) {
182        if(data.length() < length) {
183            int needed = length - data.length();
184            int padNeeded = needed / 2;
185            StringBuilder result = new StringBuilder();
186            result.append(create(pad, padNeeded));
187            result.append(data);
188            result.append(create(pad, padNeeded));
189            int remaining = length - result.length();
190            result.append(create(pad, remaining));
191            return result.toString();
192        }
193        return data;
194    }
195
196    public static String trimLeft(String data)  {
197        return trimLeft(data, DEFAULT_PAD_CHAR);
198    }
199    
200    public static String trimLeft(String data, char trim)  {
201        for(int index = 0; index < data.length(); index++)
202            if(!(data.charAt(index) == trim))
203                return data.substring(index);
204        return EMPTY;
205    }     
206
207    public static String trimRight(String data)  {
208        return trimRight(data, DEFAULT_PAD_CHAR);
209    }
210    
211    public static String trimRight(String data, char trim)  {
212        int count = 0;
213        for(int index = data.length(); index > 0; index--)
214            if(data.charAt(index-1) == trim)
215                count++;
216            else
217                return data.substring(0, data.length() - count);
218        return EMPTY;
219    }     
220
221    public static String trim(String data)  {
222        return trim(data, DEFAULT_PAD_CHAR);
223    }
224    
225    public static String trim(String data, char trim)  {
226        String result = trimLeft(data, trim);
227        return trimRight(result, trim);
228    }
229    
230}