#ifndef hashkeyset_DEFINED
#define hashkeyset_DEFINED 1
 
#include <class.h>
/* 
 * This file was generated by the Andrew class system preprocessor.
 * Don't make changes to this file as it is created from hshkeyset.ch and will be
 * overwritten.  Make changes to hshkeyset.ch instead.
 */ 
 
/* 
 * The following information was copied, as-is, from hshkeyset.ch.
 */ 
 






/* 
 * End of information copied from hshkeyset.ch.
 */ 
 
/* 
 * Include the superclass information
 */ 
#define dontDefineRoutinesFor_keyset
#include "keyset.ih"
#undef dontDefineRoutinesFor_keyset

 
 
/* 
 * Data structure for hashkeyset 
 */ 
struct hashkeyset { 
    union {
	struct basicobject_methods *hashkeyset_methods;
	struct keyset keyset;
    } header;
    unsigned long (*hashFunction) (/* void *key */);
    unsigned long (*bucketFunction) (/* long hashValue */);
    unsigned long numberOfBuckets;
    unsigned long currentNumberOfBuckets;
    unsigned long bucketMask;
    boolean rehash;
    boolean rebucket;
    struct extendedlist **buckets;

};

 
/* 
 * End of data structure for hashkeyset.
 */ 
 


#ifndef hashkeyset_PROGRAMMERVERSION
#define hashkeyset_PROGRAMMERVERSION 1
#endif /* hashkeyset_PROGRAMMERVERSION */

#ifdef hashkeyset_VERSION
#undef hashkeyset_VERSION
#endif /* hashkeyset_VERSION */
#define hashkeyset_VERSION ((((hashkeyset_PROGRAMMERVERSION << 16) ^ (13 << 8) ^ sizeof(struct hashkeyset)) & 0x7ffff) + 0x80000 + (2 << 20))

#define hashkeyset_StaticLoadOnlyThisClass()  \
{ extern struct classinfo *hashkeyset__GetClassInfo(); \
  (void) class_EnterInfo(NULL, hashkeyset_classheader.name, hashkeyset__GetClassInfo, NULL, hashkeyset_classheader.namekey); } 
 
#define hashkeyset_StaticLoad()  \
    { \
    keyset_StaticLoad(); \
    hashkeyset_StaticLoadOnlyThisClass();  \
    } 
 
#define hashkeyset_StaticEntry  {hashkeyset_StaticLoad()} 
 
static struct classheader hashkeyset_classheader = {
    hashkeyset_VERSION,
    "hashkeyset",
    "hshkeyset",
    (struct basicobject_methods *) &class_RoutineStruct,
};


#endif /* hashkeyset_DEFINED */

#if !defined(hashkeyset_ROUTINESDEFINED) && !defined(dontDefineRoutinesFor_hashkeyset) && !defined(class_StaticEntriesOnly)
#define hashkeyset_ROUTINESDEFINED

#define hashkeyset_NumberOfElements(self) \
 ((&(self)->header.keyset)->numberOfElements)
#define hashkeyset_SetNumberOfElements(self,value) \
 ((&(self)->header.keyset)->numberOfElements = value)
#define hashkeyset_IncrementNumberOfElements(self) \
 ((&(self)->header.keyset)->numberOfElements++)
#define hashkeyset_DecrementNumberOfElements(self) \
 ((&(self)->header.keyset)->numberOfElements--)
#define hashkeyset_SetCompareFunction(self,comparefunc) \
 ((&(self)->header.keyset)->compare = comparefunc)
#define hashkeyset_SetKeyCopyFunction(self,copyfunc) \
 ((&(self)->header.keyset)->keycopy = copyfunc)
#define hashkeyset_SetKeyFreeFunction(self,freefunc) \
 ((&(self)->header.keyset)->keyfree = freefunc)
#define hashkeyset_SetValueCopyFunction(self,copyfunc) \
 ((&(self)->header.keyset)->valuecopy = copyfunc)
#define hashkeyset_SetValueFreeFunction(self,freefunc) \
 ((&(self)->header.keyset)->valuefree = freefunc)
#define hashkeyset_GetCompareFunction(self) \
 ((&(self)->header.keyset)->compare)
#define hashkeyset_GetKeyCopyFunction(self) \
 ((&(self)->header.keyset)->keycopy)
#define hashkeyset_GetKeyFreeFunction(self) \
 ((&(self)->header.keyset)->keyfree)
