/*************************************************************************\
* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
*     National Laboratory.
* Copyright (c) 2002 The Regents of the University of California, as
*     Operator of Los Alamos National Laboratory.
* EPICS BASE Versions 3.13.7
* and higher are distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution. 
\*************************************************************************/
// Author: Jim Kowalkowski
// Date: 2/96
// 
// Revision-Id: anj@aps.anl.gov-20101005192737-disfz3vs0f3fiixd
// 

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include <string>
#include <stdexcept>

#define epicsExportSharedSymbols
#include "gdd.h"

gdd_NEWDEL_NEW(gdd)
gdd_NEWDEL_DEL(gdd)
gdd_NEWDEL_STAT(gdd)

epicsMutex * gdd::pGlobalMutex;

static epicsThreadOnceId gddOnce = EPICS_THREAD_ONCE_INIT;

class gddFlattenDestructor : public gddDestructor
{
public:
	gddFlattenDestructor(void) { }
	gddFlattenDestructor(void* user_arg):gddDestructor(user_arg) { }
	void run(void*);
};

class gddContainerCleaner : public gddDestructor
{
public:
	gddContainerCleaner(void) { }
	gddContainerCleaner(void* user_arg):gddDestructor(user_arg) { }
	void run(void*);
};

void gddFlattenDestructor::run(void*)
{
	return;
}

void gddContainerCleaner::run(void* v)
{
	gddContainer* cdd = (gddContainer*)v;
	int tot = cdd->total();
	int i;
	for(i=0;i<tot;i++) cdd->remove(0);
}

//
// special gddDestructor guarantees same form of new and delete
//
class gddAitUint8Destructor: public gddDestructor {
	virtual void run (void *);
};

//
// special gddDestructor guarantees same form of new and delete
//
class gddAitStringDestructor: public gddDestructor {
	virtual void run (void *);
};

// --------------------------The gdd functions-------------------------

extern "C" void gddStaticInit ( void * p )
{
    epicsMutex * * pMutex = static_cast < epicsMutex * * > ( p );
    *pMutex = new epicsMutex ();
}

gdd::gdd(int app, aitEnum prim, int dimen)
{
	init(app,prim,dimen);
}

gdd::gdd(int app, aitEnum prim, int dimen, aitUint32* val) 
{
	init(app,prim,dimen);
	for(int i=0;i<dimen;i++) bounds[i].set(0,val[i]);
}

void gdd::init(int app, aitEnum prim, int dimen)
{
    epicsThreadOnce ( & gddOnce, gddStaticInit, & gdd::pGlobalMutex );
	setApplType(app);
	//
	// joh - we intentionally dont call setPrimType()
	// here because the assumption is that init() is only
	// called from the constructor, and we dont want
	// to destroy a non-existent string if the uninitialized
	// prim type is a string
	//
	this->prim_type = prim;
	dim=(aitUint8)dimen;
	destruct=NULL;
	ref_cnt=1;
	flags=0;
	bounds=NULL;
	setStatSevr(0u,0u);

	if(dim)
	{
		switch(dim)
		{
		case 1:  bounds=(gddBounds*)new gddBounds1D; bounds->set(0,0); break;
		case 2:  bounds=(gddBounds*)new gddBounds2D; break;
		case 3:  bounds=(gddBounds*)new gddBounds3D; break;
		default: bounds=(gddBounds*)new gddBounds[dim]; break;
		}
        memset ( & this->data, '\0', sizeof ( this->data ) );
	}
	else if(primitiveType()==aitEnumString)
	{
		aitString* str=(aitString*)dataAddress();
		str->init();
	}
	else if (primitiveType()==aitEnumFixedString)
	{
		this->data.FString = new aitFixedString;
		memset ( this->data.FString, '\0', sizeof(aitFixedString) );
	}
    else {
        memset ( & this->data, '\0', sizeof ( this->data ) );
    }
}

gdd::gdd(gdd* dd)
{
	//
	// added this because the "copy()" below bombs
	// if the GDD isnt initialized
	// joh - 4-23-99
	//
	this->init (dd->appl_type, dd->primitiveType(), dd->dimension());

	copyInfo(dd);
}

gdd::~gdd(void)
{
	gdd* dd;
	gdd* temp;

	// fprintf(stderr,"A gdd is really being deleted %8.8x!!\n",this);

	if(isContainer())
	{
		if(destruct)
			destruct->destroy(dataPointer());
		else
		{
			for(dd=(gdd*)dataPointer();dd;)
			{
				temp=dd;
				dd=dd->next();
				temp->unreference();
			}
			freeBounds();
		}
	}
	else if(isAtomic())
	{
		if(destruct) destruct->destroy(dataPointer());
		if(bounds) freeBounds();
	}
	else
	{
		//
		// this destroys any scalar string data that may be present
		//
		this->setPrimType (aitEnumInvalid);
	}
	this->setApplType (0);
    memset ( & this->data, '\0', sizeof ( this->data ) );
}

// this routine is private so we dont need to initialize
// string data when changing to a scalar, but we do need
// to be careful about how it is called
void gdd::freeBounds(void)
{
	if(bounds)
	{
		switch(dim)
		{
		case 0: 
		    fprintf ( stderr, "gdd: freeing bounds, bounds exist, but gdd is scalar?\n" );
		    break;
		case 1: { gddBounds1D* d1=(gddBounds1D*)bounds; delete d1; } break;
		case 2: { gddBounds2D* d2=(gddBounds2D*)bounds; delete d2; } break;
		case 3: { gddBounds3D* d3=(gddBounds3D*)bounds; delete d3; } break;
		default: delete [] bounds; break;
		}
		bounds=NULL;
	}
	dim=0;	
}

