nyla.solutions.global.util.Text Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of nyla.solutions.global Show documentation
Nyla Solutions Global Java API provides support for basic application utilities (application configuration, data encryption, debugger and text processing).
The newest version!
package nyla.solutions.global.util;
import java.io.*;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import nyla.solutions.global.data.Textable;
import nyla.solutions.global.exception.FormatException;
import nyla.solutions.global.exception.RequiredException;
import nyla.solutions.global.exception.SetupException;
import nyla.solutions.global.exception.SystemException;
import nyla.solutions.global.io.IO;
import nyla.solutions.global.patterns.decorator.style.TextStyles;
import nyla.solutions.global.util.Config;
import nyla.solutions.global.util.Debugger;
import nyla.solutions.global.util.Text;

/**
 *  * Text is geared toward string based processing. It includes template engine support 
 * like Free Marker that builds composite strings/values dynamically at runtime 
 *  (see http://freemarker.sourceforge.net/). There are also methods to support complex 
 *  regular expressions with Boolean AND, OR and NOT logic, numerous string conversions, 
 *  general text manipulation and parsing methods.
 * 
 * @author Gregory Green
 *  
 */

public class Text
{
   /**
    * TEMPLATE_DIR_PROP_NM = Text.class.getName()+".template.dir"
    */
   public static final String TEMPLATE_DIR_PROP_NM = Text.class.getName()+".template.dir";
   
   /**
    * TEMPLATE_EXTENSION_PROP_NM = Text.class.getName()+".template.extension"
    */
   public static final String TEMPLATE_EXTENSION_PROP_NM = Text.class.getName()+".template.extension";
      
   private static final String[] fixedNumberPrefixLookup =
   {
	   "0","00","000","0000","00000","000000","0000000","00000000","000000000","0000000000"
   };
   
   /**
    * Complex matches ${NOT}
    */
   public static final String NOT = "${NOT}";
   
   /**
    * Complex matches ${OR}
    */
   public static final String OR = "${OR}";
   
   /**
    * Complex matches and
    */
   private static final String AND  = "${AND}";
   
   /**
    * TEMPLATE_LOCALE_COUNTRY = Text.class.getName()+".TEMPLATE_LOCALE_COUNTRY"
    */
   public static final String TEMPLATE_LOCALE_COUNTRY = Text.class.getName()+".TEMPLATE_LOCALE_COUNTRY";
   
   /**
    * TEMPLATE_LOCALE_LANGUAGE = Text.class.getName()+".TEMPLATE_LOCALE_LANGUAGE"
    */
   public static final String TEMPLATE_LOCALE_LANGUAGE = Text.class.getName()+".TEMPLATE_LOCALE_LANGUAGE";
   /**
    * SPECIAL_START = "${START}" used for the parse method (start tag)
    */
   public static final String SPECIAL_START = "${START}";
   
   /**
    * SPECIAL_END = "${END} used for the parse method (end tag)
    */
   public static final String SPECIAL_END = "${END}";
   
   /**
    * DATE_FORMAT = Config.getProperty(Text.class.getName()+".formatDate","MM/dd/yyyy hh:mm:ss a")
    */
   public static final String DATE_FORMAT = Config.getProperty(Text.class.getName()+".DATE_FORMAT","MM/dd/yyyy hh:mm:ss:SS a");