#define hashkeyset_GetValueCopyFunction(self) \
 ((&(self)->header.keyset)->valuecopy)
#define hashkeyset_GetValueFreeFunction(self) \
 ((&(self)->header.keyset)->valuefree)
#define hashkeyset_Lookup(self,key,element) \
    ((* ((boolean (*)())((self)->header.hashkeyset_methods->routines[0]))) (self,key,element))
#define hashkeyset_Insert(self,key,element) \
    ((* ((void (*)())((self)->header.hashkeyset_methods->routines[1]))) (self,key,element))
#define hashkeyset_Remove(self,key,retKey,retValue) \
    ((* ((boolean (*)())((self)->header.hashkeyset_methods->routines[2]))) (self,key,retKey,retValue))
#define hashkeyset_Delete(self,key) \
    ((* ((void (*)())((self)->header.hashkeyset_methods->routines[3]))) (self,key))
#define hashkeyset_GetList(self,include,rock) \
    ((* ((struct extendedlist * (*)())((self)->header.hashkeyset_methods->routines[4]))) (self,include,rock))
#define hashkeyset_ForEach(self,stopfunc,rock) \
    ((* ((void * (*)())((self)->header.hashkeyset_methods->routines[5]))) (self,stopfunc,rock))
#define hashkeyset_Prune(self,include,rock) \
    ((* ((void (*)())((self)->header.hashkeyset_methods->routines[6]))) (self,include,rock))
#define hashkeyset_Clear(self) \
    ((* ((void (*)())((self)->header.hashkeyset_methods->routines[7]))) (self))
#define hashkeyset_SetString(self,copyKey,copyValue) \
    ((* ((void (*)())((self)->header.hashkeyset_methods->routines[8]))) (self,copyKey,copyValue))
#define hashkeyset_SetHashFunction(self,hashFunction) \
    ((* ((void (*)())((self)->header.hashkeyset_methods->routines[9]))) (self,hashFunction))
#define hashkeyset_SetBucketFunction(self,bucketFunction) \
    ((* ((void (*)())((self)->header.hashkeyset_methods->routines[10]))) (self,bucketFunction))
#define hashkeyset_SetNumberOfBuckets(self,numberOfBuckets) \
    ((* ((void (*)())((self)->header.hashkeyset_methods->routines[11]))) (self,numberOfBuckets))
#define hashkeyset_Rehash(self) \
    ((* ((void (*)())((self)->header.hashkeyset_methods->routines[12]))) (self))

#define hashkeyset_NewFromObject(self) \
    ((* ((struct hashkeyset * (*)())((self)->header.hashkeyset_methods->info->procs->routines[0]))) (&hashkeyset_classheader, (self)->header.hashkeyset_methods->info->versionnumber))
#define hashkeyset_New() \
    (hashkeyset__New(NULL, hashkeyset_VERSION))
#define hashkeyset_Initialize(self) \
    (hashkeyset__Initialize(NULL, self, hashkeyset_VERSION))

#define hashkeyset_Destroy(self) \
    ((* ((void (*)()) ((self)->header.hashkeyset_methods->info->procs->routines[1]))) (&hashkeyset_classheader, self))
#define hashkeyset_Finalize(self) \
    (hashkeyset__Finalize(NULL, self))

#define hashkeyset_InitializeObject(self) \
    ((boolean) hashkeyset__InitializeObject(NULL, self))
#define hashkeyset_FinalizeObject(self) \
    ((void) hashkeyset__FinalizeObject(NULL, self))
#define hashkeyset_KRHash(str) \
    ((unsigned long) hashkeyset__KRHash(NULL, str))


#endif /* !defined(hashkeyset_ROUTINESDEFINED) && !defined(dontDefineRoutinesFor_hashkeyset ) && !defined(class_StaticEntriesOnly)*/

#define super_NumberOfElements(self)  \
	   keyset_NumberOfElements((struct keyset *)self)
#define super_SetNumberOfElements(self,value)  \
	   keyset_SetNumberOfElements((struct keyset *)self,value)
#define super_IncrementNumberOfElements(self)  \
	   keyset_IncrementNumberOfElements((struct keyset *)self)
#define super_DecrementNumberOfElements(self)  \
	   keyset_DecrementNumberOfElements((struct keyset *)self)
#define super_SetCompareFunction(self,comparefunc)  \
	   keyset_SetCompareFunction((struct keyset *)self,comparefunc)