void gdd::setDimension(int d, const gddBounds* bnds)
{
    if ( dim != 0 ) {
        if ( isFlat() || isManaged() ) {
            throw std::logic_error ( 
                "sorry: cant change the bounds on an atomic, managed or flat gdd" );
        }
    }
	if(dim!=d)
	{
        if ( dim == 0 ) {
		    // run destructors for scalar string data
		    if ( primitiveType() == aitEnumFixedString )
		    {
			    // aitString type could have destructors
                if ( destruct ) {
				    destruct->destroy(dataPointer());
                    destruct = 0;
                }
			    else
				    if (data.FString) delete data.FString;
		    }
		    else if ( primitiveType() == aitEnumString )
		    {
			    // aitString type could have destructors
                if ( destruct ) {
				    destruct->destroy(dataAddress());
                    destruct = 0;
                }
			    else
			    {
				    aitString* s = (aitString*)dataAddress();
				    s->clear();
			    }
		    }
            // changing from scalar to vector so set the 
            // vector pointer to nill
            memset ( & this->data, '\0', sizeof ( this->data ) );
        }
        else {
		    this->freeBounds();
        }
		dim=(aitUint8)d;
		switch(dim)
		{
		case 0:  bounds=0; break;
		case 1:  bounds=(gddBounds*)new gddBounds1D; bounds->set(0,0); break;
		case 2:  bounds=(gddBounds*)new gddBounds2D; break;
		case 3:  bounds=(gddBounds*)new gddBounds3D; break;
		default: bounds=(gddBounds*)new gddBounds[dim]; break;
		}
        if ( dim == 0 ) {
            if ( destruct ) {
	            destruct->destroy(dataAddress());
                destruct = 0;
            }
		    // run constructers for scalar string data types
		    if ( primitiveType() == aitEnumString ) {
			    aitString* str=(aitString*)dataAddress();
			    str->init();
		    }
		    else if ( primitiveType() ==aitEnumFixedString ) {
			    this->data.FString = new aitFixedString;
			    memset (this->data.FString, '\0', sizeof(aitFixedString));
		    }
            else {
                memset ( & this->data, '\0', sizeof ( this->data ) );
            }
        }
	}
	if ( bnds )
	{
		for(int i=0;i<dim;i++)
			bounds[i]=bnds[i];
	}
}

gddStatus gdd::registerDestructor(gddDestructor* dest)
{
	// this is funky, will not register a destructor if one is present
	if(destruct)
	{
		gddAutoPrint("gdd::registerDestructor()",gddErrorAlreadyDefined);
		return gddErrorAlreadyDefined;
	}
	else
		return replaceDestructor(dest);
}

gddStatus gdd::replaceDestructor(gddDestructor* dest)
{
	destruct=dest;
	destruct->reference();

	if(isContainer()||isFlat())
		markManaged();

	return 0;
}

gddStatus gdd::genCopy(aitEnum t, const void* d, aitDataFormat f)
{
	gddStatus rc=0;

	if(isScalar())
		set(t,d,f);
	else if(isAtomic())
	{
		if(!dataPointer())
		{
            if ( primitiveType()==aitEnumString ) {
                size_t nElem = describedDataSizeElements ();
                aitString * pStrVec = new aitString [ nElem ];
                if ( ! pStrVec ) {
				    gddAutoPrint("gdd::genCopy()",gddErrorNewFailed);
				    rc = gddErrorNewFailed;
                }
                else {
                    destruct = new gddAitStringDestructor;
                    if ( destruct ) {
                        destruct->reference();
                        setData ( pStrVec );
                    }
                    else {
                        delete [] pStrVec;
                        gddAutoPrint("gdd::genCopy()",gddErrorNewFailed);
                        rc = gddErrorNewFailed;
                    }
                }
            }
            else {
			    size_t sz=describedDataSizeBytes();
	            aitUint8 * buf = new aitUint8[sz];
			    if ( buf == NULL ) {
				    gddAutoPrint("gdd::genCopy()",gddErrorNewFailed);
				    rc=gddErrorNewFailed;
			    }
			    else
			    {
				    destruct=new gddAitUint8Destructor;
				    if (destruct==NULL) {
					    gddAutoPrint("gdd::genCopy()",gddErrorNewFailed);
					    rc=gddErrorNewFailed;
					    delete [] buf;
				    }
				    else {
					    setData(buf);
					    destruct->reference();
				    }
			    }
            }
		}
		if(rc==0)
		{
			if(f==aitLocalDataFormat)
				aitConvert(primitiveType(),dataPointer(),t,d,
					getDataSizeElements());
			else
				aitConvertFromNet(primitiveType(),dataPointer(),t,d,
					getDataSizeElements());

			markLocalDataFormat();
		}
	}
	else
	{
		gddAutoPrint("gdd::genCopy()",gddErrorTypeMismatch);
		rc=gddErrorTypeMismatch;
	}

	return rc;
}


gddStatus gdd::changeType(int app,aitEnum prim)
{
	gddStatus rc=0;

	// this should only be allowed for setting the type if it is
	// undefined or if the data is a scalar

	if(isScalar() || primitiveType()==aitEnumInvalid)
	{
		setApplType(app);
		setPrimType(prim);
	}
	else
	{
		gddAutoPrint("gdd::changeType()",gddErrorTypeMismatch);
		rc=gddErrorTypeMismatch;
	}

	return rc;
}

gddStatus gdd::setBound(unsigned index_dim, aitIndex first, aitIndex count)
{
	gddStatus rc=0;
	if(index_dim<dimension())
		bounds[index_dim].set(first,count);
	else
	{
		gddAutoPrint("gdd::setBound()",gddErrorOutOfBounds);
		rc=gddErrorOutOfBounds;
	}
	return rc;
}

gddStatus gdd::getBound(unsigned index_dim, aitIndex& first, aitIndex& count) const
{
	gddStatus rc=0;
	if(index_dim<dimension())
		bounds[index_dim].get(first,count);
	else
	{
		gddAutoPrint("gdd::getBound()",gddErrorOutOfBounds);
		rc=gddErrorOutOfBounds;
	}
	return rc;
}

