event.h

Go to the documentation of this file.

/*
** Copyright (C) 2004 Russell Leighton
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

/*
Changes:

3/30/02 Russell Leighton
Added xactionid for transaction based control

*/

#ifndef __AWEVENT__
#define __AWEVENT__


#include <sys/bitypes.h>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <string.h>

#include "util.h"
#include "address.h"

/* Careful with this! It should change when you change the network format */
#define AW_EVENT_NET_FMTVERSION 2

/* largest message we will accept */
#define AW_EVENT_NET_MAXSIZE 0xffff

typedef int64_t  aw_timestamp_t;
#define AW_TIMESTAMP_PER_SEC ((aw_timestamp_t)1000000)

inline static aw_timestamp_t aw_gettimestamp(void)
{
  aw_timestamp_t
    stamp;

  /* is there a faster way? */
  struct timeval 
    tval;
  gettimeofday(&tval, NULL);
  stamp = (tval.tv_sec * AW_TIMESTAMP_PER_SEC) + tval.tv_usec ;

  return stamp ;
}

typedef enum {

  AW_EVENT_CONTEXT_CONTROL,     
  AW_EVENT_CONTEXT_ALARM,       
  AW_EVENT_CONTEXT_HANDLER,     
  AW_EVENT_CONTEXT_EXTERNAL,    
} aw_event_context_t;

typedef enum {

  AW_EVENT_TYPE_UNKNOWN,  /* must be 1st! */

  /* for internal use only */
  AW_EVENT_TYPE_MON_ADD_ALARM,
  AW_EVENT_TYPE_MON_REMOVE_ALARM,
  AW_EVENT_TYPE_MON_ADD_HANDLER_FDCALLBACK,
  AW_EVENT_TYPE_MON_REMOVE_HANDLER_FDCALLBACK,
  AW_EVENT_TYPE_MON_ADD_HANDLER_IRECALLBACK,
  AW_EVENT_TYPE_MON_REMOVE_HANDLER_IRECALLBACK,
  AW_EVENT_TYPE_MON_ADD_HANDLER,
  AW_EVENT_TYPE_MON_REMOVE_HANDLER,

  /* generic */
  AW_EVENT_TYPE_INT32,
  AW_EVENT_TYPE_INT64,
  AW_EVENT_TYPE_TIMESTAMP,
  AW_EVENT_TYPE_FLOAT32,
  AW_EVENT_TYPE_FLOAT64,
  AW_EVENT_TYPE_STRING,
  AW_EVENT_TYPE_PTR,

  AW_EVENT_NTYPES         /* must be last ! */

}  aw_event_payload_t;


#define AW_EVENT_SIGNAME_SIZE 64

typedef struct {

  /* descriptive name of event */
  byte_t
   name[AW_EVENT_SIGNAME_SIZE];

  /* descriptive name of event source */
  byte_t
   source[AW_EVENT_SIGNAME_SIZE];

  /* priority */
  int32_t
   priority;

  /* address for handlers to match */
  aw_address_t
   id;

} aw_event_sig_t;

typedef struct 
{

  int32_t
   xactionid;               /* id of particular xaction  */

} aw_event_xactioninfo_t;