#define super_SetKeyCopyFunction(self,copyfunc)  \
	   keyset_SetKeyCopyFunction((struct keyset *)self,copyfunc)
#define super_SetKeyFreeFunction(self,freefunc)  \
	   keyset_SetKeyFreeFunction((struct keyset *)self,freefunc)
#define super_SetValueCopyFunction(self,copyfunc)  \
	   keyset_SetValueCopyFunction((struct keyset *)self,copyfunc)
#define super_SetValueFreeFunction(self,freefunc)  \
	   keyset_SetValueFreeFunction((struct keyset *)self,freefunc)
#define super_GetCompareFunction(self)  \
	   keyset_GetCompareFunction((struct keyset *)self)
#define super_GetKeyCopyFunction(self)  \
	   keyset_GetKeyCopyFunction((struct keyset *)self)
#define super_GetKeyFreeFunction(self)  \
	   keyset_GetKeyFreeFunction((struct keyset *)self)
#define super_GetValueCopyFunction(self)  \
	   keyset_GetValueCopyFunction((struct keyset *)self)
#define super_GetValueFreeFunction(self)  \
	   keyset_GetValueFreeFunction((struct keyset *)self)
#define super_Lookup(self,key,element)  \
    ((* ((boolean (*)()) (hashkeyset_supermethods->routines[0]))) (self,key,element))
#define super_Insert(self,key,element)  \
    ((* ((void (*)()) (hashkeyset_supermethods->routines[1]))) (self,key,element))
#define super_Remove(self,key,retKey,retValue)  \
    ((* ((boolean (*)()) (hashkeyset_supermethods->routines[2]))) (self,key,retKey,retValue))
#define super_Delete(self,key)  \
    ((* ((void (*)()) (hashkeyset_supermethods->routines[3]))) (self,key))
#define super_GetList(self,include,rock)  \
    ((* ((struct extendedlist * (*)()) (hashkeyset_supermethods->routines[4]))) (self,include,rock))
#define super_ForEach(self,stopfunc,rock)  \
    ((* ((void * (*)()) (hashkeyset_supermethods->routines[5]))) (self,stopfunc,rock))
#define super_Prune(self,include,rock)  \
    ((* ((void (*)()) (hashkeyset_supermethods->routines[6]))) (self,include,rock))
#define super_Clear(self)  \
    ((* ((void (*)()) (hashkeyset_supermethods->routines[7]))) (self))
#define super_SetString(self,copyKey,copyValue)  \
    ((* ((void (*)()) (hashkeyset_supermethods->routines[8]))) (self,copyKey,copyValue))

extern struct basicobject_methods *hashkeyset_supermethods;

#ifndef AUXMODULE

struct basicobject_methods *hashkeyset_supermethods;

struct hashkeyset_methods {
    struct classinfo *info;
    long (*routines[13])();
};

struct hashkeyset_classprocedures {
    struct classinfo *info;
    long (*routines[7])();
};

boolean hashkeyset__Lookup();
void hashkeyset__Insert();
boolean hashkeyset__Remove();
struct extendedlist * hashkeyset__GetList();
void * hashkeyset__ForEach();
void hashkeyset__Prune();
void hashkeyset__Clear();
void hashkeyset__SetString();
void hashkeyset__SetHashFunction();
void hashkeyset__SetBucketFunction();
void hashkeyset__SetNumberOfBuckets();
void hashkeyset__Rehash();

static struct hashkeyset_methods hashkeyset_methodtable = {
    NULL,
    (long (*)()) hashkeyset__Lookup,
    (long (*)()) hashkeyset__Insert,
    (long (*)()) hashkeyset__Remove,
    NULL,
    (long (*)()) hashkeyset__GetList,
    (long (*)()) hashkeyset__ForEach,
    (long (*)()) hashkeyset__Prune,
    (long (*)()) hashkeyset__Clear,
    (long (*)()) hashkeyset__SetString,
    (long (*)()) hashkeyset__SetHashFunction,
    (long (*)()) hashkeyset__SetBucketFunction,
    (long (*)()) hashkeyset__SetNumberOfBuckets,
    (long (*)()) hashkeyset__Rehash
};

struct hashkeyset *hashkeyset__New();
void hashkeyset__Destroy();
boolean hashkeyset__Initialize();
void hashkeyset__Finalize();
boolean hashkeyset__InitializeObject();
void hashkeyset__FinalizeObject();
unsigned long hashkeyset__KRHash();

