src/main/java/org/lwes/serializer/Serializer.java

   1 package org.lwes.serializer;
   2
   3 import java.math.BigInteger;
   4 import java.net.InetAddress;
   5
   6 import org.lwes.Event;
   7 import org.lwes.util.EncodedString;
   8 import org.lwes.util.IPAddress;
   9 import org.lwes.util.NumberCodec;
  10
  11 /**
  12  * This contains low level type serialization used by the
  13  * rest of the system.
  14  * @author Anthony Molinaro
  15  */
  16 public class Serializer
  17 {
  18
  19         public static int serializeBYTE(byte aByte, byte[] bytes, int offset)
  20         {
  21                 bytes[offset] = aByte;
  22                 return (1);
  23         }
  24
  25         public static int serializeBOOLEAN(boolean aBoolean, byte[] bytes, int offset)
  26         {
  27                 if ( aBoolean )
  28                 {
  29                         bytes[offset] = (byte)0x01;
  30                 }
  31                 else
  32                 {
  33                         bytes[offset] = (byte)0x00;
  34                 }
  35                 return (1);
  36         }
  37
  38         public static int serializeUINT16(int anUnsignedShortInt, byte[] bytes,
  39                         int offset)
  40         {
  41                 bytes[offset]  = (byte)( (anUnsignedShortInt & (255 << 8) ) >> 8);
  42                 bytes[offset+1]= (byte)( (anUnsignedShortInt & (255 << 0) ) >> 0);
  43                 return (2);
  44         }
  45
  46         public static int serializeINT16(short aShortInt, byte[] bytes, int offset)
  47         {
  48                 bytes[offset]  = (byte)( (aShortInt & (255 << 8) ) >> 8);
  49                 bytes[offset+1]= (byte)( (aShortInt & (255 << 0) ) >> 0);
  50                 return (2);
  51         }
  52
  53         public static int serializeUINT32(long anUnsignedInt, byte[] bytes,
  54                         int offset)
  55         {
  56                 bytes[offset]   = (byte) ( (anUnsignedInt & 0xff000000 ) >> 24);
  57                 bytes[offset+1] = (byte) ( (anUnsignedInt & 0x00ff0000 ) >> 16);
  58                 bytes[offset+2] = (byte) ( (anUnsignedInt & 0x0000ff00 ) >> 8);
  59                 bytes[offset+3] = (byte) ( (anUnsignedInt & 0x000000ff ) >> 0);
  60                 return (4);
  61         }
  62
  63         public static int serializeINT32(int anInt, byte[] bytes,
  64                         int offset)
  65         {
  66                 bytes[offset]   = (byte) ( (anInt & (255 << 24)) >> 24);
  67                 bytes[offset+1] = (byte) ( (anInt & (255 << 16)) >> 16);
  68                 bytes[offset+2] = (byte) ( (anInt & (255 <<  8)) >>  8);
  69                 bytes[offset+3] = (byte) ( (anInt & (255 <<  0)) >>  0);
  70                 return (4);
  71         }
  72
  73         public static int serializeINT64(long anInt, byte[] bytes, int offset)
  74         {
  75                 NumberCodec.encodeLongUnchecked(anInt,bytes,offset);
  76                 return (8);
  77         }
  78
  79         public static int serializeUINT64(long anInt, byte[] bytes, int offset)
  80         {
  81                 NumberCodec.encodeLongUnchecked(anInt,bytes,offset);
  82                 return (8);
  83         }
  84
  85         public static int serializeUINT64(BigInteger anInt, byte[] bytes, int offset)
  86         {
  87                 // TODO: write a BigInteger serialization method
  88                 NumberCodec.encodeLongUnchecked(anInt.longValue(),bytes,offset);
  89                 return (8);
  90         }
  91
  92         /**
  93          * @deprecated
  94          */
  95          public static int serializeSTRING(String aString, byte[] bytes, int offset)
  96         {
  97                 return serializeSTRING(aString, bytes, offset, Event.DEFAULT_ENCODING);
  98         }
  99
 100          public static int serializeSTRING(String aString, byte[] bytes, int offset,
 101                          short encoding)
 102          {
 103                  byte[] stringBytes =
 104                          EncodedString.getBytes(aString, Event.ENCODING_STRINGS[encoding]);
 105                  int length = stringBytes.length;
 106                  if ( length < 65535 && length >= 0 )
 107                  {
 108                          offset += serializeUINT16(length,bytes,offset);
 109                          System.arraycopy(stringBytes,0,bytes,offset,length);
 110                          return (length+2);
 111                  }
 112                  return 0;
 113
 114          }
 115
 116          /*
 117           * @deprecated
 118           */
 119           public static int serializeEVENTWORD(String aString, byte[] bytes, int offset)
 120           {
 121                   return serializeEVENTWORD(aString, bytes, offset, Event.DEFAULT_ENCODING);
 122           }
 123
 124           private static int serializeEVENTWORD(String aString, byte[] bytes,
 125                           int offset, short encoding)
 126           {
 127                   byte[] stringBytes =
 128                           EncodedString.getBytes(aString, Event.ENCODING_STRINGS[encoding]);
 129                   int length = stringBytes.length;
 130                   if ( length < 255 && length > 0 )
 131                   {
 132                           offset += serializeBYTE((byte)length,bytes,offset);
 133                           System.arraycopy(stringBytes,0,bytes,offset,length);
 134                           return (length+1);
 135                   }
 136                   return 0;
 137
 138           }
 139
 140           public static int serializeATTRIBUTEWORD(String aString, byte[] bytes,
 141                           int offset)
 142           {
 143                   return serializeEVENTWORD(aString, bytes, offset, Event.DEFAULT_ENCODING);
 144           }
 145
 146           public static int serializeIPADDR(IPAddress anIPAddress, byte[] bytes,
 147                           int offset)
 148           {
 149                   byte[] inetaddr = anIPAddress.getInetAddressAsBytes();
 150                   bytes[offset+3] = inetaddr[0];
 151                   bytes[offset+2] = inetaddr[1];
 152                   bytes[offset+1] = inetaddr[2];
 153                   bytes[offset  ] = inetaddr[3];
 154                   return (4);
 155           }
 156
 157           public static int serializeIPADDR(InetAddress anIPAddress, byte[] bytes,
 158                           int offset)
 159           {
 160                   byte[] inetaddr = anIPAddress.getAddress();
 161                   bytes[offset+3] = inetaddr[0];
 162                   bytes[offset+2] = inetaddr[1];
 163                   bytes[offset+1] = inetaddr[2];
 164                   bytes[offset  ] = inetaddr[3];
 165                   return (4);
 166           }
 167 }