// should the copy functions in gdd use the flatten technique?
gddStatus gdd::copyStuff(const gdd* dd,int ctype)
{
	gddStatus rc=0;
	gddContainer* cdd;
	gdd *pdd,*ndd;

	// blow me out quickly here
	if(isFlat()||isManaged())
	{
		gddAutoPrint("gdd::copyStuff()",gddErrorNotAllowed);
		return gddErrorNotAllowed;
	}

	clear();

	setApplType(dd->appl_type);
    setPrimType(aitEnumContainer);
	setStatSevr(dd->getStat(),dd->getSevr());

	if(dd->isContainer())
	{
		cdd=(gddContainer*)dd;
		gddCursor cur=cdd->getCursor();
		for(ndd=cur.first();ndd;ndd=cur.next())
		{
			pdd=new gdd(ndd->applicationType(),
				ndd->primitiveType(),ndd->dimension());
			pdd->setNext((gdd*)dataPointer());
			setData(pdd);
			bounds->setSize(bounds->size()+1);
			pdd->copyStuff(ndd,ctype);
		}
	}
	else if(dd->isScalar()) {
		if (dd->primitiveType()==aitEnumString) {
			aitString* pStrDest =(aitString*)&data;
			aitString* pStrSrc =(aitString*)&dd->data;
			*pStrDest = *pStrSrc;
		}
		else if (dd->primitiveType()==aitEnumFixedString) {
			aitFixedString* pStrDest =(aitFixedString*)data.Pointer;
			aitFixedString* pStrSrc =(aitFixedString*)dd->data.Pointer;
			memcpy (pStrDest, pStrSrc, sizeof(aitFixedString));
		}
		else {
			data=dd->data;
		}
	}
	else // atomic
	{
		const gddBounds* bnds = dd->getBounds();
		for(unsigned i=0;i<dd->dimension();i++) bounds[i]=bnds[i];

		switch(ctype)
		{
		case 1: // copy()
            if ( primitiveType()==aitEnumString ) {
                size_t nElem = dd->describedDataSizeElements ();
                aitString * pStrVec = new aitString [ nElem ];
                if ( ! pStrVec ) {
				    gddAutoPrint("gdd::copyStuff()",gddErrorNewFailed);
				    rc=gddErrorNewFailed;
                }
                else {
                    destruct = new gddAitStringDestructor;
                    if ( destruct ) {
                        const aitString * pSrc = 
                            static_cast <const aitString *> ( dd->dataPointer() );
                        for ( unsigned j=0; j < nElem; j++ ) {
                            pStrVec[j] = pSrc[j];
                        }
                        destruct->reference();
                        setData ( pStrVec );
                    }
                    else {
                        delete [] pStrVec;
					    gddAutoPrint("gdd::copyStuff()",gddErrorNewFailed);
					    rc=gddErrorNewFailed;
                    }
                }
            }
            else {
			    size_t a_size = dd->getDataSizeBytes();
			    aitUint8* array = new aitUint8[a_size];
			    if ( array ) {
				    destruct=new gddAitUint8Destructor;
				    if (destruct!=NULL) {
					    destruct->reference();
					    memcpy(array,dd->dataPointer(),a_size);
					    setData(array);
				    }
				    else {
					    delete [] array;
					    gddAutoPrint("gdd::copyStuff()",gddErrorNewFailed);
					    rc=gddErrorNewFailed;
				    }
			    }
			    else
			    {
				    gddAutoPrint("gdd::copyStuff()",gddErrorNewFailed);
				    rc=gddErrorNewFailed;
			    }
            }
			break;
		case 2: // Dup()
			data=dd->getData(); // copy the data reference
			destruct=dd->destruct;
			if(destruct) destruct->reference();
			break;
		case 0: // copyInfo()
		default: break;
		}
	}
	return rc;
}

size_t gdd::getDataSizeBytes(void) const
{
	size_t sz=0;
	const gdd* pdd;
	aitString* str;

	if(isContainer())
	{
		const gddContainer* cdd=(const gddContainer*)this;
		constGddCursor cur=cdd->getCursor();
		for(pdd=cur.first();pdd;pdd=cur.next())
			sz+=pdd->getTotalSizeBytes();
	}
	else
	{
		if(aitValid(primitiveType()))
		{
			if(primitiveType()==aitEnumString)
			{
				if(dimension()) str=(aitString*)dataPointer();
				else str=(aitString*)dataAddress();
				sz+=(size_t)(aitString::totalLength(str,
					getDataSizeElements()));
			}
			else
				sz+=(size_t)(getDataSizeElements())*aitSize[primitiveType()];
		}
	}
	return sz;
}

size_t gdd::describedDataSizeBytes(void) const
{
	size_t sz=0;

	// does not work well for aitString - only reports the aitString info

	if(!isContainer())
		sz+=(size_t)(describedDataSizeElements())*aitSize[primitiveType()];

	return sz;
}

size_t gdd::getTotalSizeBytes(void) const
{
	size_t sz;
	unsigned long tsize;
	const gdd* pdd;

	// add up size of bounds + size of this DD
	sz=sizeof(gdd)+(sizeof(gddBounds)*dimension());

	// special case the aitString/aitFixedString here - sucks bad
	if(isScalar())
	{
		if(primitiveType()==aitEnumString)
		{
			aitString* str=(aitString*)dataAddress();
			sz+=str->length()+1; // include the NULL
		}
		else if(primitiveType()==aitEnumFixedString)
			sz+=sizeof(aitFixedString);
	}
	else if(isAtomic())
	{
		if(aitValid(primitiveType()))
		{
			if(primitiveType()==aitEnumString)
			{
				// special case the aitString here
				tsize=(size_t)(aitString::totalLength((aitString*)dataPointer(),
					getDataSizeElements()));
			}
			else
				tsize=(size_t)(getDataSizeElements())*aitSize[primitiveType()];

			sz+=(size_t)align8(tsize); // include alignment
		}
	}
	else if(isContainer())
	{
		const gddContainer* cdd=(const gddContainer*)this;
		constGddCursor cur=cdd->getCursor();
		for(pdd=cur.first();pdd;pdd=cur.next())
			sz+=pdd->getTotalSizeBytes();
	}
	return sz;
}

aitUint32 gdd::getDataSizeElements(void) const
{
	unsigned long total=1u;
	unsigned i;

	if(dimension()>0u && dataPointer())
	{
		for(i=0u;i<dimension();i++) 
			total*=bounds[i].size();
	}

	return total;
}

aitUint32 gdd::describedDataSizeElements(void) const
{
	unsigned long total=0;
	unsigned i;

	if(dimension()==0)
		total=1;
	else
		for(i=0;i<dimension();i++) total+=bounds[i].size();

	return total;
}

size_t gdd::flattenWithOffsets(void* buf, size_t size, aitIndex* total_dd)
{
	gdd* flat_dd;
	size_t sz;
	
	sz = flattenWithAddress(buf,size,total_dd);
	flat_dd=(gdd*)buf;
	if(sz>0) flat_dd->convertAddressToOffsets();
	return sz;
}

// IMPORTANT NOTE:
// Currently the user cannot register an empty container as a prototype.
// The destructor will not be installed to clean up the container when
// it is freed.

// This is an important function
// Data should be flattened as follows:
// 1) all the GDDs, seen as an array an GDDs
// 2) all the bounds info for all the GDDs
// 3) all the data for all GDDs
//
// In addition, the user should be able to flatten GDDs without the data
// and flatten portions or all the data without flattening GDDs

