src/main/java/org/lwes/Event.java

   1 package org.lwes;
   2
   3 import org.lwes.db.EventTemplateDB;
   4 import org.lwes.serializer.Deserializer;
   5 import org.lwes.serializer.DeserializerState;
   6 import org.lwes.serializer.Serializer;
   7 import org.lwes.util.CharacterEncoding;
   8 import org.lwes.util.IPAddress;
   9 import org.lwes.util.Log;
  10 import org.lwes.util.NumberCodec;
  11
  12 import java.math.BigInteger;
  13 import java.net.InetAddress;
  14 import java.util.Arrays;
  15 import java.util.Enumeration;
  16 import java.util.concurrent.ConcurrentHashMap;
  17
  18 public class Event {
  19
  20     public static final int MAX_MESSAGE_SIZE = 65507;
  21
  22     /**
  23      * Reserved metadata keywords
  24      */
  25     public static final String ENCODING = "enc";
  26     public static final String RECEIPT_TIME = "ReceiptTime";
  27     public static final String SENDER_IP = "SenderIP";
  28     public static final String SENDER_PORT = "SenderPort";
  29
  30     /**
  31      * Encoding variables
  32      */
  33     public static final short ISO_8859_1 = 0;
  34     public static final short UTF_8 = 1;
  35     public static final short DEFAULT_ENCODING = UTF_8;
  36     public static final CharacterEncoding[] ENCODING_STRINGS = {
  37             CharacterEncoding.ISO_8859_1, CharacterEncoding.UTF_8};
  38
  39     /**
  40      * Event data
  41      */
  42     private ConcurrentHashMap<String, BaseType> attributes = new ConcurrentHashMap<String, BaseType>();
  43     private String name = null;
  44     private EventTemplateDB eventTemplateDB = null;
  45     private short encoding = DEFAULT_ENCODING;
  46
  47     /**
  48      * If this is set to true, types and attributes are validated against the EventTemplateDB
  49      */
  50     private boolean validating = true;
  51
  52     /**
  53      * Internal object for deserialization state
  54      */
  55     private DeserializerState state = null;
  56
  57     /**
  58      * the size of the event in bytes
  59      */
  60     private int bytesStoreSize = 0;
  61
  62     /**
  63      * Create an event called <tt>eventName</tt>
  64      *
  65      * @param eventName       the name of the event
  66      * @param eventTemplateDB the EventTemplateDB to use for validation
  67      * @throws NoSuchEventException         if the Event does not exist in the EventTemplateDB
  68      * @throws NoSuchAttributeException     if an attribute does not exist in the EventTemplateDB
  69      * @throws NoSuchAttributeTypeException if an attribute type does not exist in the EventTemplateDB
  70      */
  71     public Event(String eventName, EventTemplateDB eventTemplateDB)
  72             throws EventSystemException {
  73         this(eventName, true, eventTemplateDB);
  74     }
  75
  76     /**
  77      * Create an event called <tt>eventName</tt>
  78      *
  79      * @param eventName       the name of the event
  80      * @param validate        true if the EventTemplateDB should be checked for types before all mutations
  81      * @param eventTemplateDB the EventTemplateDB to use for validation
  82      * @throws NoSuchEventException         if the Event does not exist in the EventTemplateDB
  83      * @throws NoSuchAttributeException     if an attribute does not exist in the EventTemplateDB
  84      * @throws NoSuchAttributeTypeException if an attribute type does not exist in the EventTemplateDB
  85      */
  86     public Event(String eventName, boolean validate, EventTemplateDB eventTemplateDB)
  87             throws EventSystemException {
  88         this(eventName, validate, eventTemplateDB, DEFAULT_ENCODING);
  89     }
  90
  91     /**
  92      * Create an event called <tt>eventName</tt>
  93      *
  94      * @param eventName the name of the event
  95      * @param validate  true if the EventTemplateDB should be checked for types before all mutations
  96      * @param encoding  the character encoding used by the event
  97      * @throws NoSuchEventException         if the Event does not exist in the EventTemplateDB
  98      * @throws NoSuchAttributeException     if an attribute does not exist in the EventTemplateDB
  99      * @throws NoSuchAttributeTypeException if an attribute type does not exist in the EventTemplateDB
 100      */
 101     public Event(String eventName, boolean validate, EventTemplateDB eventTemplateDB, short encoding)
 102             throws EventSystemException {
 103         setEventTemplateDB(eventTemplateDB);
 104         validating = validate;
 105         setEventName(eventName);
 106         setEncoding(encoding);
 107     }
 108
 109     /**
 110      * Creates an event by deserializing a raw byte array.
 111      *
 112      * @param bytes           the raw bytes to convert
 113      * @param eventTemplateDB the EventTemplateDB to use to validate the event
 114      * @throws NoSuchEventException
 115      * @throws NoSuchAttributeException
 116      * @throws NoSuchAttributeTypeException
 117      */
 118     public Event(byte[] bytes, EventTemplateDB eventTemplateDB)
 119             throws EventSystemException {
 120         this(bytes, true, eventTemplateDB);
 121     }
 122
 123
 124     /**
 125      * Creates an event by deserializing a raw byte array.
 126      *
 127      * @param bytes           the raw bytes to convert
 128      * @param validate        whether or not to validate the event
 129      * @param eventTemplateDB the EventTemplateDB to use to validate the event
 130      * @throws NoSuchEventException
 131      * @throws NoSuchAttributeException
 132      * @throws NoSuchAttributeTypeException
 133      */
 134     public Event(byte[] bytes, boolean validate, EventTemplateDB eventTemplateDB)
 135             throws EventSystemException {
 136         setEventTemplateDB(eventTemplateDB);
 137         validating = validate;
 138         deserialize(bytes);
 139     }
 140
 141     /**
 142      * Returns an enumeration of all the event attribute names
 143      *
 144      * @return an enumeration of attribute strings
 145      */
 146     public Enumeration<String> getEventAttributeNames() {
 147         if (attributes == null) {
 148             return null;
 149         }
 150
 151         return attributes.keys();
 152     }
 153
 154     /**
 155      * Returns the number of attributes in the event
 156      *
 157      * @return number of attributes in the event
 158      */
 159     public int size() {
 160         if (attributes == null) {
 161             return 0;
 162         }
 163         return attributes.size();
 164     }
 165
 166     /**
 167      * Returns true if the event validates against the EventTemplateDB before making changes
 168      *
 169      * @return the validating state
 170      */
 171     public boolean isValidating() {
 172         return this.validating;
 173     }
 174
 175     /**
 176      * Set to true if the event should validate against the EventTemplateDB before making changes
 177      *
 178      * @param validate the validating value
 179      */
 180     public void setValidating(boolean validate) {
 181         this.validating = validate;
 182     }
 183
 184     /**
 185      * Returns the EventTemplateDB for this event, used for validation of types and attributes.
 186      *
 187      * @return the EventTemplateDB
 188      */
 189     public EventTemplateDB getEventTemplateDB() {
 190         return this.eventTemplateDB;
 191     }
 192
 193     /**
 194      * Sets the EventTemplateDB for this event, used for validation of types and attributes.
 195      *
 196      * @param eventTemplateDB the EventTemplateDB to be used for validation
 197      */
 198     public void setEventTemplateDB(EventTemplateDB eventTemplateDB) {
 199         this.eventTemplateDB = eventTemplateDB;
 200     }
 201
 202     /**
 203      * Returns the name of the event
 204      *
 205      * @return the name of the event
 206      */
 207     public synchronized String getEventName() {
 208         return this.name;
 209     }
 210
 211     /**
 212      * Sets the name of the Event
 213      *
 214      * @param name the name of the event
 215      * @throws NoSuchEventException if the event is validating and does not exist in the EventTemplateDB
 216      */
 217     public synchronized void setEventName(String name) throws NoSuchEventException {
 218         if (isValidating() && getEventTemplateDB() != null) {
 219             if (!getEventTemplateDB().checkForEvent(name)) {
 220                 throw new NoSuchEventException("Event " + name + " does not exist in event definition");
 221             }
 222         }
 223
 224         /* determine if we already have the name and are just resetting it */
 225         if (this.name != null) {
 226             bytesStoreSize -= (this.name.length() + 1 + 2);
 227         }
 228
 229         bytesStoreSize += (name.length() + 1 + 2);
 230
 231         this.name = name;
 232     }
 233
 234     /**
 235      * Get the character encoding for this event
 236      *
 237      * @return the encoding
 238      */
 239     public short getEncoding() {
 240         return this.encoding;
 241     }
 242
 243     /**
 244      * Set the character encoding for event strings
 245      *
 246      * @param encoding the character encoding
 247      * @throws NoSuchAttributeTypeException if the type for the encoding attribute does not exist
 248      * @throws NoSuchAttributeException     if the encoding attribute does not exist
 249      */
 250     public void setEncoding(short encoding) throws EventSystemException {
 251         this.encoding = encoding;
 252         setInt16(ENCODING, this.encoding);
 253     }
 254
 255     /**
 256      * Generic accessor, checks if an attribute exists and returns its value.  The user must do their
 257      * own type checking.
 258      *
 259      * @param attributeName name of the attribute to lookup
 260      * @return the object poitned to by attributeName
 261      * @throws NoSuchAttributeException if the attribute does not exist in this event
 262      */
 263     public Object get(String attributeName) throws NoSuchAttributeException {
 264         if (attributes == null) {
 265             return null;
 266         }
 267
 268         if (attributes.containsKey(attributeName)) {
 269             return attributes.get(attributeName).getTypeObject();
 270         }
 271
 272         if (isValidating() && getEventTemplateDB() != null) {
 273             if (getEventTemplateDB().checkForAttribute(name, attributeName)) {
 274                 return null;
 275             }
 276             else {
 277                 throw new NoSuchAttributeException("Attribute " + attributeName + " does not exist for event " + name);
 278             }
 279         }
 280
 281         return null;
 282     }
 283
 284
 285     public String[] getStringArray(String attributeName)
 286             throws NoSuchAttributeException {
 287         Object o = get(attributeName);
 288         if (o != null && o instanceof String[]) {
 289             return (String[]) o;
 290         }
 291         else {
 292             return null;
 293         }
 294     }
 295
 296     /**
 297      * Method to check if an attribute is set in the event. This method does not throw
 298      * NoSuchAttributeException because it shouldn't really care. If it's not there, it's
 299      * not there.
 300      *
 301      * @param attributeName The attribute name to check for existance.
 302      * @return true if there is a value, false if not.
 303      */
 304     public boolean isSet(String attributeName) {
 305         try {
 306             return (get(attributeName) != null);
 307         }
 308         catch (NoSuchAttributeException e) {
 309             return false;
 310         }
 311     }
 312
 313     /**
 314      * Accessor that returns a boolean value for attribute <tt>attributeName</tt>
 315      *
 316      * @param attributeName the name of the attribute to fetch
 317      * @return the boolean value
 318      * @throws NoSuchAttributeException if the attribute does not exist in this event
 319      */
 320     public Boolean getBoolean(String attributeName) throws NoSuchAttributeException {
 321         return (Boolean) get(attributeName);
 322         }
 323
 324     /**
 325      * Accessor that returns an <tt>unsigned short</tt>, in the guise of an <tt>int</tt>, for attribute <tt>attributeName</tt>
 326      *
 327      * @param attributeName the name of the attribute to fetch
 328      * @return the unsigned short as an int
 329      * @throws NoSuchAttributeException if the attribute does not exist in this event
 330      */
 331     public Integer getUInt16(String attributeName) throws NoSuchAttributeException {
 332         return (Integer) get(attributeName);
 333         }
 334
 335     /**
 336      * Accessor that returns an <tt>short</tt>, for attribute <tt>attributeName</tt>
 337      *
 338      * @param attributeName the name of the attribute to fetch
 339      * @return the short value
 340      * @throws NoSuchAttributeException if the attribute does not exist in this event
 341      */
 342     public Short getInt16(String attributeName) throws NoSuchAttributeException {
 343         return (Short) get(attributeName);
 344         }
 345
 346     /**
 347      * Accessor that returns an <tt>unsigned int</tt>, in the guise of an <tt>long</tt>, for attribute <tt>attributeName</tt>
 348      *
 349      * @param attributeName the name of the attribute to fetch
 350      * @return the unsigned int as a long
 351      * @throws NoSuchAttributeException if the attribute does not exist in this event
 352      */
 353     public Long getUInt32(String attributeName) throws NoSuchAttributeException {
 354         return (Long) get(attributeName);
 355         }
 356
 357     /**
 358      * Accessor that returns an <tt>int</tt>, for attribute <tt>attributeName</tt>
 359      *
 360      * @param attributeName the name of the attribute to fetch
 361      * @return the int value
 362      * @throws NoSuchAttributeException if the attribute does not exist in this event
 363      */
 364     public Integer getInt32(String attributeName) throws NoSuchAttributeException {
 365         return (Integer) get(attributeName);
 366         }
 367
 368     /**
 369      * Accessor that returns an <tt>unsigned long</tt>, in the guise of an <tt>BigInteger</tt>, for attribute <tt>attributeName</tt>
 370      *
 371      * @param attributeName the name of the attribute to fetch
 372      * @return the unsigned long as a BigInteger
 373      * @throws NoSuchAttributeException if the attribute does not exist in this event
 374      */
 375     public BigInteger getUInt64(String attributeName) throws NoSuchAttributeException {
 376         return (BigInteger) get(attributeName);
 377         }
 378
 379
 380     /**
 381      * Accessor that returns an <tt>long</tt>, for attribute <tt>attributeName</tt>
 382      *
 383      * @param attributeName the name of the attribute to fetch
 384      * @return the long value
 385      * @throws NoSuchAttributeException if the attribute does not exist in this event
 386      */
 387     public Long getInt64(String attributeName) throws NoSuchAttributeException {
 388         return (Long) get(attributeName);
 389         }
 390
 391     /**
 392      * Accessor that returns an <tt>String</tt>, for attribute <tt>attributeName</tt>
 393      *
 394      * @param attributeName the name of the attribute to fetch
 395      * @return the String value
 396      * @throws NoSuchAttributeException if the attribute does not exist in this event
 397      */
 398     public String getString(String attributeName) throws NoSuchAttributeException {
 399         return (String) get(attributeName);
 400         }
 401
 402     /**
 403      * Accessor that returns an <tt>InetAddress</tt>, for attribute <tt>attributeName</tt>
 404      *
 405      * @param attributeName the name of the attribute to fetch
 406      * @return the InetAddress value
 407      * @throws NoSuchAttributeException if the attribute does not exist in this event
 408      */
 409     public InetAddress getInetAddress(String attributeName) throws NoSuchAttributeException {
 410         IPAddress a = (IPAddress) get(attributeName);
 411         if (a != null) {
 412             return a.toInetAddress();
 413         }
 414         else {
 415             return null;
 416         }
 417     }
 418
 419     /**
 420      * Accessor that returns an IP address in bytes, for attribute <tt>attributeName</tt>
 421      *
 422      * @param attributeName the name of the attribute to fetch
 423      * @return the IP address in bytes
 424      * @throws NoSuchAttributeException if the attribute does not exist in this event
 425      */
 426     public byte[] getIPAddress(String attributeName) throws NoSuchAttributeException {
 427         return (byte[]) get(attributeName);
 428         }
 429
 430
 431     /**
 432      * Set the object's attribute <tt>attributeName</tt> with the Object given
 433      *
 434      * @param attributeName  the name of the attribute to set
 435      * @param attributeValue the object to set the attribute with
 436      * @throws NoSuchAttributeException     if the attribute does not exist in this event
 437      * @throws NoSuchAttributeTypeException if there is an attribute with an undefined type
 438      */
 439     public void set(String attributeName, Object attributeValue)
 440             throws EventSystemException {
 441         if (isValidating() && getEventTemplateDB() != null) {
 442             if (getEventTemplateDB().checkForAttribute(getEventName(), attributeName)) {
 443                 BaseType bt = getEventTemplateDB().getBaseTypeForObjectAttribute(getEventName(),
 444                                                                                  attributeName, attributeValue);
 445                 set(attributeName, bt);
 446             }
 447         }
 448         else {
 449             throw new NoSuchAttributeException("Must be able to check the EventTemplateDB to use set(String,Object)");
 450         }
 451     }
 452
 453     /**
 454      * Private method to set a BaseType
 455      *
 456      * @param attribute the name of the attribute to set
 457      * @param anObject  the BaseType to set in the event
 458      * @throws NoSuchAttributeException     if the attribute does not exist in this event
 459      * @throws NoSuchAttributeTypeException if there is an attribute with an undefined type
 460      */
 461     private void set(String attribute, BaseType anObject)
 462             throws EventSystemException {
 463
 464         if (isValidating() && getEventTemplateDB() != null) {
 465             if (getEventTemplateDB().checkForAttribute(name, attribute)) {
 466                 if (!getEventTemplateDB().checkTypeForAttribute(name, attribute, anObject)) {
 467                     throw new NoSuchAttributeTypeException("Wrong type '" + anObject.getTypeName() +
 468                                                            "' for " + name + "." + attribute);
 469                 }
 470             }
 471             else {
 472                 throw new NoSuchAttributeException("Attribute " + attribute + " does not exist for event " + name);
 473             }
 474             getEventTemplateDB().checkForSize(name, attribute, anObject);
 475         }
 476
 477         if (anObject.getTypeObject() != null) {
 478             BaseType oldObject = null;
 479             int newSize = bytesStoreSize + ((attribute.length() + 1) + anObject.bytesStoreSize(encoding));
 480             if (newSize > MAX_MESSAGE_SIZE) {
 481                 throw new EventSystemException("Event size limit is " + MAX_MESSAGE_SIZE + " bytes.");
 482             }
 483             if ((oldObject = attributes.remove(attribute)) != null) {
 484                 bytesStoreSize -= (attribute.length() + 1) + oldObject.bytesStoreSize(encoding);
 485             }
 486
 487             bytesStoreSize += (attribute.length() + 1) + anObject.bytesStoreSize(encoding);
 488             attributes.put(attribute, anObject);
 489         }
 490     }
 491
 492     public void setStringArray(String attributeName, String[] value)
 493             throws EventSystemException {
 494         set(attributeName, new BaseType(TypeID.STRING_ARRAY_STRING,
 495                                         TypeID.STRING_ARRAY_TOKEN,
 496                                         value));
 497     }
 498
 499     /**
 500      * Sets the given attribute with a <tt>boolean</tt> value given by <tt>aBool</tt>.
 501      *
 502      * @param attributeName the attribute to set
 503      * @param aBool         the boolean value to set
 504      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 505      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 506      */
 507     public void setBoolean(String attributeName, boolean aBool)
 508             throws EventSystemException {
 509         setBoolean(attributeName, Boolean.valueOf(aBool));
 510     }
 511
 512     /**
 513      * Sets the given attribute with a <tt>Boolean</tt> value given by <tt>aBool</tt>.
 514      *
 515      * @param attributeName the attribute to set
 516      * @param aBool         the boolean value to set
 517      * @throws NoSuchAttributeException
 518      * @throws NoSuchAttributeTypeException
 519      */
 520     public void setBoolean(String attributeName, Boolean aBool)
 521             throws EventSystemException {
 522         set(attributeName, new BaseType(TypeID.BOOLEAN_STRING, TypeID.BOOLEAN_TOKEN, aBool));
 523     }
 524
 525     /**
 526      * Set the given attribute with the <tt>unsigned short</tt> value given by <tt>aNumber</tt>.
 527      * Because Java does not support unsigned types, we must use a signed int to cover the range of unsigned short.
 528      *
 529      * @param attributeName the attribute to set
 530      * @param aNumber       the unsigned short value as an integer
 531      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 532      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 533      */
 534     public void setUInt16(String attributeName, int aNumber)
 535             throws EventSystemException {
 536         setUInt16(attributeName, Integer.valueOf(aNumber));
 537     }
 538
 539     /**
 540      * Set the given attribute with the <tt>Integer</tt> value given by <tt>aNumber</tt>.
 541      * This should be an <tt>unsigned short</tt>, but is an Integer because Java does not support unsigned types,
 542      * and a signed integer is needed to cover the range of an unsigned short.
 543      *
 544      * @param attributeName the attribute to set
 545      * @param aNumber       the value
 546      */
 547     public void setUInt16(String attributeName, Integer aNumber)
 548             throws EventSystemException {
 549         set(attributeName, new BaseType(TypeID.UINT16_STRING, TypeID.UINT16_TOKEN, aNumber));
 550     }
 551
 552     /**
 553      * Set the given attribute with the <tt>short</tt> value given by <tt>aNumber</tt>.
 554      *
 555      * @param attributeName the attribute to set
 556      * @param aNumber       the short value to set
 557      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 558      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 559      */
 560     public void setInt16(String attributeName, short aNumber)
 561             throws EventSystemException {
 562         setInt16(attributeName, Short.valueOf(aNumber));
 563     }
 564
 565     /**
 566      * Set the given attribute with the <tt>Short</tt> value given by <tt>aNumber</tt>.
 567      *
 568      * @param attributeName the attribute to set
 569      * @param aNumber       the short value to set
 570      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 571      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 572      */
 573     public void setInt16(String attributeName, Short aNumber)
 574             throws EventSystemException {
 575         set(attributeName, new BaseType(TypeID.INT16_STRING, TypeID.INT16_TOKEN, aNumber));
 576     }
 577
 578     /**
 579      * Set the given attribute with the <tt>unsigned int</tt> value given by <tt>aNumber</tt>.
 580      * Because Java does not support unsigned types, we must use a signed long to cover the range of an unsigned int.
 581      *
 582      * @param attributeName the attribute to set
 583      * @param aNumber       the unsigned int value as a long
 584      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 585      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 586      */
 587     public void setUInt32(String attributeName, long aNumber)
 588             throws EventSystemException {
 589         setUInt32(attributeName, Long.valueOf(aNumber));
 590     }
 591
 592     /**
 593      * Set the given attribute with the <tt>Long</tt> value given by <tt>aNumber</tt>.
 594      * This should be an <tt>unsigned int</tt>, but is an Long because Java does not support unsigned types,
 595      * and a signed long is needed to cover the range of an unsigned int.
 596      *
 597      * @param attributeName the attribute to set
 598      * @param aNumber       the value
 599      */
 600     public void setUInt32(String attributeName, Long aNumber)
 601             throws EventSystemException {
 602         set(attributeName, new BaseType(TypeID.UINT32_STRING, TypeID.UINT32_TOKEN, aNumber));
 603     }
 604
 605     /**
 606      * Set the given attribute with the <tt>int</tt> value given by <tt>aNumber</tt>.
 607      *
 608      * @param attributeName the attribute to set
 609      * @param aNumber       the integer value to set
 610      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 611      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 612      */
 613     public void setInt32(String attributeName, int aNumber)
 614             throws EventSystemException {
 615         setInt32(attributeName, Integer.valueOf(aNumber));
 616     }
 617
 618     /**
 619      * Set the given attribute with the <tt>Integer</tt> value given by <tt>aNumber</tt>.
 620      *
 621      * @param attributeName the attribute to set
 622      * @param aNumber       the Integer value to set
 623      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 624      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 625      */
 626     public void setInt32(String attributeName, Integer aNumber)
 627             throws EventSystemException {
 628         set(attributeName, new BaseType(TypeID.INT32_STRING, TypeID.INT32_TOKEN, aNumber));
 629     }
 630
 631     /**
 632      * Set the given attribute with the <tt>unsigned long</tt> value given by <tt>aNumber</tt>.
 633      *
 634      * @param attributeName the attribute to set
 635      * @param aNumber       the value
 636      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 637      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 638      */
 639     public void setUInt64(String attributeName, long aNumber)
 640             throws EventSystemException {
 641         set(attributeName, new BaseType(TypeID.UINT64_STRING, TypeID.UINT64_TOKEN, BigInteger.valueOf(aNumber)));
 642     }
 643
 644     /**
 645      * Set the given attribute with the <tt>Long</tt> value given by <tt>aNumber</tt>.
 646      *
 647      * @param attributeName the attribute to set
 648      * @param aNumber       the value
 649      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 650      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 651      */
 652     public void setUInt64(String attributeName, Long aNumber)
 653             throws EventSystemException {
 654         set(attributeName,
 655             new BaseType(TypeID.UINT64_STRING, TypeID.UINT64_TOKEN, BigInteger.valueOf(aNumber.longValue())));
 656     }
 657
 658     /**
 659      * Set the given attribute with the <tt>BigInteger</tt> value given by <tt>aNumber</tt>.
 660      * This should be an <tt>unsigned long</tt>, but is an BigInteger because Java does not support unsigned types,
 661      * and a BigInteger is needed to cover the range of an unsigned long.
 662      *
 663      * @param attributeName the attribute to set
 664      * @param aNumber       the value
 665      */
 666     public void setUInt64(String attributeName, BigInteger aNumber)
 667             throws EventSystemException {
 668         set(attributeName, new BaseType(TypeID.UINT64_STRING, TypeID.UINT64_TOKEN, aNumber));
 669     }
 670
 671     /**
 672      * Set the given attribute with the <tt>long</tt> value given by <tt>aNumber</tt>.
 673      *
 674      * @param attributeName the attribute to set
 675      * @param aNumber       the long value to set
 676      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 677      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 678      */
 679     public void setInt64(String attributeName, long aNumber)
 680             throws EventSystemException {
 681         setInt64(attributeName, Long.valueOf(aNumber));
 682     }
 683
 684     /**
 685      * Set the given attribute with the <tt>Long</tt> value given by <tt>aNumber</tt>.
 686      *
 687      * @param attributeName the attribute to set
 688      * @param aNumber       the Long value to set
 689      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 690      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 691      */
 692     public void setInt64(String attributeName, Long aNumber)
 693             throws EventSystemException {
 694         set(attributeName, new BaseType(TypeID.INT64_STRING, TypeID.INT64_TOKEN, aNumber));
 695     }
 696
 697     /**
 698      * Set the given attribute with a <tt>String</tt>
 699      *
 700      * @param attributeName the attribute to set
 701      * @param aString       the String value to set
 702      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 703      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 704      */
 705     public void setString(String attributeName, String aString)
 706             throws EventSystemException {
 707         set(attributeName, new BaseType(TypeID.STRING_STRING, TypeID.STRING_TOKEN, aString));
 708     }
 709
 710     /**
 711      * Set the given attribute with the <tt>ip address</tt> value given by <tt>address</tt>
 712      *
 713      * @param attributeName the attribute to set
 714      * @param address       the ip address in bytes
 715      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 716      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 717      */
 718     public void setIPAddress(String attributeName, byte[] address)
 719             throws EventSystemException {
 720         setIPAddress(attributeName, new IPAddress(address));
 721     }
 722
 723     /**
 724      * Set the given attribute with the <tt>ip address</tt> value given by <tt>address</tt>
 725      *
 726      * @param attributeName the attribute to set
 727      * @param address       the ip address in bytes
 728      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 729      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 730      */
 731     public void setIPAddress(String attributeName, InetAddress address)
 732             throws EventSystemException {
 733         setIPAddress(attributeName, new IPAddress(address));
 734     }
 735
 736     /**
 737      * Set the given attribute with the <tt>ip address</tt> value given by <tt>address</tt>
 738      *
 739      * @param attributeName the attribute to set
 740      * @param address       the ip address in bytes
 741      * @throws NoSuchAttributeException     if the attribute does not exist in the event
 742      * @throws NoSuchAttributeTypeException if the attribute type does not match the EventTemplateDB
 743      */
 744     public void setIPAddress(String attributeName, IPAddress address)
 745             throws EventSystemException {
 746         set(attributeName, new BaseType(TypeID.IPADDR_STRING, TypeID.IPADDR_TOKEN, address));
 747     }
 748
 749     /**
 750      * Serializes the Event into a byte array
 751      *
 752      * @return the serialized byte array
 753      */
 754     public byte[] serialize() {
 755         /*
 756            * Serialization uses the following protocol
 757            * EVENTWORD,<number of elements>,ATTRIBUTEWORD,TYPETOKEN,
 758            * (UINT16|INT16|UINT32|INT32|UINT64|INT64|BOOLEAN|STRING)
 759            * ...ATTRIBUTEWORD,TYPETOKEN(UINT16|INT16|UINT32|INT32|
 760            * UINT64|INT64|BOOLEAN|STRING)
 761            *
 762            * The first attribute will always be the encoding if present.
 763            */
 764         byte[] bytes = new byte[this.bytesStoreSize];
 765         int offset = 0;
 766         int attributeCount = 0;
 767         short encoding = DEFAULT_ENCODING;
 768
 769         if (attributes != null) {
 770             attributeCount = attributes.size();
 771         }
 772
 773         offset += Serializer.serializeEVENTWORD(name, bytes, offset);
 774         offset += Serializer.serializeUINT16((short) (attributeCount), bytes, offset);
 775
 776         /*
 777            * Set the encoding attributes in the event
 778            */
 779         if (attributes != null) {
 780             BaseType encodingBase = attributes.get(ENCODING);
 781             if (encodingBase != null) {
 782                 Object encodingObj = encodingBase.getTypeObject();
 783                 byte encodingType = encodingBase.getTypeToken();
 784                 if (encodingObj != null) {
 785                     if (encodingType == TypeID.INT16_TOKEN) {
 786                         encoding = (Short) encodingObj;
 787                         Log.trace("Character encoding: " + encoding);
 788                         offset += Serializer.serializeATTRIBUTEWORD(ENCODING, bytes, offset);
 789                         offset += Serializer.serializeBYTE(encodingType, bytes, offset);
 790                         offset += Serializer.serializeUINT16(encoding, bytes, offset);
 791                     }
 792                 }
 793             }
 794             else {
 795                 Log.warning("Character encoding null in event " + name);
 796             }
 797
 798             Enumeration<String> e = attributes.keys();
 799             while (e.hasMoreElements()) {
 800                 String key = e.nextElement();
 801                 if (key.equals(ENCODING)) {
 802                     continue;
 803                 }
 804
 805                 BaseType value = attributes.get(key);
 806                 Object data = value.getTypeObject();
 807                 byte typeToken = value.getTypeToken();
 808
 809                 /* don't try to serialize nulls */
 810                 if (data == null) {
 811                     Log.warning("Attribute " + key + " was null in event " + name);
 812                     continue;
 813                 }
 814
 815                 offset += Serializer.serializeATTRIBUTEWORD(key, bytes, offset);
 816                 offset += Serializer.serializeBYTE(typeToken, bytes, offset);
 817
 818                 switch (typeToken) {
 819                     case TypeID.BOOLEAN_TOKEN:
 820                         offset += Serializer.serializeBOOLEAN((Boolean) data, bytes, offset);
 821                         break;
 822                     case TypeID.UINT16_TOKEN:
 823                         offset += Serializer.serializeUINT16((Integer) data, bytes, offset);
 824                         break;
 825                     case TypeID.INT16_TOKEN:
 826                         offset += Serializer.serializeINT16((Short) data, bytes, offset);
 827                         break;
 828                     case TypeID.UINT32_TOKEN:
 829                         offset += Serializer.serializeUINT32((Long) data, bytes, offset);
 830                         break;
 831                     case TypeID.INT32_TOKEN:
 832                         offset += Serializer.serializeINT32((Integer) data, bytes, offset);
 833                         break;
 834                     case TypeID.UINT64_TOKEN:
 835                         offset += Serializer.serializeUINT64((BigInteger) data, bytes, offset);
 836                         break;
 837                     case TypeID.INT64_TOKEN:
 838                         offset += Serializer.serializeINT64((Long) data, bytes, offset);
 839                         break;
 840                     case TypeID.STRING_TOKEN:
 841                         offset += Serializer.serializeSTRING(((String) data), bytes, offset, encoding);
 842                         break;
 843                     case TypeID.IPADDR_TOKEN:
 844                         offset += Serializer.serializeIPADDR(((IPAddress) data), bytes, offset);
 845                         break;
 846                     case TypeID.STRING_ARRAY_TOKEN:
 847                         offset += Serializer.serializeStringArray
 848                                 (((String[]) data), bytes, offset, encoding);
 849                         break;
 850                     default:
 851                         Log.warning("Unknown BaseType token: " + typeToken);
 852                         break;
 853                 } // switch(typeToken)
 854
 855                 Log.trace("Serialized attribute " + key);
 856             } // while(e.hasMoreElements())
 857         } // if(attributes != null)
 858
 859         return bytes;
 860     }
 861
 862     /**
 863      * Deserialize the Event from byte array
 864      *
 865      * @param bytes the byte array containing a serialized Event
 866      */
 867     public void deserialize(byte[] bytes)
 868             throws EventSystemException {
 869         if (bytes == null) {
 870             return;
 871         }
 872         if (state == null) {
 873             state = new DeserializerState();
 874         }
 875
 876         state.reset();
 877         setEventName(Deserializer.deserializeEVENTWORD(state, bytes));
 878         long num = Deserializer.deserializeUINT16(state, bytes);
 879         if (Log.isLogTrace()) {
 880             Log.trace("Event name = " + getEventName());
 881             Log.trace("Number of attribute: " + num);
 882         }
 883         for (int i = 0; i < num; ++i) {
 884             String attribute = Deserializer.deserializeATTRIBUTEWORD(state, bytes);
 885
 886             byte type = Deserializer.deserializeBYTE(state, bytes);
 887             if (Log.isLogTrace()) {
 888                 Log.trace("Attribute: " + attribute);
 889                 Log.trace("Type: " + TypeID.byteIDToString(type));
 890                 Log.trace("State: " + state);
 891             }
 892             if (attribute != null) {
 893                 if (i == 0 && attribute.equals(ENCODING)) {
 894                     if (type == TypeID.INT16_TOKEN) {
 895                         setEncoding(Deserializer.deserializeINT16(state, bytes));
 896                         continue;
 897                     }
 898                     else {
 899                         Log.warning("Found encoding, but type was not int16 while deserializing");
 900                     }
 901                 }
 902
 903                 switch (type) {
 904                     case TypeID.BOOLEAN_TOKEN:
 905                         boolean aBool = Deserializer.deserializeBOOLEAN(state, bytes);
 906                         setBoolean(attribute, aBool);
 907                         break;
 908                     case TypeID.UINT16_TOKEN:
 909                         int uShort = Deserializer.deserializeUINT16(state, bytes);
 910                         setUInt16(attribute, uShort);
 911                         break;
 912                     case TypeID.INT16_TOKEN:
 913                         short aShort = Deserializer.deserializeINT16(state, bytes);
 914                         setInt16(attribute, aShort);
 915                         break;
 916                     case TypeID.UINT32_TOKEN:
 917                         long uInt = Deserializer.deserializeUINT32(state, bytes);
 918                         setUInt32(attribute, uInt);
 919                         break;
 920                     case TypeID.INT32_TOKEN:
 921                         int aInt = Deserializer.deserializeINT32(state, bytes);
 922                         setInt32(attribute, aInt);
 923                         break;
 924                     case TypeID.UINT64_TOKEN:
 925                         long uLong = Deserializer.deserializeUINT64(state, bytes);
 926                         setUInt64(attribute, BigInteger.valueOf(uLong));
 927                         break;
 928                     case TypeID.INT64_TOKEN:
 929                         long aLong = Deserializer.deserializeINT64(state, bytes);
 930                         setInt64(attribute, aLong);
 931                         break;
 932                     case TypeID.STRING_TOKEN:
 933                         String s = Deserializer.deserializeSTRING(state, bytes, encoding);
 934                         setString(attribute, s);
 935                         break;
 936                     case TypeID.IPADDR_TOKEN:
 937                         byte[] inetAddress = Deserializer.deserializeIPADDR(state, bytes);
 938                         setIPAddress(attribute, inetAddress);
 939                         break;
 940                     case TypeID.STRING_ARRAY_TOKEN:
 941                         String[] sArray = Deserializer.deserializeStringArray(state, bytes, encoding);
 942                         setStringArray(attribute, sArray);
 943                         break;
 944                     default:
 945                         Log.warning("Unknown type " + type + " in deserialization");
 946                 }
 947             }
 948         } // for (int i =0 ...
 949
 950     }
 951
 952     /**
 953      * Returns a mutable copy of the event.  This is a SLOW operation.
 954      *
 955      * @return Event the Event object
 956      * @throws NoSuchEventException         if the Event does not exist in the EventTemplateDB
 957      * @throws NoSuchAttributeException     if the attribute does not exist in this event
 958      * @throws NoSuchAttributeTypeException if there is an attribute that does not match a type in the EventTemplateDB
 959      */
 960     public Event copy() throws EventSystemException {
 961         /* match the type-checking of the original event */
 962         Event evt = new Event(name, isValidating(), getEventTemplateDB());
 963         for (Enumeration<String> e = attributes.keys(); e.hasMoreElements();) {
 964             String key = e.nextElement();
 965             BaseType value = attributes.get(key);
 966             evt.set(key, value);
 967         }
 968
 969         return evt;
 970     }
 971
 972     /**
 973      * Returns a String representation of this event
 974      *
 975      * @return a String return of this event.
 976      */
 977     public String toString() {
 978         if (name == null) {
 979             return "";
 980         }
 981
 982         StringBuffer sb = new StringBuffer();
 983         sb.append(name);
 984         sb.append("\n{\n");
 985
 986         if (attributes != null) {
 987             int i = 0;
 988             String[] keys = new String[attributes.size()];
 989             for (Enumeration<String> e = attributes.keys(); e.hasMoreElements();) {
 990                 keys[i++] = e.nextElement();
 991             }
 992
 993             Arrays.sort(keys);
 994
 995             for (i = 0; i < attributes.size(); ++i) {
 996                 BaseType value = attributes.get(keys[i]);
 997                 if (isValidating() && getEventTemplateDB() != null) {
 998                     if (getEventTemplateDB().checkTypeForAttribute(name, keys[i], TypeID.UINT64_STRING)) {
 999                         try {
1000                             sb.append("\t")
1001                                     .append(keys[i])
1002                                     .append(" = ")
1003                                     .append(NumberCodec.toHexString(getUInt64(keys[i])))
1004                                     .append(";\n");
1005                         }
1006                         catch (EventSystemException exc) {
1007                             Log.warning("Event.toString : ", exc);
1008                         }
1009                     }
1010                     else {
1011                         sb.append("\t").append(keys[i]).append(" = ").append(value).append(";\n");
1012                     }
1013                 }
1014                 else {
1015                     sb.append("\t").append(keys[i]).append(" = ").append(value).append(";\n");
1016                 }
1017             } // for(i = 0; i < attributes.size() ...
1018         } // if(attributes != null)
1019
1020         sb.append("}");
1021         return sb.toString();
1022     }
1023
1024     @Override
1025     public int hashCode() {
1026         return toString().hashCode();
1027     }
1028
1029     public boolean equals(Object o) {
1030         if (o == null) {
1031             return false;
1032         }
1033         if (getClass().getName().equals(o.getClass().getName())) {
1034             return toString().equals(o.toString());
1035         }
1036         else {
1037             return false;
1038         }
1039     }
1040
1041     /**
1042      * This method can be used to validate an event after it has been created.
1043      *
1044      * @throws EventSystemException
1045      */
1046     public void validate() throws EventSystemException {
1047         EventTemplateDB templ = getEventTemplateDB();
1048         if (templ == null) {
1049             throw new EventSystemException("No template defined.");
1050         }
1051         if (!templ.checkForEvent(name)) {
1052             throw new NoSuchEventException("Event " + name + " does not exist in event definition");
1053         }
1054         for (String key : attributes.keySet()) {
1055             if (!templ.checkForAttribute(name, key)) {
1056                 throw new NoSuchAttributeException("Attribute " + key + " does not exist for event " + name);
1057             }
1058             Object value = get(key);
1059             BaseType expected = templ.getBaseTypeForObjectAttribute(name, key, value);
1060             BaseType bt = BaseType.baseTypeFromObject(value);
1061             /**
1062              * There are no unsigned values in java so they are kind of a special case
1063              * in that i can't guess which one the person meant. This small hack treats
1064              * similar types the same way.
1065              */
1066             if ((expected.getTypeToken() == TypeID.UINT16_TOKEN &&
1067                 bt.getTypeToken() == TypeID.INT32_TOKEN) ||
1068                 (expected.getTypeToken() == TypeID.UINT32_TOKEN &&
1069                 bt.getTypeToken() == TypeID.INT64_TOKEN) ||
1070                 (expected.getTypeToken() == TypeID.UINT64_TOKEN &&
1071                 bt.getTypeToken() == TypeID.INT64_TOKEN)    ) {
1072                 bt = expected;
1073             }
1074             if (!templ.checkTypeForAttribute(name, key, bt)) {
1075                 throw new NoSuchAttributeTypeException("Wrong type '" + bt.getTypeName() +
1076                                                        "' for " + name + "." + key);
1077             }
1078         }
1079     }
1080 }