typedef struct aw_event_s 
{

  /* list */
  struct 
   aw_event_s *next;

  /* where this was created */
  aw_event_context_t
   context;

  /* time stamp for this event */
  aw_timestamp_t 
   tstamp;

  /* event signature */
  aw_event_sig_t
   sig;

  /* transaction info, used to track events when alarms/handlers use alarmsync */
  aw_event_xactioninfo_t
   xactioninfo;

  /* type for payload */
  aw_event_payload_t
   payload_type;

  /* data */
  union {

    int32_t
     int32_value;

    int64_t
     int64_value;

    float32_t
     float32_value;

    float64_t
     float64_value;

    aw_timestamp_t
     tstamp;

    byte_t
     *string;                         /* ptr to null terminated string */

    void 
     *valueptr ;                      /* ptr to some data, use event's 'id', 'source' and 'status' to dispatch */

  } payload;


  /* called when dup()ing an event of type AW_EVENT_TYPE_PTR, may return a copy of the data
     or the orginal ptr, you are on your own to manage this memory. It is suggested you
     not pass fancy structures.
  */
  void * (*copy_valueptr)(void *valueptr);

  /* called before freeing event structure, use this to free resources an event references */
  void (*finalize)(struct aw_event_s *e);

  /* called to write payload as text in 's' with max chars 'size' , set to default in aw_create_event() */
  void (*tostring)(struct aw_event_s *e, byte_t *s, u_int32_t size);

  /* memory management */
  aw_cache_allocator_t
   *factory;

} aw_event_t;

typedef struct 
{

  /* how many in q */
  u_int32_t count;

  /* first in q */
  aw_event_t *first;

  /* last in q */
  aw_event_t *last;

} aw_event_q_t;


/* #################### exported functions ######################## */

/* event.c */

/*** q management ***/

inline static void aw_append_q(aw_event_t *e, aw_event_q_t *q)
{
  u_int32_t
    count = q->count;

  if ( count == 0 ) {

    q->first = e;
  
  } else {

    q->last->next = e;

  } /* end else */

  q->last = e;
  q->count = count + 1;
  e->next = NULL;
}

inline static void aw_push_q(aw_event_t *e, aw_event_q_t *q)
{
  u_int32_t
    count = q->count;

  if ( count == 0 ) q->last = e;

  q->count = count + 1;
  e->next = q->first;
  q->first = e;

}

inline static aw_event_t * aw_dq_q(aw_event_q_t *q)
{
  aw_event_t
    *last, *e;
  u_int32_t
    count = q->count;
  
  if (count != 0) {

    q->count = count - 1;
    e = q->last;
    last = e->next;
    e->next = NULL ;
    q->last = last;
    if ( last == NULL ) q->first = last;

  } else {

    e = NULL ;

  }/* end else */

  return e ;
}


inline static aw_event_t * aw_pop_q(aw_event_q_t *q)
{
  aw_event_t
    *first, *e;
  u_int32_t
    count = q->count;
  
  if (count != 0) {

    q->count = count - 1;
    e = q->first;
    first = e->next;
    e->next = NULL;
    q->first = first;
    if ( first == NULL ) q->last = first;

  } else {

    e = NULL ;

  }/* end else */

  return e ;
}


inline static void aw_append_qs(aw_event_q_t *q1, aw_event_q_t *q2)
{
  u_int32_t
    count = q1->count;

  /* don't bother */
  if ( q2->count == 0 ) goto done;

  /* just set if 0 */
  if (count == 0) {

    /* copy */
    memcpy( q1, q2, sizeof(aw_event_q_t));

  } else {

    count += q2->count;

    q1->count = count;
    q1->last->next = q2->first;
    q1->last = q2->last;

  }/* end else */

  /* clear q2 */
  memset(q2, 0, sizeof(aw_event_q_t));

 done:;

}


const aw_event_t *aw_findin_q(const aw_event_t *e, const aw_event_q_t *q);

void aw_clear_q(aw_event_q_t *q);

/*** event management ***/

aw_event_t * aw_create_event(aw_event_context_t context, aw_cache_allocator_t *f);

void aw_destroy_event(aw_event_t *e);

aw_event_t *aw_dup_event(const aw_event_t *e,   aw_cache_allocator_t  *f);

void aw_event_format(aw_event_t *e, byte_t *format, byte_t *s, u_int32_t size);


int32_t aw_event2n(aw_event_t *e, int32_t size, byte_t *buffer);


int32_t aw_n2event(aw_event_t *e, const byte_t *buffer);

#endif

Aware 0.11.1 Copyright (C) 1998-2005 Russell Leighton (russ@elegant-software.com)