size_t gdd::flattenWithAddress(void* buf, size_t size, aitIndex* total_dd)
{
	gdd* pdd = (gdd*)buf;
	size_t pos,sz,spos;
	aitUint32 i;
	gddBounds* bnds;

	// copy this gdd (first one) to get things started
	// this is done in two passes - one to copy DDs, one for bounds/data
	// need to be able to check if the DD has been flattened already

	if((sz=getTotalSizeBytes())>size) return 0;
	pdd[0]=*this;
	pdd[0].destruct=NULL;
	pdd[0].flags=0;
	pos=1;

	// not enough to just copy the gdd info if the primitive type is
	// aitString or aitFixedString (even if scalar gdd)
	// must special case the strings - that really sucks

	if(isScalar())
	{
		// here is special case for the string types
		if(primitiveType()==aitEnumFixedString)
		{
			if(data.FString)
				memcpy((char*)&pdd[pos],data.FString,sizeof(aitFixedString));

			pdd[0].data.FString=(aitFixedString*)&pdd[pos];
		}
		else if(primitiveType()==aitEnumString)
		{
			aitString* str=(aitString*)pdd[0].dataAddress();
			if(str->string())
			{
				memcpy((char*)&pdd[pos],str->string(),str->length()+1);
				str->installBuf((char*)&pdd[pos],str->length(),str->length()+1);
			}
			else
				str->init();
		}
	}
	else if(isContainer())
	{
		// need to check for bounds in the container and flatten them
		if(dataPointer())
		{
			// process all the container's DDs
			spos=pos;
			pos+=flattenDDs((gddContainer*)this,&pdd[pos],
				size-(pos*sizeof(gdd)));

			// copy all the data from the entire container into the buffer
			flattenData(&pdd[0],pos,&pdd[pos],size-(pos*sizeof(gdd)));

			pdd[0].markFlat();
			pdd[0].setData(&pdd[spos]);
		}
		else
			sz=0; // failure should occur - cannot flatten an empty container
	}
	else if(isAtomic())
	{
		// Just copy the data from this DD into the buffer, copy bounds
		if(bounds)
		{
			pdd[0].markFlat();
			bnds=(gddBounds*)(&pdd[pos]);
			for(i=0;i<dimension();i++) bnds[i]=bounds[i];
			pdd[0].bounds=bnds;
			if(dataPointer())
			{
				if(primitiveType()==aitEnumString)
				{
					// not very good way to do it, size info bad
					aitString* str = (aitString*)dataPointer();
					aitString::compact(str,getDataSizeElements(),&bnds[i],size);
				}
				else
					memcpy(&bnds[i],dataPointer(),getDataSizeBytes());

				pdd[0].setData(&bnds[i]);
			}
			else
				sz=0; // should return a failure
		}
		else
			sz=0; // should return failure
	}
	if(total_dd) *total_dd=pos;
	return sz;
}

gddStatus gdd::flattenData(gdd* dd, int tot_dds, void* buf,size_t size)
{
	int i;
	unsigned j;
	size_t sz;
	gddBounds* bnds;
	aitUint8* ptr = (aitUint8*)buf;

	// This functions needs to be divided into two sections
	// 1) copy ALL the bounds out
	// 2) copy ALL the data out

	for(i=0;i<tot_dds;i++)
	{
		if(dd[i].isContainer())
		{
			// don't mark flat if container - 1D bounds must be present
			if(dd[i].bounds)
			{
				bnds=(gddBounds*)(ptr);
				for(j=0;j<dd[i].dimension();j++) bnds[j]=dd[i].bounds[j];
				dd[i].bounds=bnds;
				ptr+=j*sizeof(gddBounds);
			}
			else
			{
				// this is an error condition!
				dd[i].bounds=NULL;
			}
		}
		else if(dd[i].isAtomic())
		{
			if(dd[i].bounds)
			{
				// copy the bounds
				// need to mark flat if bounds are present in an atomic type
				dd[i].markFlat();
				bnds=(gddBounds*)(ptr);
				for(j=0;j<dd[i].dimension();j++) bnds[j]=dd[i].bounds[j];
				dd[i].bounds=bnds;
				ptr+=j*sizeof(gddBounds);

				// copy the data
				if(dd[i].dataPointer())
				{
					if(dd[i].primitiveType()==aitEnumString)
					{
						// not very good way to do it, size info bad
						aitString* str = (aitString*)dd[i].dataPointer();
						sz=aitString::compact(str,
							dd[i].getDataSizeElements(),ptr,size);
					}
					else
					{
						// need to copy data here, align to size of double
						sz=dd[i].getDataSizeBytes();
						memcpy(ptr,dd[i].dataPointer(),sz);
					}
					dd[i].setData(ptr);
					ptr+=align8(sz); // do alignment
				}
			}
			else
			{
				// bounds not required
				dd[i].bounds=NULL;
			}
		}
		else if(dd[i].isScalar())
		{
			// here is special case for String types
			if(dd[i].primitiveType()==aitEnumString)
			{
				aitString* str=(aitString*)dd[i].dataAddress();
				if(str->string())
				{
					memcpy(ptr,str->string(),str->length()+1);
					str->installBuf((char *)ptr, str->length(), str->length()+1);
					ptr+=str->length()+1;
				}
				else
					str->init();
			}
			else if(dd[i].primitiveType()==aitEnumFixedString)
			{
				if(dd[i].data.FString)
					memcpy(ptr,dd[i].data.FString,sizeof(aitFixedString));
				dd[i].data.FString=(aitFixedString*)ptr;
				ptr+=sizeof(aitFixedString);
			}
		}
	}
	return 0;
}

int gdd::flattenDDs(gddContainer* dd, void* buf, size_t size)
{
	gdd* ptr=(gdd*)buf;
	int i,tot,pos,spos;
	gdd *pdd;
	gddCursor cur;

	cur=dd->getCursor();

	// make first pass to copy all the container's DDs into the buffer
	for(tot=0,pdd=cur.first();pdd;pdd=pdd->next(),tot++)
	{
		ptr[tot]=*pdd;
		ptr[tot].destruct=NULL;
		ptr[tot].setNext(&ptr[tot+1]);
		ptr[tot].noReferencing();
	}
	ptr[tot-1].setNext(NULL);

	// make second pass to copy all child containers into buffer
	for(pos=tot,i=0;i<tot;i++)
	{
		if(ptr[i].isContainer())
		{
			if(ptr[i].dataPointer())
			{
				spos=pos;
				pos+=flattenDDs((gddContainer*)&ptr[i],&ptr[pos],
					size-(pos*sizeof(gdd)));
				ptr[i].markFlat();
				ptr[i].setData(&ptr[spos]);
			}
			else
			{
				ptr[i].setData(NULL);
				ptr[i].destruct=new gddContainerCleaner(&ptr[i]);
				ptr[i].destruct->reference();
			}
		}
	}
	return pos;
}

