src/main/java/org/lwes/BaseType.java

   1 package org.lwes;
   2
   3 import org.lwes.serializer.StringParser;
   4 import org.lwes.util.EncodedString;
   5 import org.lwes.util.IPAddress;
   6 import org.lwes.util.Log;
   7
   8 import java.math.BigInteger;
   9 import java.net.InetAddress;
  10
  11 /**
  12  * This class provides a base type for the base types in the event system. acts
  13  * partially as an interface and partially to provide encapsulation of the
  14  * TypeIDs used in serialization.
  15  * <p/>
  16  * It also provides a sizeof() type method called getByteSize() used to
  17  * determine how many bytes must be used to serialize an object of the given
  18  * type.
  19  *
  20  * @author Anthony Molinaro
  21  */
  22 public class BaseType {
  23     /**
  24      * The name of this type used in the ESF file
  25      */
  26     String typeName = null;
  27
  28     /**
  29      * The type token used during serialization
  30      */
  31     byte typeToken = TypeID.UNDEFINED_TOKEN;
  32
  33     /**
  34      * The object stored in this type
  35      */
  36     Object typeObject = null;
  37
  38     /**
  39      * Is this guy required
  40      */
  41     private boolean required;
  42
  43     /**
  44      * What is the size restriction on this guy
  45      */
  46     private int sizeRestriction;
  47
  48     public BaseType() {
  49     }
  50
  51     public BaseType(String typeName, byte typeToken) {
  52         this(typeName, typeToken, null, false, -1);
  53     }
  54
  55     public BaseType(String typeName, byte typeToken, Object typeObject) {
  56         this(typeName, typeToken, typeObject, false, -1);
  57     }
  58
  59     public BaseType(String typeName,
  60                     byte typeToken,
  61                     Object typeObject,
  62                     boolean required,
  63                     int sizeRestriction) {
  64         this.required = required;
  65         this.sizeRestriction = sizeRestriction;
  66         this.typeName = typeName;
  67         this.typeObject = typeObject;
  68         this.typeToken = typeToken;
  69     }
  70
  71     public void setTypeName(String typeName) {
  72         this.typeName = typeName;
  73     }
  74
  75     public String getTypeName() {
  76         return typeName;
  77     }
  78
  79     public void setTypeToken(byte typeToken) {
  80         this.typeToken = typeToken;
  81     }
  82
  83     public byte getTypeToken() {
  84         return typeToken;
  85     }
  86
  87     public void setTypeObject(Object typeObject) {
  88         this.typeObject = typeObject;
  89     }
  90
  91     public Object getTypeObject() {
  92         return typeObject;
  93     }
  94
  95     public boolean isRequired() {
  96         return required;
  97     }
  98
  99     public void setRequired(boolean required) {
 100         this.required = required;
 101     }
 102
 103     public Integer getSizeRestriction() {
 104         return sizeRestriction;
 105     }
 106
 107     public void setSizeRestriction(Integer sizeRestriction) {
 108         this.sizeRestriction = sizeRestriction;
 109     }
 110
 111     public int getByteSize(short encoding) throws NoSuchAttributeTypeException {
 112         int size;
 113         switch (typeToken) {
 114             case TypeID.UINT16_TOKEN:
 115                 size = 2;
 116                 break;
 117             case TypeID.INT16_TOKEN:
 118                 size = 2;
 119                 break;
 120             case TypeID.UINT32_TOKEN:
 121                 size = 4;
 122                 break;
 123             case TypeID.INT32_TOKEN:
 124                 size = 4;
 125                 break;
 126             case TypeID.INT64_TOKEN:
 127                 size = 8;
 128                 break;
 129             case TypeID.UINT64_TOKEN:
 130                 size = 8;
 131                 break;
 132             case TypeID.STRING_TOKEN:
 133                 String aString = (String) typeObject;
 134                 /* add size of string plus two bytes for the length */
 135                 size = EncodedString.getBytes(aString, Event.ENCODING_STRINGS[encoding]).length + 2;
 136                 break;
 137             case TypeID.IPADDR_TOKEN:
 138                 size = 4;
 139                 break;
 140             case TypeID.BOOLEAN_TOKEN:
 141                 size = 1;
 142                 break;
 143             case TypeID.STRING_ARRAY_TOKEN:
 144                 int count = 2; // start with the length of the array
 145                 String[] anArray = (String[]) typeObject;
 146                 for (String s : anArray) {
 147                     count += EncodedString.getBytes(s, Event.ENCODING_STRINGS[encoding]).length + 2;
 148                 }
 149                 size = count;
 150                 break;
 151             case TypeID.INT16_ARRAY_TOKEN:
 152                 size = ((short[]) typeObject).length*2+2;
 153                 break;
 154             case TypeID.INT32_ARRAY_TOKEN:
 155                 size = ((int[]) typeObject).length*4+2;
 156                 break;
 157             case TypeID.INT64_ARRAY_TOKEN:
 158                 size = ((long[]) typeObject).length*8+2;
 159                 break;
 160             case TypeID.UINT16_ARRAY_TOKEN:
 161                 size = ((int[]) typeObject).length*4+2;
 162                 break;
 163             case TypeID.UINT32_ARRAY_TOKEN:
 164                 size = ((long[]) typeObject).length*8+2;
 165                 break;
 166             case TypeID.UINT64_ARRAY_TOKEN:
 167                 size = ((long[]) typeObject).length*8+2;
 168                 break;
 169             case TypeID.BOOLEAN_ARRAY_TOKEN:
 170                 size = ((boolean[]) typeObject).length+2;
 171                 break;
 172             case TypeID.BYTE_ARRAY_TOKEN:
 173                 size = ((byte[]) typeObject).length+2;
 174                 break;
 175             default:
 176                 throw new NoSuchAttributeTypeException("Unknown size of BaseType " + typeName);
 177         }
 178         return size;
 179     }
 180
 181     public int bytesStoreSize(short encoding) {
 182         /* add size of data plus size of token denoting data type */
 183         try {
 184             return getByteSize(encoding) + 1;
 185         }
 186         catch (NoSuchAttributeTypeException e) {
 187             return 0;
 188         }
 189     }
 190
 191     public Object parseFromString(String string) throws EventSystemException {
 192         Object toReturn = null;
 193         switch (typeToken) {
 194             case TypeID.UINT16_TOKEN:
 195                 toReturn = StringParser.fromStringUINT16(string);
 196                 break;
 197             case TypeID.INT16_TOKEN:
 198                 toReturn = StringParser.fromStringINT16(string);
 199                 break;
 200             case TypeID.UINT32_TOKEN:
 201                 toReturn = StringParser.fromStringUINT32(string);
 202                 break;
 203             case TypeID.INT32_TOKEN:
 204                 toReturn = StringParser.fromStringINT32(string);
 205                 break;
 206             case TypeID.INT64_TOKEN:
 207                 toReturn = StringParser.fromStringINT64(string);
 208                 break;
 209             case TypeID.UINT64_TOKEN:
 210                 toReturn = StringParser.fromStringUINT64(string);
 211                 break;
 212             case TypeID.STRING_TOKEN:
 213                 toReturn = StringParser.fromStringSTRING(string);
 214                 break;
 215             case TypeID.IPADDR_TOKEN:
 216                 toReturn = StringParser.fromStringIPADDR(string);
 217                 break;
 218             case TypeID.BOOLEAN_TOKEN:
 219                 toReturn = StringParser.fromStringBOOLEAN(string);
 220                 break;
 221             default:
 222                 throw new NoSuchAttributeTypeException("Unknown size of BaseType "
 223                                                        + typeName);
 224         }
 225         return toReturn;
 226     }
 227
 228     public static BaseType baseTypeFromObject(Object value) {
 229         if (value instanceof String) {
 230             return new BaseType(TypeID.STRING_STRING, TypeID.STRING_TOKEN, value);
 231         }
 232         if (value instanceof Short) {
 233             return new BaseType(TypeID.INT16_STRING, TypeID.INT16_TOKEN, value);
 234         }
 235         if (value instanceof Integer) {
 236             return new BaseType(TypeID.INT32_STRING, TypeID.INT32_TOKEN, value);
 237         }
 238         if (value instanceof Long) {
 239             return new BaseType(TypeID.INT64_STRING, TypeID.INT64_TOKEN, value);
 240         }
 241         if (value instanceof InetAddress || value instanceof IPAddress) {
 242             return new BaseType(TypeID.IPADDR_STRING, TypeID.IPADDR_TOKEN, value);
 243         }
 244         if (value instanceof BigInteger) {
 245             return new BaseType(TypeID.UINT64_STRING, TypeID.UINT64_TOKEN, value);
 246         }
 247         else {
 248             Log.warning("unaccounted for object class: "+value.getClass().getName());
 249             return null;
 250         }
 251     }
 252
 253     public BaseType cloneBaseType() {
 254         BaseType newBaseType = new BaseType(getTypeName(), getTypeToken(),
 255                                             getTypeObject());
 256         return newBaseType;
 257     }
 258
 259     public String toString() {
 260         return typeObject.toString();
 261     }
 262 }