/*
 *	DNN - Data News Network
 *
 *	by Stephane Chatty
 *
 *	Copyright 1993-1997
 *	Centre d'Etudes de la Navigation Aerienne (CENA)
 *
 *	Events.
 *
 *	$Id$
 *	$CurLog$
 */

#include "Event.h"
#include <memory.h>

IvlEventFeatureList :: IvlEventFeatureList (const IvlEventFeatureList& base, int nbf, IvlEventFeature* f)
: IvlListOf <IvlEventFeature> (base)
{
	Load (nbf, f);
}

IvlEventFeatureList :: IvlEventFeatureList (int nbf, IvlEventFeature* f)
: IvlListOf <IvlEventFeature> ()
{
	Load (nbf, f);
}

void
IvlEventFeatureList :: Load (int nbf, IvlEventFeature* f)
{
	while (nbf-- > 0)
		Append (f++);
}

IvlEventFeatureList :: ~IvlEventFeatureList ()
{
}

/*?class IvlEventType
A \typ{IvlEventType} contains the description of a -- dynamic -- class of events.
It holds a name and an array of offsets, each describing where to find the corresponding
feature in an event of that class.
?*/

IvlListOf <IvlEventType>* IvlEventType::AllTypes = 0;

/*?hidden?*/
void
IvlEventType :: ClassInit ()
{
	AllTypes = new IvlListOf <IvlEventType>;
}

/*?
Build an event type named \var{name} from an array of features. This is mostly
useful for statically defined event classes. \var{f} is the array of features, and
\var{nbf} is the number of features in that array.
?*/
IvlEventType :: IvlEventType (const char* name, int nbf, IvlEventFeature f [])
: Name (name),
#if 0
  Features (),
#endif
  NbFeatures (nbf),
  FeaturesOffsets (new int [nbf])
{
	if (!AllTypes)
		ClassInit ();
	AllTypes->Append (this);
	int offset = 0;
	for (int i = 0; i < nbf; ++i) {
		offset += f[i].Size;
		FeaturesOffsets [i] = offset;
	}
}

/*?
Build an event type from a list of features.
?*/
IvlEventType :: IvlEventType (const char* name, const IvlEventFeatureList& fl)
: Name (name),
#if 0
  Features (),
#endif
  NbFeatures (fl.Length ()),
  FeaturesOffsets (new int [NbFeatures])
{
	if (!AllTypes)
		ClassInit ();
	AllTypes->Append (this);
	int offset = 0;
	int i = 0;
	IvlListIterOf <IvlEventFeature> f = fl;
	while (++f) {
		offset += (*f)->Size;
		FeaturesOffsets [i] = offset;
		++i;
	}
}

/*?nodoc?*/
IvlEventType :: ~IvlEventType ()
{
	AllTypes->Remove (this);
	delete [] FeaturesOffsets;
}

IvlEvent :: IvlEvent ()
{
}

/* useless, for compatibility only */
IvlEvent :: IvlEvent (const IvlEventType*)
{
}

IvlEvent :: ~IvlEvent ()
{
}

/*?
Build an event of type \var{t}.
?*/
IvlBasicEvent :: IvlBasicEvent (const IvlEventType* t)
: IvlEvent (),
  Type (*t)
{
	int sz = t->GetTotalSize ();
	if (sz > 0)
		Data = new char [sz];
	else
		Data = 0;
}

IvlBasicEvent :: IvlBasicEvent (const IvlEventType* t, bool alloc)
: IvlEvent (),
  Type (*t)
{
	if (alloc) {
		int sz = t->GetTotalSize ();
		if (sz > 0)
			Data = new char [sz];
		else
			Data = 0;
	} else {
		Data = (char*) (&Data + sizeof (char*));
	}
}

/*?nodoc?*/
IvlBasicEvent :: ~IvlBasicEvent ()
{
	if (Data && Data != (char*) (&Data+sizeof (char*)))
		delete [] Data;
}

void
IvlBasicEvent :: SetFeature (int i, const void* data)
{
	int offset = Type.GetOffset (i);
	int size = Type.GetSize (i);
	memcpy (Data+offset, data, size);
}

void
IvlBasicEvent :: GetFeature (int i, void* data)
{
	int offset = Type.GetOffset (i);
	int size = Type.GetSize (i);
	memcpy (data, Data+offset, size);
}

#if 0
void
IvlBasicEvent :: WriteTo (IvlIOS& s)
{
	// what about byte swapping?
	s.WriteBuf ((const byte*) Data, Type.GetTotalSize ());
}

void
IvlBasicEvent :: ReadFrom (IvlIOS& s, lword)
{
	// what about byte swapping?
	s.ReadBuf ((byte*) Data, Type.GetTotalSize ());
}

#endif