important optimiz...

Author: SimplyProgrammer

SerialX-core/src/main/java/org/ugp/serialx/Utils.java

@@ -770,6 +770,26 @@ public static boolean contains(CharSequence str, char... oneOf)
 		return false;
 	}
 
+	/**
+	 * @param str | Source string to compare.
+	 * @param lowerCaseOther | Other lower-case string to compare with. This must be lower-case in order for this to work! 
+	 * @param from | The beginning index, where to start with comprising (inclusive, most likely 0).
+	 * @param to | The ending marking index, index where to end the comparing (exclusive, most likely <code>str.length()</code>)
+	 * 
+	 * @return True if str is equal to lowerCaseOther given that str case is ignored and lowerCaseOther is lower-case, otherwise false. Similar to {@link String#equalsIgnoreCase(String)} but more optimal!<br>
+	 * Note that this function was designed for non-blank ASCII strings and may not work properly for others...<br>
+	 * Also sufficient length of both strings is not checked so adjust from and to accordingly.
+	 * 
+	 * @since 1.3.7
+	 */
+	public static boolean equalsLowerCase(CharSequence str, CharSequence lowerCaseOther, int from, int to)
+	{
+		for (; from < to; from++)
+			if ((str.charAt(from) | ' ') != lowerCaseOther.charAt(from))
+				return false;
+		return true;
+	}
+	
 	/**
 	 * @param str | String to display!
 	 * @param pos | Position to display!

SerialX-core/src/main/java/org/ugp/serialx/converters/BooleanConverter.java

@@ -1,5 +1,8 @@
 package org.ugp.serialx.converters;
 
+import static java.lang.Boolean.*;
+import static org.ugp.serialx.Utils.equalsLowerCase;
+
 /**
  * This converter is capable of converting {@link String}. 
  * Its case insensitive!
@@ -19,19 +22,19 @@
 		</tr>
 		<tr>
 		    <td>true</td>
-		    <td>new Boolean(true)</td>
+		    <td>Boolean.TRUE</td>
 	  	</tr>
 	    <tr>
 		    <td>t</td>
-		    <td>new Boolean(true)</td>
+		    <td>Boolean.TRUE</td>
 		</tr>
 	  	<tr>
 		    <td>false</td>
-		    <td>new Boolean(false)</td>
+		    <td>Boolean.FALSE</td>
 		</tr>
 		<tr>
 		    <td>f</td>
-		    <td>new Boolean(false)</td>
+		    <td>Boolean.FALSE</td>
 		</tr>
 	</table>
 	
@@ -54,12 +57,16 @@ public BooleanConverter(boolean shorten)
 	}
 
 	@Override
-	public Object parse(ParserRegistry myHomeRegistry, String arg, Object... args)
+	public Object parse(ParserRegistry myHomeRegistry, String str, Object... args)
 	{
-		if (arg.equalsIgnoreCase("T") || arg.equalsIgnoreCase("true"))
-			return new Boolean(true);
-		if (arg.equalsIgnoreCase("F") || arg.equalsIgnoreCase("false"))
-			return new Boolean(false);
+		int len, ch0;
+		if ((len = str.length()) > 0)
+		{
+			if ((ch0 = str.charAt(0) | ' ') == 't' && (len == 1 || len == 4 && equalsLowerCase(str, "true", 1, 4)))
+				return TRUE;
+			if (ch0 == 'f' && (len == 1 || len == 5 && equalsLowerCase(str, "false", 1, 5)))
+				return FALSE;
+		}
 		return CONTINUE;
 	}
 

SerialX-core/src/main/java/org/ugp/serialx/converters/CharacterConverter.java

@@ -1,7 +1,5 @@
 package org.ugp.serialx.converters;
 
-import static org.ugp.serialx.Utils.fastReplace;
-
 /**
  * This converter is capable of converting {@link Character}.
  * Its case sensitive!
@@ -38,16 +36,17 @@ public class CharacterConverter implements DataConverter
 	@Override
 	public Object parse(ParserRegistry myHomeRegistry, String str, Object... args) 
 	{
-		if (str.length() > 1 && str.charAt(0) == '\'' && str.charAt(str.length()-1) == '\'')
+		int len;
+		if ((len = str.length()) > 1 && str.charAt(0) == '\'' && str.charAt(--len) == '\'')
 			try
 			{
-				if (str.equals("''")) // TODO: str.length() == 2 + mby cache len
-					return new Character(' ');
-				return new Character((char) Integer.parseInt(str = fastReplace(str, "'", "")));
+				if (len == 1) // str == "''"
+					return ' ';
+				return (char) Integer.parseInt(str.substring(1, len));
 			}
 			catch (Exception e) 
 			{
-				return new Character(str.charAt(0));
+				return str.charAt(0);
 			}
 		return CONTINUE;
 	}

SerialX-core/src/main/java/org/ugp/serialx/converters/NullConverter.java

@@ -1,5 +1,7 @@
 package org.ugp.serialx.converters;
 
+import static org.ugp.serialx.Utils.equalsLowerCase;
+
 /**
  * This converter is capable of converting "nothing" otherwise known as null and {@link DataParser#VOID}.
  * Its case insensitive!
@@ -19,7 +21,7 @@
 		</tr>
 		<tr>
 		    <td>null</td>
-		    <td>null (object)</td>
+		    <td>null</td>
 	  	</tr>
 	  	<tr>
 		    <td>void</td>
@@ -36,10 +38,13 @@ public class NullConverter implements DataConverter
 	@Override
 	public Object parse(ParserRegistry registry, String str, Object... args)
 	{
-		if (str.equalsIgnoreCase("null"))
-			return null;
-		if (str.equalsIgnoreCase("void"))
-			return VOID;
+		if (str.length() == 4)
+		{
+			if (equalsLowerCase(str, "null", 0, 4))
+				return null;
+			if (equalsLowerCase(str, "void", 0, 4))
+				return VOID;
+		}
 		return CONTINUE;
 	}
 

SerialX-core/src/main/java/org/ugp/serialx/converters/NumberConverter.java

@@ -7,8 +7,6 @@
 import java.text.DecimalFormatSymbols;
 import java.util.Locale;
 
-import org.ugp.serialx.LogProvider;
-
 /**
  * This converter is capable of converting {@link Number} including all common implementations like {@link Double}, {@link Float}, {@link Integer} and others. They are determine by suffixes like in java!
  * Its case insensitive!
@@ -66,6 +64,8 @@ <td>new Integer(255)</td>
 		    <td>new Integer(15)</td>
 		</tr>
 	</table>
+ *
+ * @see NumberConverter#numberOf(CharSequence, char, int, int)
  * 
  * @author PETO
  * 
@@ -89,47 +89,15 @@ public class NumberConverter implements DataConverter
 	@Override
 	public Object parse(ParserRegistry myHomeRegistry, String arg, Object... args) 
 	{
-		if (arg.length() > 0)
+		int len;
+		if ((len = arg.length()) > 0)
 		{
-			char ch = arg.charAt(0);
-			if (ch == '+' || ch == '-' || ch == '.' || (ch >= '0' && ch <= '9'))
+			char ch0 = arg.charAt(0);
+			if (ch0 == '+' || ch0 == '-' || ch0 == '.' || (ch0 >= '0' && ch0 <= '9'))
 			{
-				arg = normFormatNum(arg.toLowerCase());
-				ch = arg.charAt(arg.length()-1); //ch = last char
-				
-				if (ch == '.')
-					return CONTINUE;
-				if (contains(arg, '.') || (!arg.startsWith("0x") && ch == 'f' || ch == 'd'))
-				{
-					if (ch == 'f')
-						return new Float(fastReplace(arg, "f", ""));
-					return new Double(fastReplace(arg, "d", ""));
-				}
-				 
-				try
-				{
-					// TODO: Use decode method instead of this mess if possible...
-					if (ch == 'l')
-						return new Long(Long.parseLong(fastReplace(fastReplace(fastReplace(arg, "l", ""), "0b", ""), "0x", ""), arg.startsWith("0b") ? 2 : arg.startsWith("0x") ? 16 : 10));
-					if (ch == 's')
-						return new Short(Short.parseShort(fastReplace(fastReplace(fastReplace(arg, "s", ""), "0b", ""), "0x", ""), arg.startsWith("0b") ? 2 : arg.startsWith("0x") ? 16 : 10));
-					if (ch == 'y')
-						return new Byte(Byte.parseByte(fastReplace(fastReplace(arg, "y", ""), "0b", ""), arg.startsWith("0b") ? 2 : 10));
-					return new Integer(Integer.parseInt(fastReplace(fastReplace(arg, "0b", ""), "0x", ""), arg.startsWith("0b") ? 2 : arg.startsWith("0x") ? 16 : 10));
-				}
-				catch (NumberFormatException e)
-				{
-					if (arg.matches("[0-9.]+"))
-						try
-						{	
-							return new Long(Long.parseLong(fastReplace(fastReplace(fastReplace(arg, "l", ""), "0b", ""), "0x", ""), arg.startsWith("0b") ? 2 : arg.startsWith("0x") ? 16 : 10));
-						}
-						catch (NumberFormatException e2)
-						{
-							LogProvider.instance.logErr("Number " + arg + " is too big for its datatype! Try to change its datatype to double (suffix D)!", e2);
-							return null;
-						}
-				}
+				Number num;
+				if ((num = numberOf(arg, ch0, --len, 10, 0)) != null)
+					return num;
 			}
 		}
 		return CONTINUE;
@@ -174,6 +142,101 @@ public String format(Number num)
 		return num.toString();
 	}
 
+	/**
+	 * @param str | Source char sequence with number to parse.
+	 * @param ch0 | Should be <code>str.charAt(0)</code>. This is to ensure that string is not null or empty and also for possible optimizations.
+	 * @param end | Index of where to end with parsing. If whole string is meant to be parsed, then <code>str.length()-1</code>, should not be greater than that!
+	 * @param base | Base of the parsed number. Theoretically can be anything but usually should be 2, 8, 10 or 16... Note that base will be overridden by suffixes <code>#</code>. for 16, <code>0x</code> for 16, <code>0b</code> for 2 or <code>0</code> for 8 (only if not followed by <code>.</code>).
+	 * @param type | Preferred datatype of of the number represented by suffixes 'S' for {@link Short}, 'Y' for {@link Byte}, 'L' for {@link Long}, 'D' for {@link Double}, 'F' for {@link Float}. Other stands for {@link Integer}.<br> 
+	 * Note that floating point numberer will be treated as {@link Double} if no suffix is present by default. Also numbers in E-notation format with negative exponents can be converted to {@link Double}. Further more, integers will be auto-converted to {@link Long} if overflow should occur!<br>
+	 * Important thing to know is that this argument will be overridden by suffix from str if present!
+	 * 
+	 * @return 
+	 * 
+	 * @since 1.3.7
+	 */
+	public static Number numberOf(CharSequence str, char ch0, int end, int base, int type) //TODO
+	{
+		int start = 0;
+
+		if (ch0 == '#') //Determine base
+		{
+			base = 16;
+			start++;
+		}
+		else if (ch0 == '0' && end > 0)
+		{
+			int ch1 = str.charAt(1) | ' ';
+			if (ch1 == 'b')
+			{
+				base = 2;
+				start++;
+			}
+			else if (ch1 == 'x')
+			{
+				base = 16;
+				start++;
+			}
+			else if (ch1 != '.')
+				base = 8;
+
+			start++;
+		}
+		
+		double result = 0, baseCof = 1, exponent = 1;
+		int chEnd = str.charAt(end--) | ' '; //Determine data type
+		if (base == 10 ? chEnd >= 'd' : chEnd >= 'l')
+			type = chEnd;
+		else if (chEnd == '.')
+			type = 'd';
+		else
+		{
+			result = chEnd > '9' ? chEnd - 'a' + 10 : chEnd - '0';
+			baseCof = base;
+		}
+
+		for (int ch; end >= start; end--) //Parsing
+		{
+			if ((ch = str.charAt(end)) == '-') // Neg
+				result = -result;
+			else if (ch == '.') //Decimal
+			{
+				result /= baseCof;
+				baseCof = 1;
+				if (type == 0)
+					type = 'd';
+			}
+			else if ((ch |= ' ') == 'e' && base == 10) //Handle E-notation
+			{
+				if ((exponent = Math.pow(base, result)) < 1 && type == 0)
+					type = 'd';
+				result = 0;
+				baseCof = 1;
+			}
+			else if (ch == ' ') //Not valid
+				return null;
+			else if (ch != 127 && ch != '+')
+			{
+				result += (ch > '9' ? ch - 'a' + 10 : ch - '0') * baseCof;
+				baseCof *= base;
+			}
+		}
+
+		result *= exponent;
+
+		if (type == 'd')
+			return result;
+		if (type == 'f')
+			return (float) result;
+		if (type == 'l' || result > 0x7fffffff || result < 0x80000000)
+			return (long) result;
+		if (type == 's')
+			return (short) result;
+		if (type == 'y')
+			return (byte) result;
+		return (int) result;
+	}
+	
 	/**
 	 * @param num | Number string to format!
 	 * 

SerialX-core/src/main/java/org/ugp/serialx/converters/StringConverter.java

@@ -43,6 +43,17 @@ public class StringConverter implements DataConverter
 	 */
 	public static boolean serializeStringNormally = true; 
 
+	@Override
+	public String parse(ParserRegistry myHomeRegistry, String str, Object... args) 
+	{	
+		int len;
+		if ((len = str.length()) > 1 && str.charAt(0) == '\"' && str.charAt(--len) == '\"' && indexOfNotInObj(str, ' ') == -1)
+		{
+			return str.substring(1, len);
+		}
+		return CONTINUE;
+	}
+	
 	@Override
 	public CharSequence toString(ParserRegistry myHomeRegistry, Object arg, Object... args) 
 	{
@@ -67,14 +78,6 @@ else if (serializeStringNormally)
 		return CONTINUE;
 	}
 
-	@Override
-	public Object parse(ParserRegistry myHomeRegistry, String str, Object... args) 
-	{	
-		if (str.length() > 1 && str.charAt(0) == '\"' && str.charAt(str.length()-1) == '\"' && indexOfNotInObj(str, ' ') == -1)
-			return str.substring(1, str.length() - 1);
-		return CONTINUE;
-	}
-	
 	@Override
 	public CharSequence getDescription(ParserRegistry myHomeRegistry, Object obj, Object... argsUsedConvert) 
 	{