gddStatus gdd::convertOffsetsToAddress(void)
{
	aitUint8* pdd = (aitUint8*)this;
	unsigned long bnds = (unsigned long)(bounds);
	unsigned long dp = (unsigned long)(dataPointer());
	gdd* tdd;
	gddContainer* cdd;
	gddCursor cur;
	aitString* str;
	aitIndex i;
	const char* cstr;

	if(isContainer())
	{
		// change bounds and data first
		bounds=(gddBounds*)(pdd+bnds);
		setData(pdd+dp);
		cdd=(gddContainer*)this;
		cur=cdd->getCursor();

		for(tdd=cur.first();tdd;tdd=cur.next())
		{
			if(tdd->next()) tdd->setNext((gdd*)(pdd+(unsigned long)tdd->next()));
			tdd->convertOffsetsToAddress();
		}
	}
	else
	{
		if(isAtomic())
		{
			bounds=(gddBounds*)(pdd+bnds);
			setData(pdd+dp);
			if(primitiveType()==aitEnumString)
			{
				// force all the strings in the array to offsets
				str=(aitString*)dataPointer();
				for(i=0;i<getDataSizeElements();i++)
				{
					if(str[i].string())
					{
						cstr=str[i].string();
						str[i].installBuf((char *)(pdd+(unsigned long)cstr), 
							str[i].length(), str[i].length()+1);
					}
					else
						str[i].init();
				}
			}
		}
		else if(isScalar())
		{
			if(primitiveType()==aitEnumFixedString)
			{
				if(data.FString) setData(pdd+dp);
			}
			else if(primitiveType()==aitEnumString)
			{
				str=(aitString*)dataAddress();
				if(str->string())
				{
					cstr=str->string();
					str->installBuf((char *)(pdd+(unsigned long)cstr), 
						str->length(), str->length()+1u);
				}
				else
					str->init();
			}
		}
	}
	return 0;
}

gddStatus gdd::convertAddressToOffsets(void)
{
	aitUint8* pdd = (aitUint8*)this;
	aitUint8* bnds = (aitUint8*)(bounds);
	aitUint8* dp = (aitUint8*)(dataPointer());
	gddContainer* tdd;
	gddCursor cur;
	gdd *cdd,*ddd;
	aitString* str;
	aitIndex i;
	const char* cstr;

	// does not ensure that all the members of a container are flat!
	if(!isFlat())
	{
		gddAutoPrint("gdd::convertAddressToOffsets()",gddErrorNotAllowed);
		return gddErrorNotAllowed;
	}

	if(isContainer())
	{
		tdd=(gddContainer*)this;
		cur=tdd->getCursor();

		for(cdd=cur.first();cdd;)
		{
			ddd=cdd;
			cdd=cur.next();
			ddd->convertAddressToOffsets();
			if(cdd) ddd->setNext((gdd*)((aitUint8*)(ddd->next())-pdd));
		}

		// bounds and data of container to offsets
		setData((gdd*)(dp-pdd));
		bounds=(gddBounds*)(bnds-pdd);
	}
	else
	{
		if(isAtomic())
		{
			if(primitiveType()==aitEnumString)
			{
				// force all the strings in the array to offsets
				str=(aitString*)dataPointer();
				for(i=0;i<getDataSizeElements();i++)
				{
					cstr=str[i].string();
					if(cstr) str[i].installBuf((char *)(cstr-(const char*)pdd),
							str[i].length(), str[i].length()+1u);
					else str[i].init();
				}
			}
			// bounds and data of atomic to offsets
			setData((gdd*)(dp-pdd));
			bounds=(gddBounds*)(bnds-pdd);
		}
		else if(isScalar())
		{
			// handle the special string scalar cases
			if(primitiveType()==aitEnumFixedString)
			{
				if(data.FString) setData((gdd*)(dp-pdd));
			}
			else if(primitiveType()==aitEnumString)
			{
				str=(aitString*)dataAddress();
				cstr=str->string();
				if(cstr) str->installBuf((char *)(cstr-(const char*)pdd), 
					str->length(), str->length()+1u);
				else str->init();
			}
		}
	}
	return 0;
}

void gdd::destroyData(void)
{
	if (isScalar())
	{
		// this destroys the string types
		this->setPrimType (aitEnumInvalid);
        memset ( & this->data, '\0', sizeof ( this->data ) );
	}
    else {
	    if(destruct)
	    {
		    if(isContainer())
			    destruct->destroy(this);
		    else
			    destruct->destroy(dataPointer());

		    destruct=NULL;
	    }
		freeBounds(); 
        this->prim_type = aitEnumInvalid;
        memset ( & this->data, '\0', sizeof ( this->data ) );
    }
}

gddStatus gdd::clearData(void)
{
	gddStatus rc=0;
	
	if(isContainer()||isManaged()||isFlat())
	{
		gddAutoPrint("gdd::clearData()",gddErrorNotAllowed);
		rc=gddErrorNotAllowed;
	}
    else if ( this->isScalar () ) {
        // clear scaler types
        if ( this->primitiveType() == aitEnumString ) {
			aitString * str=(aitString*)dataAddress();
			str->clear();
        }
        else if ( this->primitiveType() == aitEnumFixedString ) {
            memset ( this->data.FString, '\0', sizeof ( this->data.FString ) );
        }
        else {
            memset ( & this->data, '\0', sizeof ( this->data ) );
        }
    }
    else {
		if(destruct)
		{
			destruct->destroy(dataPointer());
			destruct=NULL;
		}
        setDimension ( 0, 0 );
    }
	return rc;
}

gddStatus gdd::clear(void)
{
	if(isFlat()||isManaged())
	{
		gddAutoPrint("gdd::clear()",gddErrorNotAllowed);
		return gddErrorNotAllowed;
	}

	if(isAtomic())
	{
		destroyData();
	}
	else if(isContainer())
	{
		gddContainer* cdd = (gddContainer*)this;
		gddCursor cur = cdd->getCursor();
		gdd *dd,*tdd;

		for(dd=cur.first();dd;)
		{
			tdd=dd;
			dd=cur.next();
			if(tdd->unreference()<0) delete tdd;
		}
        freeBounds();
	}

	//
	// this code clears out aitString and 
	// aitFixedString scalars (the doc says
    // that every field is set to invalid)
	//
	changeType(0,aitEnumInvalid);
    memset ( & this->data, '\0', sizeof ( this->data ) );

	return 0;
}

// Curently gives no indication of failure, which is bad.
// Obviously managed or flattened DDs cannot be redone.
// However, a DD that is within a managed or flattened container can
// use this to describe data - how's that for obscure
// This is required if the "value" is to be allowed within a container
// The "value" could be scalar or an array of unknown size.  The same is
// true of the enum strings and "units" attribute.

