src/org/lwes/serializer/StringParser.java

   1 package org.lwes.serializer;
   2
   3 import org.lwes.EventSystemException;
   4 import org.lwes.TypeID;
   5 import org.lwes.util.IPAddress;
   6 import org.lwes.util.Log;
   7 import org.lwes.util.NumberCodec;
   8
   9 import java.util.regex.Pattern;
  10
  11 /**
  12  * This contains low level type serialization used by the rest of the system.
  13  *
  14  * @author Anthony Molinaro
  15  * @author Michael P. Lum
  16  */
  17 public class StringParser {
  18
  19         public static Object fromStringBYTE(String string)
  20                         throws EventSystemException {
  21                 Object toReturn = null;
  22
  23                 return toReturn;
  24         }
  25
  26         public static Object fromStringBOOLEAN(String string)
  27                         throws EventSystemException {
  28                 Log.trace("Parsing boolean");
  29                 Object toReturn = Boolean.valueOf(string);
  30                 Log.trace("Got '" + toReturn + "'");
  31                 return toReturn;
  32         }
  33
  34         public static Object fromStringUINT16(String string)
  35                         throws EventSystemException {
  36                 Object toReturn = null;
  37
  38                 Log.trace("Parsing uint16");
  39                 if (Pattern.matches(TypeID.HEX_SHORT_REGEX, string)) {
  40                         if (string.startsWith("0x"))
  41                                 string = string.substring(2);
  42
  43                         /* pad with zeros since NumberCodec.decodeInt expects a length of 8 */
  44                         string = "0000" + string;
  45                         byte[] bytes = NumberCodec.hexStringToByteArray(string);
  46                         toReturn = NumberCodec.decodeInt(bytes, 0, bytes.length);
  47                 } else {
  48                         try {
  49                                 toReturn = Integer.valueOf(string);
  50                         } catch (NumberFormatException nfe) {
  51                                 throw new EventSystemException(nfe);
  52                         }
  53                         int intValue = (Integer) toReturn;
  54                         if (intValue < 0 || intValue > 65535) {
  55                                 throw new EventSystemException("Unsigned Short must be in the "
  56                                                 + "range [0-65535] ");
  57                         }
  58                 }
  59                 Log.trace("received '" + toReturn + "'");
  60
  61                 return toReturn;
  62         }
  63
  64         public static Object fromStringINT16(String string)
  65                         throws EventSystemException {
  66                 Object toReturn = null;
  67
  68                 Log.trace("Parsing int16");
  69                 if (Pattern.matches(TypeID.HEX_SHORT_REGEX, string)) {
  70                         if (string.startsWith("0x"))
  71                                 string = string.substring(2);
  72
  73                         byte[] bytes = NumberCodec.hexStringToByteArray(string);
  74                         toReturn = NumberCodec.decodeShort(bytes, 0, bytes.length);
  75                 } else {
  76                         try {
  77                                 toReturn = Short.valueOf(string);
  78                         } catch (NumberFormatException nfe) {
  79                                 throw new EventSystemException("Probably not a short, "
  80                                                 + "got exception " + nfe);
  81                         }
  82                         short shortValue = (Short) toReturn;
  83                         if (shortValue < -32768 || shortValue > 32767) {
  84                                 throw new EventSystemException("Signed Short must be in the "
  85                                                 + "range [-32768 - 32767] ");
  86                         }
  87                 }
  88                 Log.trace("received '" + toReturn + "'");
  89
  90                 return toReturn;
  91         }
  92
  93         public static Object fromStringUINT32(String string)
  94                         throws EventSystemException {
  95                 Object toReturn = null;
  96
  97                 Log.trace("Parsing uint32");
  98                 if (Pattern.matches(TypeID.HEX_INT_REGEX, string)) {
  99                         if (string.startsWith("0x"))
 100                                 string = string.substring(2);
 101
 102                         /* pad with zeros since NumberCodec.decodeLong expects a length of 8 */
 103                         string = "00000000" + string;
 104                         byte[] bytes = NumberCodec.hexStringToByteArray(string);
 105                         toReturn = NumberCodec.decodeLong(bytes, 0, bytes.length);
 106                 } else {
 107                         try {
 108                                 toReturn = Long.valueOf(string);
 109                         } catch (NumberFormatException nfe) {
 110                                 throw new EventSystemException(nfe);
 111                         }
 112                         long longValue = (Long) toReturn;
 113                         if (longValue < 0
 114                                         || longValue > ((long) Integer.MAX_VALUE - ((long) Integer.MIN_VALUE))) {
 115                                 throw new EventSystemException("Unsigned Int must be in the "
 116                                                 + "range [0-"
 117                                                 + ((long) Integer.MAX_VALUE - (long) Integer.MIN_VALUE)
 118                                                 + "] ");
 119                         }
 120                 }
 121                 Log.trace("received '" + toReturn + "'");
 122
 123                 return toReturn;
 124         }
 125
 126         public static Object fromStringINT32(String string)
 127                         throws EventSystemException {
 128                 Object toReturn = null;
 129
 130                 Log.trace("Parsing int32");
 131                 if (Pattern.matches(TypeID.HEX_INT_REGEX, string)) {
 132                         if (string.startsWith("0x"))
 133                                 string = string.substring(2);
 134
 135                         byte[] bytes = NumberCodec.hexStringToByteArray(string);
 136                         toReturn = NumberCodec.decodeInt(bytes, 0, bytes.length);
 137                 } else {
 138                         try {
 139                                 toReturn = Integer.valueOf(string);
 140                         } catch (NumberFormatException nfe) {
 141                                 throw new EventSystemException(nfe);
 142                         }
 143                 }
 144                 Log.trace("received '" + toReturn + "'");
 145
 146                 return toReturn;
 147         }
 148
 149         public static Object fromStringUINT64(String string)
 150                         throws EventSystemException {
 151                 Object toReturn = null;
 152
 153                 Log.trace("Parsing uint64");
 154                 if (Pattern.matches(TypeID.HEX_LONG_REGEX, string)) {
 155                         if (string.startsWith("0x"))
 156                                 string = string.substring(2);
 157
 158                         byte[] bytes = NumberCodec.hexStringToByteArray(string);
 159                         toReturn = NumberCodec.decodeLong(bytes, 0, bytes.length);
 160                 } else {
 161                         try {
 162                                 toReturn = Long.valueOf(string);
 163                         } catch (NumberFormatException nfe) {
 164                                 throw new EventSystemException("Got Exception " + nfe);
 165                         }
 166                 }
 167                 Log.trace("received '" + toReturn + "'");
 168
 169                 return toReturn;
 170         }
 171
 172         public static Object fromStringINT64(String string)
 173                         throws EventSystemException {
 174                 Object toReturn = null;
 175
 176                 Log.trace("Parsing int64");
 177                 if (Pattern.matches(TypeID.HEX_LONG_REGEX, string)) {
 178                         if (string.startsWith("0x"))
 179                                 string = string.substring(2);
 180
 181                         byte[] bytes = NumberCodec.hexStringToByteArray(string);
 182                         toReturn = NumberCodec.decodeLong(bytes, 0, bytes.length);
 183                 } else {
 184                         try {
 185                                 toReturn = Long.valueOf(string);
 186                         } catch (NumberFormatException nfe) {
 187                                 throw new EventSystemException(nfe);
 188                         }
 189                 }
 190                 Log.trace("received '" + toReturn + "'");
 191
 192                 return toReturn;
 193         }
 194
 195         public static Object fromStringSTRING(String string)
 196                         throws EventSystemException {
 197
 198                 Log.trace("Parsing string '" + string + "'");
 199                 return string;
 200         }
 201
 202         public static Object fromStringIPADDR(String string)
 203                         throws EventSystemException {
 204                 Object toReturn = null;
 205
 206                 Log.trace("Parsing IPAddress");
 207
 208                 if (Pattern.matches(TypeID.IP_ADDR_REGEX, string)) {
 209                         toReturn = new IPAddress(string);
 210                         if (((IPAddress) toReturn).toInt() == 0) {
 211                                 throw new EventSystemException("Possible Bad IP Address "
 212                                                 + string);
 213                         }
 214                 } else {
 215                         throw new EventSystemException("Invalid IP Address");
 216                 }
 217                 Log.trace("received '" + toReturn + "'");
 218
 219                 return toReturn;
 220         }
 221 }