   /**
    * Append newline to text
    * 
    */
   public static String appendNewLine(String text)
   {
	  
	  String newline = IO.newline();
	   
	  if(text == null || text.length() == 0)
		  return newline;
	  
	  StringBuilder sb = new StringBuilder(text);
	  
	   if(!text.endsWith(newline))
		{
			 sb.append(newline);
		}
	   
	   return sb.toString();
   }// --------------------------------------------------------
   /**
    * Inject an with the property solutions.global.util.Text.textStyles=className
    *  
    * @return implementation of  text styles
    */
   public static TextStyles getTextStyles()
   {
	   if(textStyles == null)
	   {
		   String className = Config.getProperty(Text.class,"textStyles","nyla.solutions.global.patterns.decorator.style.BasicTextStyles");
		  
		   try
			{
				textStyles = (TextStyles)Class.forName(className).newInstance(); 
			}
			catch (Exception e)
			{
				throw new SetupException("Unable to create TextSytles instance:"+className, e);
			}
	   }
	   
	   return textStyles;
	   
   }// --------------------------------------------------------
   public static String fixedLength(int number, int length)
   {
	   String numberText = String.valueOf(number);
	   int numberLength =  numberText.length();
	   
	   StringBuilder sb = new StringBuilder();
	   
	   if(length > 16)
	   {
		 sb.ensureCapacity(length);  
	   }
	   
	   sb.append(numberText);
	   
	   //prefix 0
	   if(length == numberLength)
		   return sb.toString();
	   
	   
	   if(numberLength > length)
	   {
		   sb.setLength(length);
		   return sb.toString();
	   }
	
	   int diff = length - numberLength;
	   
	   if(diff <  fixedNumberPrefixLookup.length)
	   {
		   sb.insert(0, fixedNumberPrefixLookup[diff-1]);
		   return sb.toString();
	   }
	   
	   //prefix 0(s) = 
	   //length = 2 and value = 1 = 01
	   
	   for(int i=0; i < length- numberLength;i++)
	   {
		   sb.insert(0, "0");
	   }
	   
	   return sb.toString();
	   
	   /*NumberFormat formatter = NumberFormat.getNumberInstance();
	   formatter.setGroupingUsed(false);
	   formatter.setMinimumIntegerDigits(length);
	   
	   return formatter.format(number);*/
   }// ------------------------------------------------
   public static String fixedLength(String text, int length)
   {
	   StringBuilder sb = new StringBuilder(length);
	   
	   sb.append(text);
	   /*Formatter formatter = new Formatter(sb);
	   Object [] input = {text};
	   formatter.format("%0$-"+length+"s", input);
	   */
	   sb.setLength(length);
	   return sb.toString();	
	   
   }// ------------------------------------------------
   
   public static String fixedLength(String text, int length, char filleChar)
   {

	   StringBuilder sb = new StringBuilder(length);
	   sb.append(text);
	   sb.setLength(length);
	   
	   /*
	   Formatter formatter = new Formatter(sb);
	   Object [] input = {text};
	   formatter.format("%0$-"+length+"s", input);
	   
	   if(text == null)
	   {
		 return sb.toString();
	   }*/
	   
	   //Take original 
	   if(filleChar != '\0')
	   {
		   //replace with prefix
		   int originalLength = text.length();
		   
		   if(originalLength < sb.length())
		   {
			   String newEnd = sb.substring(originalLength, sb.length()).replace('\0', filleChar);
			  sb = sb.replace(originalLength, sb.length(), newEnd);
		   }
		   
	   }
	   
	   return sb.toString();	
	   
   }// ------------------------------------------------
   
   /**
    * Loop thrus map to formats any needed value with data from other properties.
    * 
    * See Text.format(String,Map)
    * @param map the map to format
    * @throws FormatException
    */
   public static final void formatMap(Map map)
   throws FormatException
   {
	if(map == null || map.isEmpty())
	   return;// nothing to process
	
	//format properties
      Object key = null;
      Object value =null;
      String text = null;
      
      for (Map.Entry entry : map.entrySet())
      {
		key =  entry.getKey();
		value = entry.getValue();
		
		if(!(value instanceof String))
		   continue; //skip
		
		text = (String)value;
	
		//overwrite value with formatted version
		if(text.indexOf("${") > -1)
		   map.put(key, Text.format(text, map));
	   }
	
   }//----------------------------------------------
   /**
    * Generate a unique ID
    * @return the generated ID
    */
   public static final String generateId()
   {
	Date date = Calendar.getInstance().getTime();
	
	String dateId = formatDate("yyyyMMddHHmmssSS", date);
	
	return new StringBuffer(dateId).append(random.nextInt()).toString();
	
   }// ----------------------------------------------
   /**
    * End all line with \r\n
    * @param s string to replace
    * @return 
    */
   public static String newlineToCrLf(String s)
   {
       String s1 = s.replaceAll("\\r", "");
       String s2 = s1.replaceAll("\\n", "\r\n");
       return s2;
   }// ----------------------------------------------
   