gddStatus gdd::reset(aitEnum prim, int dimen, aitIndex* cnt)
{
	int i;
	gddStatus rc;

	if((rc=clear())==0)
	{
        setPrimType(prim);
        setDimension(dimen);
		for(i=0;i<dimen;i++)
			setBound(i,0,cnt[i]);
	}
	return rc;
}

void gdd::get(aitString& d) const
{
	if(primitiveType()==aitEnumString)
	{
		aitString* s=(aitString*)dataAddress();
		d=*s;
	}
	else
		get(aitEnumString,&d);
}
void gdd::get(aitFixedString& d) const
{
	if(primitiveType()==aitEnumFixedString){
		strncpy(d.fixed_string,data.FString->fixed_string,
			sizeof(d));
		d.fixed_string[sizeof(d)-1u] = '\0';
	}
	else
		get(aitEnumFixedString,&d);
}

void gdd::getConvert(aitString& d) const
{
	get(aitEnumString,&d);
}

void gdd::getConvert(aitFixedString& d) const
{
	get(aitEnumFixedString,d.fixed_string);
}

gddStatus gdd::put(const aitString& d)
{
	gddStatus rc=0;
	if(isScalar())
	{
		//
		// destroy existing fixed string if it exists
		// and construct new aitString object
		//
		setPrimType(aitEnumString);
		aitString* s=(aitString*)dataAddress();
		*s=d;
	}
	else
	{
		gddAutoPrint("gdd::put(aitString&)",gddErrorNotAllowed);
		rc=gddErrorNotAllowed;
	}

	return rc;
}

gddStatus gdd::put(const aitFixedString& d)
{
	gddStatus rc=0;

	if(isScalar())
	{
		this->setPrimType(aitEnumFixedString);

		if (data.FString!=NULL)
			memcpy (data.FString->fixed_string, d.fixed_string, sizeof(d.fixed_string));
	}
	else
	{
		gddAutoPrint("gdd::put(aitString&)",gddErrorNotAllowed);
		rc=gddErrorNotAllowed;
	}
	return rc;
}

void gdd::putConvert(const aitString& d)
{
	set(aitEnumString,&d);
}

void gdd::putConvert(const aitFixedString& d)
{
	set(aitEnumFixedString,(void*)d.fixed_string);
}

// copy each of the strings into this DDs storage area
gddStatus gdd::put(const aitString* const d)
{
	return genCopy(aitEnumString,d);
}

// copy each of the strings into this DDs storage area
gddStatus gdd::put(const aitFixedString* const d)
{
	gddStatus rc=0;

	if(isAtomic())
		if(dataPointer())
			aitConvert(primitiveType(),dataPointer(),aitEnumFixedString,d,
				getDataSizeElements());
		else
			genCopy(aitEnumFixedString,d);
	else
	{
		gddAutoPrint("gdd::put(const aitFixedString*const)",gddErrorNotAllowed);
		rc=gddErrorTypeMismatch;
	}

	return rc;
}

gddStatus gdd::putRef(const gdd*)
{
	gddAutoPrint("gdd::putRef(const gdd*) - NOT IMPLEMENTED",
		gddErrorNotSupported);
	return gddErrorNotSupported;
}

gddStatus gdd::put ( const gdd * dd )
{    
    if ( this->isScalar() && dd->isScalar() )
    {
        // this is the simple case - just make this scalar look like the other
        this->set(dd->primitiveType(),dd->dataVoid());
    }
    else if ( isContainer() || dd->isContainer() )
    {
        gddAutoPrint("gdd::put(const gdd*)",gddErrorNotSupported);
        return gddErrorNotSupported;
    }
    else if ( this->dimension() > 1 || dd->dimension() > 1 )
    {
        // sorry, no support currently for multidimensional arrays
        return gddErrorOutOfBounds;
    }
    else if ( this->isScalar() ) // dd must be atomic if this is true
    {
        this->set ( dd->primitiveType(), dd->dataPointer() );
    }
    // at this point this GDD must be atomic 
    // and the src gdd is either atomic or scalar
    else {
        // this must be single dimensional atomic at this point

        // dd can be scaler or single dimensional atomic at this point
        // so fetch the bounds carefully
        aitUint32 srcFirst;
        aitUint32 srcElemCount;
        if ( dd->isScalar() ) {
            srcFirst = 0;
            srcElemCount = 1;
        }
        else {
            srcFirst = dd->getBounds()->first();
            srcElemCount = dd->getBounds()->size();
        }

        // clip to lower limit of source
        aitUint32 srcCopyFirst;
        if ( this->getBounds()->first () > srcFirst ) {
            srcCopyFirst = this->getBounds()->first();
        }
        else {
            srcCopyFirst = srcFirst;
        }
    
        // clip to upper limit of source
        aitUint32 srcCopySize;
        const aitUint32 unusedSrcBelow = srcCopyFirst - srcFirst;
        if ( srcElemCount <= unusedSrcBelow ) {
            return gddErrorOutOfBounds;
        }

        aitUint32 srcAvailSize = srcElemCount - unusedSrcBelow;
        if ( srcAvailSize > this->getBounds()->size() ) {
            srcCopySize = this->getBounds()->size();
        }
        else {
            srcCopySize = srcAvailSize;
        }

        if ( dataVoid() == NULL )
        {
            if (primitiveType()==aitEnumInvalid) {
                setPrimType (dd->primitiveType());
            }
            if ( primitiveType()==aitEnumString ) {
                aitString * pStrVec = new aitString [ srcCopySize ];
                if( ! pStrVec ) {
                    return gddErrorNewFailed;
                }
                destruct = new gddAitStringDestructor;
                if ( destruct ) {
                    destruct->reference();
                    setData ( pStrVec );
                }
                else {
                    delete [] pStrVec;
                    gddAutoPrint("gdd::copyData(const gdd*)",gddErrorNewFailed);
                    return gddErrorNewFailed;
                }
            }
            else {
                size_t sz = srcCopySize * aitSize[primitiveType()];
                
                // allocate a data buffer for the user
                aitUint8 * arr = new aitUint8[sz];
                if( ! arr ) {
                    return gddErrorNewFailed;
                }
                destruct=new gddAitUint8Destructor;
                if (destruct!=NULL) {
                    destruct->reference();
                    setData(arr);
                }
                else {
                    delete [] arr;
                    gddAutoPrint("gdd::copyData(const gdd*)",gddErrorNewFailed);
                    return gddErrorNewFailed;
                }
            }

            // the rule is that if storage is not preallocated then its ok
            // for the dest bounds to shrink to match the original dest 
            // bounds intersection with the source data bounds
            for ( unsigned i = 0; i < this->dimension(); i++ ) {
                if ( i == 0 ) {
                    this->setBound ( i, srcCopyFirst, srcCopySize );
                }
                else {
                    this->setBound ( i, 0, 1 );
                }
            }
        }

        aitUint8* pDst = (aitUint8*) this->dataPointer();
        assert ( srcCopyFirst >= this->getBounds()->first() );
        const aitUint32 unusedDstLow = srcCopyFirst - this->getBounds()->first();
        if ( unusedDstLow > 0 ) {
            //
            // zero portions that dont match
            // (should eventually throw an exception ?)
            //
            aitUint32 byteCount = aitSize[primitiveType()] * unusedDstLow;
            memset (pDst, '\0', byteCount);
            pDst += byteCount;
        }
        
        aitUint8* pSrc = (aitUint8*) dd->dataVoid();
        pSrc += aitSize[dd->primitiveType()] * unusedSrcBelow;
        int gddStatus = aitConvert (this->primitiveType(), pDst, 
            dd->primitiveType(), pSrc, srcCopySize);
        if ( gddStatus < 0 ) {
            return gddErrorTypeMismatch;
        }
        
        assert ( this->getBounds()->size() >= srcCopySize + unusedDstLow );
        const aitUint32 unusedDstHigh = this->getBounds()->size() - ( srcCopySize + unusedDstLow );
        if ( unusedDstHigh > 0 ) {
            pDst += aitSize[primitiveType()] * srcCopySize;
            //
            // zero portions that dont match
            // (should eventually throw an exception ?)
            //
            aitUint32 byteCount = aitSize[primitiveType()] * unusedDstHigh;
            memset (pDst, '\0', byteCount);
        }
    }
    
    setStatSevr(dd->getStat(),dd->getSevr());
    aitTimeStamp ts;
    dd->getTimeStamp(&ts);
    setTimeStamp(&ts);
    
    return 0; // success
}