static struct hashkeyset_classprocedures hashkeyset_classproceduretable = {
    NULL,
    (long (*)()) hashkeyset__New,
    (long (*)()) hashkeyset__Destroy,
    (long (*)()) hashkeyset__Initialize,
    (long (*)()) hashkeyset__Finalize,
    (long (*)()) hashkeyset__InitializeObject,
    (long (*)()) hashkeyset__FinalizeObject,
    (long (*)()) hashkeyset__KRHash
};


static struct classinfo hashkeyset_classinfo = {
    (struct basicobject_methods *) &hashkeyset_methodtable,
    (struct basicobject_methods *) &hashkeyset_classproceduretable,
    "hashkeyset",
    "hshkeyset",
    hashkeyset_VERSION,
    "keyset",
    "keyset",
    NULL,
    NULL,
    &hashkeyset_classheader,
    NULL,
    0
};

static int classinitialized = FALSE;

boolean hashkeyset__Initialize(classID, self, versionnumber)
struct classheader *classID;
struct hashkeyset *self;
unsigned long versionnumber;
{
    /* keyset_Initialize(self); */
    if(!(*((boolean (*)()) (keyset_classheader.classprocedures->routines[2])))(&keyset_classheader,self, keyset_VERSION))
	return FALSE;
    if (! classinitialized)  {
	classinitialized = TRUE;
	hashkeyset_supermethods =self->header.hashkeyset_methods;
	{
	    long (**p)() = &(hashkeyset_methodtable.routines[0]);
	    long (**q)() = &(self->header.hashkeyset_methods->routines[0]);
	    long i;

	    for (i = 0; i < 9; i++)  {
		if (*p == NULL)
		    *p = *q;
		p++;
		q++;
	    }
	}
	hashkeyset_classinfo.superclass = hashkeyset_supermethods->info;
	hashkeyset_methodtable.info = &hashkeyset_classinfo;
    }
    self->header.hashkeyset_methods = (struct basicobject_methods *) &hashkeyset_methodtable;
    if(!hashkeyset__InitializeObject(classID, self)){
	/* keyset_Finalize(self); */
	(*((void (*)()) (keyset_classheader.classprocedures->routines[3])))(&keyset_classheader,self);
	return FALSE;
    }
    return TRUE;
}

struct hashkeyset *hashkeyset__New(classID, versionnumber)
struct classheader *classID;
unsigned long versionnumber;
{
    struct hashkeyset *self;
    if (versionnumber != class_VERSIONNOTKNOWN && versionnumber != hashkeyset_VERSION)  {
	(void) fprintf(stderr, "Incompatible version of hashkeyset requested!\n");
    }
    self = (struct hashkeyset *) malloc (sizeof(struct hashkeyset));
    if (! self)  {
	(void) fprintf(stderr, "Could not allocate hashkeyset object!\n");
	return NULL;
    }
    if(!hashkeyset__Initialize(classID, self, versionnumber)){
	free((char *)self);
	return NULL;
    }
    return self;
}

void hashkeyset__Finalize(classID, self)
struct classheader *classID;
struct hashkeyset *self;
{
    hashkeyset__FinalizeObject(classID, self);
    /* keyset_Finalize(self); */
    (*((void (*)()) (keyset_classheader.classprocedures->routines[3])))(&keyset_classheader,self);
}

void hashkeyset__Destroy(classID, self)
struct classheader *classID;
struct hashkeyset *self;
{
    hashkeyset__Finalize(classID, self);
    free(self);
}

struct classinfo *hashkeyset__GetClassInfo(classID, versionnumber)
struct classheader *classID;
unsigned long versionnumber;
{
    if (versionnumber != class_VERSIONNOTKNOWN && versionnumber != hashkeyset_VERSION)  {
	(void) fprintf(stderr, "Incompatible version of hashkeyset requested!\n");
    }
    hashkeyset_classproceduretable.info = &hashkeyset_classinfo;
    return &hashkeyset_classinfo;
}

/* 
 * THIS IS NEEDED BECAUSE OF THE WAY makedo WORKS.
 * HOPEFULLY, IT CAN BE REMOVED SOON.
 */ 
 
struct classinfo *hshkeyset__GetClassInfo(classID, versionnumber)
struct classheader *classID;
unsigned long versionnumber;
{
    return hashkeyset__GetClassInfo(classID, versionnumber);
}
 
/* 
 * END OF THIS PATCH. 
 */ 
 
#endif /* AUXMODULE */