   /**
    * dateFormat = Config.getProperty(Text.class,"dateFormat", "MM/dd/yyyy")
    */
   public static final String  dateFormat = Config.getProperty(Text.class,"dateFormat", "MM/dd/yyyy");
   
  /**
   * 
   * @param text tokens separated by \t\n\r
   * @return tokens separated by \n (newline)
   */
   public static Set toSet(String[] lines)
   {
	   TreeSet set = new TreeSet(Arrays.asList(lines));
	  
	   return set;
   }// --------------------------------------------------------
   
   public static String removeNewLines(String text)
   {
      return replace("\r\n", " ", text);
   }//--------------------------------------------
   
   /**
    * 
    * @param aValue the value
    * @param aType the type of the value
    * @return value cast to the object type instance
    */
   public static Object toObject(String aValue, String aType)
   throws ParseException
   {
      if("Date".equalsIgnoreCase(aType))
      {
         return toDate(aValue);
      }
      else if("Boolean".equalsIgnoreCase(aType))
      {
         return Boolean.valueOf(aValue);
      }
      else if("Int".equalsIgnoreCase(aType) ||
              "Integer".equalsIgnoreCase(aType))
      {
         return Integer.valueOf(aValue);
      }
      else if("Double".equalsIgnoreCase(aType))
      {
         return Double.valueOf(aValue);
      }
      else
      {
         return aValue;
      }
      
   }// --------------------------------------------

   /**
    * Use a regular expression to update a given text
    * @param aText the text to update
    * @param aRE the regular expression
    * @param aReplaceText the replacement text
    * @return the formatted regular expression
    */
   public static String replaceForRegExprWith(final String text,final String re,final String replaceText)
   {
      if(text == null  || text.length() == 0)
         return "";
      
      Pattern pattern = Pattern.compile(re);
      
      return pattern.matcher(text).replaceAll(replaceText);
      
   }// --------------------------------------------
   /**
    * Parse text based on regular expressions 
    * TODO: add multiple results
    * @param startRE the start regular express
    * @param endRE the end regular expression
    * @param text the text to parse
    * @return the parsed output
    */
   public static String parseRE(String text, String startRE,String endRE)
   {
      try
      {
		if(text == null  || text.length() == 0)
		     return text;
		  
		  if(startRE == null || endRE == null)
			  return text;
		  
		  Pattern startPattern = Pattern.compile(startRE);
		  Pattern endPattern = Pattern.compile(endRE);
		  
		  Matcher startMatcher = startPattern.matcher(text);
		  
		  if(!startMatcher.find())
			  return text;
		  
		  int startIndex = startMatcher.end();
		   
		  String endText = text.substring(startIndex);
		  
		  Matcher endMatcher = endPattern.matcher(endText);
		  if(!endMatcher.find())
			  return text.substring(startIndex);
		  
		  int endIndex = endMatcher.start();
		  
		  if(endIndex < 0)
			  endIndex = endText.length() - 1;
		  
		  return text.substring(startIndex, startIndex+endIndex);
		} 
	    catch (IllegalStateException e)
		{
			throw new SystemException("startRE="+startRE+" endRE="+endRE+" text="+text+" "+Debugger.stackTrace(e));
		}
   }// --------------------------------------------
   /**
    * Replace the last instance of the regular expression with a given token
    * @param text the source text
    * @param re the regular expression
    * @param replacement the replacement text
    * @return the text with the last regExpr instance replaced 
    */
   public static String replaceFirstRegExpWith(String text, String re, String replacement )
   {
	   if(text == null || text.length() == 0)
	         return "";
	   
	   //compile pattern
	   Pattern pattern = Pattern.compile(re);
	      
	   return pattern.matcher(text).replaceFirst(replacement);
	   
   }//---------------------------------------------
   /**
    * 
    * @param collection convert collection of String to array
    * @return the array of strings
    */
   @SuppressWarnings("unchecked")
public static String[] toStrings(Object object)
   {
      if(object == null)
         return null;
      
      
      if(object instanceof Collection)
      {
         return toStrings((Collection