size_t gdd::outHeader(void* buf,aitUint32 bufsize) const
{
	// simple encoding for now..  will change later
	// this is the SLOW, simple version

	aitUint8* b = (aitUint8*)buf;
	aitUint8* app = (aitUint8*)&appl_type;
	aitUint8* stat = (aitUint8*)&status;
	aitUint8* ts_sec = (aitUint8*)&time_stamp.tv_sec;
	aitUint8* ts_nsec = (aitUint8*)&time_stamp.tv_nsec;
	size_t i,j,sz;
	aitIndex ff,ss;
	aitUint8 *f,*s;

	// verify that header will fit into buffer first
	sz=4+sizeof(status)+sizeof(time_stamp)+sizeof(appl_type)+
		sizeof(prim_type)+sizeof(dim)+(dim*sizeof(gddBounds));

	if(sz>bufsize) return 0; // blow out here!

	*(b++)='H'; *(b++)='E'; *(b++)='A'; *(b++)='D';

	// how's this for putrid
	*(b++)=dim;
	*(b++)=prim_type;

	if(aitLocalNetworkDataFormatSame)
	{
		*(b++)=app[0]; *(b++)=app[1];
		for(i=0;i<sizeof(status);i++) *(b++)=stat[i];
		for(i=0;i<sizeof(time_stamp.tv_sec);i++) *(b++)=ts_sec[i];
		for(i=0;i<sizeof(time_stamp.tv_nsec);i++) *(b++)=ts_nsec[i];
	}
	else
	{
		*(b++)=app[1]; *(b++)=app[0];
		i=sizeof(status)-1u; do { *(b++)=stat[i]; } while(i-->0u);
		i=sizeof(time_stamp.tv_sec)-1u; do { *(b++)=ts_sec[i]; } while(i-->0u);
		i=sizeof(time_stamp.tv_nsec)-1u; do { *(b++)=ts_nsec[i]; } while(i-->0u);
	}

	// put out the bounds info
	for(j=0;j<dim;j++)
	{
		ff=bounds[j].first(); f=(aitUint8*)&ff;
		ss=bounds[j].size(); s=(aitUint8*)&ss;
		if(aitLocalNetworkDataFormatSame)
		{
			for(i=0;i<sizeof(aitIndex);i++) *(b++)=s[i];
			for(i=0;i<sizeof(aitIndex);i++) *(b++)=f[i];
		}
		else
		{
			i=sizeof(aitIndex)-1u; do { *(b++)=s[i]; } while(i-->0u);
			i=sizeof(aitIndex)-1u; do { *(b++)=f[i]; } while(i-->0u);
		}
	}
	return sz;
}
size_t gdd::outData(void* buf,aitUint32 bufsize, aitEnum e, aitDataFormat f) const
{
	// put data into user's buffer in the format that the user wants (e/f).
	// if e is invalid, then use whatever format this gdd describes.

	aitUint32 sz = getDataSizeElements();
	aitUint32 len = getDataSizeBytes();
	aitEnum type=(e==aitEnumInvalid)?primitiveType():e;

	if(len>bufsize) return 0; // blow out early

	if(sz>0)
	{
		if(f==aitLocalDataFormat)
			aitConvert(type,buf,primitiveType(),dataVoid(),sz);
		else
			aitConvertToNet(type,buf,primitiveType(),dataVoid(),sz);
	}

	return len;
}
size_t gdd::out(void* buf,aitUint32 bufsize,aitDataFormat f) const
{
	size_t index = outHeader(buf,bufsize);
	size_t rc;

	if(index>0)
		rc=outData(((char*)buf)+index,bufsize-index,aitEnumInvalid,f)+index;
	else
		rc=0;

	return rc;
}

size_t gdd::inHeader(void* buf)
{
	// simple encoding for now..  will change later
	// this is the SLOW, simple version

	aitUint16 inapp;
	aitUint8 inprim;
	aitUint8 indim;

	aitUint8* b = (aitUint8*)buf;
	aitUint8* b1 = b;
	aitUint8* app = (aitUint8*)&inapp;
	aitUint8* stat = (aitUint8*)&status;
	aitUint8* ts_sec = (aitUint8*)&time_stamp.tv_sec;
	aitUint8* ts_nsec = (aitUint8*)&time_stamp.tv_nsec;
	size_t i,j;
	aitIndex ff,ss;
	aitUint8 *f,*s;

	if(strncmp((char*)b,"HEAD",4)!=0) return 0;
	b+=4;

	indim=*(b++);
	inprim=*(b++);

	if(aitLocalNetworkDataFormatSame)
	{
		app[0]=*(b++); app[1]=*(b++);
		init(inapp,(aitEnum)inprim,indim);
		for(i=0u;i<sizeof(status);i++) stat[i]=*(b++);
		for(i=0u;i<sizeof(time_stamp.tv_sec);i++) ts_sec[i]=*(b++);
		for(i=0u;i<sizeof(time_stamp.tv_nsec);i++) ts_nsec[i]=*(b++);
	}
	else
	{
		app[1]=*(b++); app[0]=*(b++);
		init(inapp,(aitEnum)inprim,indim);
		i=sizeof(status)-1u; do { stat[i]=*(b++); } while(i-->0u);
		i=sizeof(time_stamp.tv_sec)-1u; do { ts_sec[i]=*(b++); } while(i-->0u);
		i=sizeof(time_stamp.tv_nsec)-1u; do { ts_nsec[i]=*(b++); } while(i-->0u);
	}

	// read in the bounds info
	f=(aitUint8*)&ff;
	s=(aitUint8*)&ss;
	
	for(j=0u;j<dim;j++)
	{
		if(aitLocalNetworkDataFormatSame)
		{
			for(i=0;i<sizeof(aitIndex);i++) s[i]=*(b++);
			for(i=0;i<sizeof(aitIndex);i++) f[i]=*(b++);
		}
		else
		{
			i=sizeof(aitIndex)-1u; do { s[i]=*(b++); } while(i-->0u);
			i=sizeof(aitIndex)-1u; do { f[i]=*(b++); } while(i-->0u);
		}
		bounds[j].setFirst(ff);
		bounds[j].setSize(ss);
	}
	return (size_t)(b-b1);
}
size_t gdd::inData(void* buf,aitUint32 tot, aitEnum e, aitDataFormat f)
{
	size_t rc;

	// Get data from a buffer and put it into this gdd.  Lots of rules here.
	// 1) tot is the total number of elements to copy from buf to this gdd.
	// * if tot is zero, then use the element count described in the gdd.
	// * if tot is not zero, then set the gdd up as a 1 dimensional array
	//   with tot elements in it.
	// 2) e is the primitive data type of the incoming data.
	// * if e is aitEnumInvalid, then use the gdd primitive type.
	// * if e is valid and gdd primitive type is invalid, set the gdd
	//   primitive type to e.
	// * if e is valid and so is this gdd primitive type, then convert the
	//   incoming data from type e to gdd primitive type.

	// Bad error condition, don't do anything.
	if(e==aitEnumInvalid && primitiveType()==aitEnumInvalid)
		return 0;

	aitIndex sz=tot;
	aitEnum src_type=(e==aitEnumInvalid)?primitiveType():e;
	aitEnum dest_type=(primitiveType()==aitEnumInvalid)?e:primitiveType();

	// I'm not sure if this is the best way to do this.
	if(sz>0)
		reset(dest_type,dimension(),&sz);

	if(genCopy(src_type,buf,f)==0)
		rc=getDataSizeBytes();
	else 
		rc=0;

	return rc;
}
size_t gdd::in(void* buf, aitDataFormat f)
{
	size_t index = inHeader(buf);
	size_t rc;

	if(index>0)
		rc=inData(((char*)buf)+index,0,aitEnumInvalid,f)+index;
	else
		rc=0;

	return rc;

}

//
// rewrote this to properly construct/destruct
// scalar string types when the prim type changes
// joh 05-22-98
//
//
void gdd::setPrimType (aitEnum t)		
{
	//
	// NOOP if there is no change
	//
	if ( this->prim_type == t ) {
		return;
	}

	//
	// I (joh) assume that something needs to be done when
	// the primative type of a container changes. For now I
    // assuming that the gdd should be cleared. 
	//
    if(isContainer()) {
        this->clear();
    }

	//
	// run constructors/destructors for string data
	// if it is scalar
	//
	if (isScalar())
	{
		//
		// run destructors for existing string data
		//
		if(primitiveType()==aitEnumFixedString)
		{
			// aitString type could have destructors
            if ( destruct ) {
				destruct->destroy(dataPointer());
                destruct = 0;
            }
			else
				if (data.FString) delete data.FString;
		}
		else if(primitiveType()==aitEnumString)
		{
			// aitString type could have destructors
            if ( destruct ) {
				destruct->destroy(dataAddress());
                destruct = 0;
            }
			else
			{
				aitString* s = (aitString*)dataAddress();
				s->clear();
			}
		}

		//
		// run constructors for new string data types
		//
		if (t==aitEnumString) {
			aitString* str=(aitString*)dataAddress();
			str->init();
		}
		else if (t==aitEnumFixedString) {
			this->data.FString = new aitFixedString;
			memset ( this->data.FString, '\0', sizeof(aitFixedString) );
		}
        else {
			memset ( & this->data, '\0', sizeof(this->data) );
        }
	}

	//
	// I (joh) assume that Jim intended that
	// calling of the destructors for arrays of string 
	// data when the primitive type changes is handled 
	// by the application. Not sure - nothing was done
	// by Jim to take care of this as far as I can tell.
	//
	else if(isAtomic())
	{
        if ( dataPointer() && destruct ) {
			destruct->destroy(dataPointer());
		    destruct=NULL;
        }
		memset (&this->data, '\0', sizeof(this->data));
	}

	this->prim_type = t;
}

//
// gdd::indexDD()
//
// modified by JOH 4-23-99 so that the correct method
// is used if the container gdd is not organized
// as an array of GDDs in memory (i.e. its not flat)
//
const gdd* gdd::indexDD (aitIndex index) const
{
	aitIndex i;
	unsigned nElem;

	if (index==0u) {
		return this;
	}

	//
	// otherwise this had better be a container
	// we are indexing
	//
	assert (this->prim_type==aitEnumContainer);

	//
	// catch out of bounds index
	//
	nElem = getDataSizeElements();
	assert (index<=nElem);

	//
	// if the container GDD is "flat"
	//
	if (this->isFlat()) {
		return this + index;
	}

	//
	// otherwise linear search for it
	//
	gdd* dd = (gdd*) dataPointer();
	i = nElem;
	while (i>index) {
		dd=(gdd*)dd->next();
		i--;
	}
	return dd;
}

//
// gddAitUint8Destructor::run()
//
// special gddDestructor guarantees same form of new and delete
//
void gddAitUint8Destructor::run (void *pUntyped)
{
	aitUint8 *pui8 = (aitUint8 *) pUntyped;
	delete [] pui8;
}

//
// gddAitStringDestructor::run()
//
// special gddDestructor guarantees same form of new and delete
//
void gddAitStringDestructor::run (void *pUntyped)
{
	aitString *pStr = (aitString *) pUntyped;
	delete [] pStr;
}