#ifndef _CDEV_CLASS_DEFINITION_H_
#define _CDEV_CLASS_DEFINITION_H_

#ifndef _CDEV_DIRECTORY_TABLE_H_
	#error "You must include cdevDirectoryTable.h to load cdevClassDefinition.h"
#endif

// *****************************************************************************
// * class cdevClassDefinition :
// *	This class stores the definition of a single CDEV DDL class and all
// *	of its associated verbs, attributes and messages.
// * 
// *	This class maintains a variety of internal data items for the following
// *	 purposes...
// * 
// *	directory   - This is the cdevDirectoryTable that the class definition 
// *                  is a member of...
// * 
// *	name        - This is the name of the class as defined in the CDEV DDL
// *                  file.
// * 
// *    verbs       - This is a list of cdevElementDefinitions that identify
// *	              each verb that was defined within the class definition.
// * 
// *    attributes  - This is a list of cdevElementDefinitions that identify
// *                  each attribute that was defined within the class 
// *                  definition.
// * 
// *    messages    - This is a list of cdevElementDefinitions that identify 
// *	              each messages that was defined within the class defintion.
// * 
// * 	parent      - This is the class definition for the class that this one
// *	              inherited from - if any.
// * 
// *    deviceHead  - This is a list of device definitions for all devices that
// *    deviceTail    were created from this class.
// * 
// *	redirector  - This is a table of all complete messages that this class
// *                  will support.  This table is only generated if devices are
// *                  instanciated from the class - and it includes the message
// *                  contents from all parent classes.
// * 
// *    next        - This is the next class definition that occurs... This list
// *                  is maintained in the cdevDirectoryTable object.
// *****************************************************************************
class cdevClassDefinition 
{
private:
	cdevDirectoryTable    & directory;		
	cdevClassDefinition   * next;		
	char                  * name;		
	cdevElementDefinition * verbs;		
	cdevElementDefinition * attributes;	
	cdevElementDefinition * messages;	
	cdevClassDefinition   * parent;		
	cdevDeviceDefinition  * deviceHead;	
	cdevDeviceDefinition  * deviceTail;
	StringHash              redirector;	
	
public:
	inline cdevClassDefinition(cdevDirectoryTable   &Master,
				  char                  *Name       = NULL, 
				  cdevClassDefinition   *Parent     = NULL,
				  cdevElementDefinition *Verbs      = NULL, 
				  cdevElementDefinition *Attributes = NULL, 
				  cdevElementDefinition *Messages   = NULL);
	inline ~cdevClassDefinition ( void );
	inline int  addElement   (cdevElementDefinition *&target,
				  cdevElementDefinition * element );
	inline int  addElement   (cdevElementDefinition *& target,
				  char                  *  eleName,
				  cdevServiceDefinition *  service,
				  char                  ** serviceData,
				  int                      nItems);
	inline int  addDevice    (char * device, char * substName = NULL );
	inline int  addVerb      (char * eleName, cdevServiceDefinition *service, char ** serviceData, int nItems );
	inline int  addVerb      (cdevElementDefinition * element );
	inline int  addAttribute (char * eleName, cdevServiceDefinition *service, char ** serviceData, int nItems );
	inline int  addAttribute (cdevElementDefinition * element );
	inline int  addMessage   (char * eleName, cdevServiceDefinition *service, char ** serviceData, int nItems );
	inline int  addMessage   (cdevElementDefinition * element );
	inline int  isA          (char * className );
	inline void asciiDump    (FILE * fp = stdout );
	inline void asciiDumpInstances     ( FILE * fp = stdout );
	inline void asciiDumpRedirector    ( FILE * fp = stdout );
	inline void createRedirectionTable ( void );

	// *********************************************************************
	// * Member access functions:
	// *********************************************************************
	inline char                  * getName       ( void );
	inline cdevDirectoryTable    & getDirectory  ( void );
	inline cdevClassDefinition   * getParent     ( void ); 
	inline cdevElementDefinition * getVerbs      ( void );
	inline cdevElementDefinition * getAttributes ( void );
	inline cdevElementDefinition * getMessages   ( void );
	inline cdevDeviceDefinition  * getDevices    ( void );
	inline StringHash            & getRedirector ( void );
	inline int                     getElements   ( cdevDirectoryTable::ElementType type,
						       cdevElementDefinition       ** &def, 
						       int                            &nItems );
	inline cdevClassDefinition   * getNext       ( void );
	inline void                    setNext       ( cdevClassDefinition * Next );	

};


// *****************************************************************************
// * cdevClassDefinition::cdevClassDefinition   :
// *	This is the constructor for the class definition object.  I
// *****************************************************************************
inline cdevClassDefinition::cdevClassDefinition  
	( cdevDirectoryTable    &Master,
	  char                  *Name, 
	  cdevClassDefinition   *Parent,
	  cdevElementDefinition *Verbs, 
	  cdevElementDefinition *Attributes, 
	  cdevElementDefinition *Messages)
	: directory  (Master),
	  name       (Name), 
	  parent     (Parent), 
	  verbs      (Verbs), 
	  attributes (Attributes), 
	  messages   (Messages),
	  deviceHead (NULL),
	  deviceTail (NULL),
	  next       (NULL)
	{
	}

// *****************************************************************************
// * cdevClassDefinition::~cdevClassDefinition  :
// *	This is the descructor for the cdevClassDefinition object.  It will 
// *	delete the class name and each item from the elements list.
// *****************************************************************************
inline cdevClassDefinition::~cdevClassDefinition ( void )
	{
	cdevElementDefinition    * ptr;
	cdevDeviceDefinition     * dPtr;
	cdevRedirectorDefinition * rPtr;
	StringHashIterator         iter(&redirector);
	
	delete name;

	while(verbs!=NULL)
		{
		ptr   = verbs;
		verbs = verbs->getNext();
		delete ptr;
		}
	while(messages!=NULL)
		{
		ptr      = messages;
		messages = messages->getNext();
		delete ptr;
		}
	while(attributes!=NULL)
		{
		ptr        = attributes;
		attributes = attributes->getNext();
		delete ptr;
		}	
	while(deviceHead!=NULL)
		{
		dPtr       = deviceHead;
		deviceHead = deviceHead->getNext();
		directory.getDeviceHash().remove(dPtr->getName());
		delete dPtr;
		}	
	for(iter.first(); (rPtr = (cdevRedirectorDefinition *)iter.data())!=NULL; )
		{
		iter++;
		redirector.remove(rPtr->getName());
		delete rPtr;
		}
	}

// *****************************************************************************
// * cdevClassDefinition::addElement :
// *	This method is used to add an element (verb, attribute, or message) to
// *	the cdevClassDefinition. The target parameter is a reference to the 
// *	list that will receive the incoming element.
// *****************************************************************************
inline int cdevClassDefinition::addElement
	( cdevElementDefinition *&target,
	  cdevElementDefinition * element )
	{
	cdevElementDefinition *curr, *prev;
	int                    result = CDEV_SUCCESS;
	
	for(curr=target, prev=NULL; 
	    curr!=NULL && strcmp(curr->getName(), element->getName()); 
	    curr=curr->getNext())
	    	{
	    	prev = curr;
	    	}
	if(curr == NULL)
		{
		if(prev) prev->setNext(new cdevElementDefinition(element));
		else     target = new cdevElementDefinition(element);
		}
	else result = CDEV_ERROR;
	return result;
	}
	
// *****************************************************************************
// * cdevClassDefinition::addElement :
// *	This method will create a new element and add it to the list of elements
// *	that is reference by the target paremeter.
// *****************************************************************************
inline int cdevClassDefinition::addElement
	       (cdevElementDefinition *& target,
                char                  *  eleName,
                cdevServiceDefinition *  service,
                char                  ** serviceData,
                int                      nItems)
	{
	cdevElementDefinition *curr, *prev;
	int                    result = CDEV_SUCCESS;
	
	for(curr=target, prev=NULL; 
	    curr!=NULL && strcmp(curr->getName(), eleName); 
	    curr=curr->getNext())
	    	{
	    	prev = curr;
	    	}
	if(curr == NULL)
		{
		if(prev) prev->setNext(new cdevElementDefinition(eleName, service, serviceData, nItems));
		else     target = new cdevElementDefinition(eleName, service, serviceData, nItems);
		}
	else result = CDEV_ERROR;
	return result;
	}

// *****************************************************************************
// * cdevClassDefinition::addDevice  :
// *	This method will add a new device to the device list.  This device name
// *	will also be placed in the hashTable in the cdevDirectoryTable object
// *	specified by directory.  
// * 
// *	Note the device name becomes the property of the cdevDeviceDefinition
// *	class and should not be deleted.
// * 
// *	The redirection table for this device will also be created as the
// *	first device is instanciated.
// *****************************************************************************
inline int cdevClassDefinition::addDevice ( char * device, char * substName )
	{
	int result = CDEV_SUCCESS;

	if(device!=NULL && directory.getDeviceHash().find(device)==NULL)
		{
		cdevDeviceDefinition * def = 
			new cdevDeviceDefinition(directory, device, substName, *this);

		if(deviceTail==NULL)
			{
			deviceHead = def;
			deviceTail = def;
			createRedirectionTable();
			directory.addClassInstance(this);
			}
		else	{
			deviceTail->setNext( def );
			deviceTail = def;
			}

		directory.addDevice(def);
		}
	else result = CDEV_ERROR;

	return result;
	}
	
// *****************************************************************************
// * cdevClassDefinition::addVerb    :
// *	This method will add a verb to the verbs element definition list.
// *****************************************************************************
inline int cdevClassDefinition::addVerb
	( char * eleName, cdevServiceDefinition *service, char ** serviceData, int nItems )
	{
	return addElement(verbs, eleName, service, serviceData, nItems);
	}

// *****************************************************************************
// * cdevClassDefinition::addVerb  :
// *	This method will add a verb to the verbs element definition list.
// *****************************************************************************
inline int cdevClassDefinition::addVerb ( cdevElementDefinition * element )
	{
	return addElement(verbs, element);
	}
	
// *****************************************************************************
// * cdevClassDefinition::addAttribute    :
// *	This method will add an attribute to the attributes element 
// *	definition list.
// *****************************************************************************
inline int cdevClassDefinition::addAttribute
	( char * eleName, cdevServiceDefinition * service, char ** serviceData, int nItems )
	{
	return addElement(attributes, eleName, service, serviceData, nItems);
	}

// *****************************************************************************
// * cdevClassDefinition::addAttribute  :
// *	This method will add an attribute to the attributes element 
// *	definition list.
// *****************************************************************************
inline int cdevClassDefinition::addAttribute ( cdevElementDefinition * element )
	{
	return addElement(attributes, element);
	}
	
// *****************************************************************************
// * cdevClassDefinition::addMessage    :
// *	This method will add a message to the messages element definition list.
// *****************************************************************************
inline int cdevClassDefinition::addMessage
	( char * eleName, cdevServiceDefinition * service, char ** serviceData, int nItems )
	{
	return addElement(messages, eleName, service, serviceData, nItems);
	}

// *****************************************************************************
// * cdevClassDefinition::addMessage  :
// *	This method will add a message to the messages element definition list.
// *****************************************************************************
inline int cdevClassDefinition::addMessage ( cdevElementDefinition * element )
	{
	return addElement(messages, element);
	}
		
// *****************************************************************************
// * cdevClassDefinition::isA  :
// *	This method will ascend the class hierarchy attempting to locate a 
// *	class with the name specified in className.  It will return TRUE if this
// *	class is or inherits from the specified className, or FALSE if not.
// *****************************************************************************
inline int cdevClassDefinition::isA ( char * className )
	{
	int result;
	if(strcmp(name, className)==0)	result = 1;
	else if(parent!=NULL)           result = parent->isA(className);
	else                            result = 0;
	return result;
	}

// *****************************************************************************
// * cdevClassDefinition::asciiDump  :
// *	This method dumps the contents of the cdevClassDefinition to the user
// *	specified file descriptor.
// *****************************************************************************
inline void cdevClassDefinition::asciiDump ( FILE * fp )
	{
	if(name)
		{
		fprintf(fp, "\nclass %s", name);
		if(parent) fprintf(fp, " : %s", parent->name);
		fprintf(fp, "\n\t{\n");

		if(verbs!=NULL) verbs->asciiDumpList(fp, "verbs");
		if(attributes!=NULL) attributes->asciiDumpList(fp, "attributes");
		if(messages!=NULL) messages->asciiDumpList(fp, "messages");

		fprintf(fp, "\t}\n");
		}
	}


// *****************************************************************************
// * cdevClassDefinition::asciiDumpInstances  :
// *	This method dumps the instance data of the class definition to the 
// *	caller specified file descriptor.
// *****************************************************************************
inline void cdevClassDefinition::asciiDumpInstances ( FILE * fp )
	{
	if(deviceHead!=NULL)
		{
		cdevDeviceDefinition * device = deviceHead;
		
		fprintf(fp, "\n%s : \n", name);
		while(device!=NULL)
			{
			if(device->getName()!=device->getSubstituteName())
				{
				fprintf(fp, "\t%s {%s}\n", device->getName(), device->getSubstituteName());
				}
			else fprintf(fp, "\t%s\n", device->getName());
			device = device->getNext();
			}
		fprintf(fp, "\t;\n");
		}
	}


// *****************************************************************************
// * cdevClassDefinition::asciiDumpRedirector  :
// *	This method dumps the contents of the redirection table that is used
// *	to route messages to their intended service.
// *****************************************************************************
inline void cdevClassDefinition::asciiDumpRedirector ( FILE * fp )
	{
	StringHashIterator iter(&redirector);
	cdevRedirectorDefinition * def;	

	fprintf(fp, "\n/* Redirection table for class %s */\n", name);
	fprintf(fp, "class %s\n\t{\n\tmessages\n\t\t{\n", name);
	for(iter.first(); 
	   (def = (cdevRedirectorDefinition *)iter.data())!=NULL;
	   iter++) 
	   	{
	   	def->asciiDump(fp);
		}
	fprintf(fp, "\t\t}\n\t}\n");
	}


// *****************************************************************************
// * cdevClassDefinition::createRedirectionTable :
// *	This method will read the verbs, attributes and messages and will 
// *	generate a redirection table that will allow the cdevDirectoryTable
// *	to route requests to the correct service using the proper serviceData.
// *****************************************************************************
inline void cdevClassDefinition::createRedirectionTable ( void )
	{
	cdevRedirectorDefinition * def;
	cdevElementDefinition ** msgPtr, ** vrbPtr, **atrPtr;
	int                      msgCnt,    vrbCnt,   atrCnt;
	int                      msgIdx,    vrbIdx,   atrIdx;
	
	// *********************************************************************
	// * Get a pointer to all of the verbs that are in use by the class.
	// *********************************************************************
	getElements(cdevDirectoryTable::MESSAGE,   msgPtr, msgCnt);
	getElements(cdevDirectoryTable::VERB,      vrbPtr, vrbCnt);
	getElements(cdevDirectoryTable::ATTRIBUTE, atrPtr, atrCnt);
	
	// *********************************************************************
	// * Process through all of the messages and add them to the 
	// * redirection list first.  Display a warning if they are already
	// * present.
	// *********************************************************************
	for(msgIdx=0; msgIdx<msgCnt; msgIdx++)
		{
		if(msgPtr[msgIdx]->getName() && msgPtr[msgIdx]->getService())
			{
			if(redirector.find(msgPtr[msgIdx]->getName())!=NULL)
				{
				cdevReportError(CDEV_SEVERITY_INFO, "CDEV Directory", NULL,
						"Message %s already defined for class %s",
						msgPtr[msgIdx]->getName(), name);
				}
			else	{
				def = new cdevRedirectorDefinition(strdup(msgPtr[msgIdx]->getName()), *msgPtr[msgIdx]);
				redirector.insert(def->getName(), def);
				}
			}
		}

	// *********************************************************************
	// * Walk through the verb list and combine them with each attribute... 
	// * For each verb that has a service associated with it, use the verbs
	// * element definition... If the verb does not have a service, then
	// * use the attributes element definition.
	// *********************************************************************
	for(vrbIdx=0; vrbIdx<vrbCnt; vrbIdx++)
		{
		if(vrbPtr[vrbIdx]->getName())
			{
			// *****************************************************
			// * Using the verbs service.
			// *****************************************************
			if(vrbPtr[vrbIdx]->getService())
				{
				for(atrIdx=0; atrIdx<atrCnt; atrIdx++)
					{
					if(atrPtr[atrIdx]->getName()!=NULL)
						{
						char * temp = new char[strlen(vrbPtr[vrbIdx]->getName())+strlen(atrPtr[atrIdx]->getName())+2];
						sprintf(temp, "%s %s", vrbPtr[vrbIdx]->getName(), atrPtr[atrIdx]->getName());
						if(redirector.find(temp)!=NULL)
							{
							cdevReportError(CDEV_SEVERITY_INFO, "CDEV Directory", NULL,
								"Message %s already defined for class %s",
								temp, name);
							delete temp;
							}
						else	{
							def = new cdevRedirectorDefinition(temp, *vrbPtr[vrbIdx]);
							redirector.insert(def->getName(), def);
							}
						}
					}
				}
			// *****************************************************
			// * Using the attributes service.
			// *****************************************************
			else for(atrIdx=0; atrIdx<atrCnt; atrIdx++)
				{
				if(atrPtr[atrIdx]->getName() && atrPtr[atrIdx]->getService())
					{
					char * temp = new char[strlen(vrbPtr[vrbIdx]->getName())+strlen(atrPtr[atrIdx]->getName())+2];
					sprintf(temp, "%s %s", vrbPtr[vrbIdx]->getName(), atrPtr[atrIdx]->getName());
					if(redirector.find(temp)!=NULL)
						{
						cdevReportError(CDEV_SEVERITY_INFO, "CDEV Directory", NULL,
								"Message %s already defined for class %s",
								temp, name);
						delete temp;
						}
					else	{
						def = new cdevRedirectorDefinition(temp, *atrPtr[atrIdx]);
						redirector.insert(def->getName(), def);
						}
					}
				else	{
					cdevReportError(CDEV_SEVERITY_ERROR, "CDEV Directory", NULL,
							"Neither the verb nor the message for \"%s %s\" has a service",
							vrbPtr[vrbIdx]->getName(), atrPtr[atrIdx]->getName());
					}
				}
			}
		}

	// *********************************************************************
	// * Release the memory used to store the pointers.
	// *********************************************************************
	if(msgPtr) delete msgPtr;
	if(vrbPtr) delete vrbPtr;
	if(atrPtr) delete atrPtr;
	}
	

// *****************************************************************************
// * cdevClassDefinition::getElements :
// * 	This method allows the caller to retrieve a list of all element 
// *	definitions of a particular type from all subclasses of the current 
// *	class.
// *****************************************************************************
inline int cdevClassDefinition::getElements ( cdevDirectoryTable::ElementType type,
					      cdevElementDefinition        ** &def, 
					      int                             &nItems )
	{
	StringHash            tempHash;
	cdevClassDefinition * classDef = this;
	
	def    = NULL;
	nItems = 0;
	
	do
		{
		cdevElementDefinition * el = 
			type==cdevDirectoryTable::VERB?classDef->verbs:
			(type==cdevDirectoryTable::ATTRIBUTE?classDef->attributes:
			classDef->messages);

		for(; el!=NULL; el = el->getNext())
			{
			if(tempHash.find(el->getName())==NULL)
				{
				tempHash.insert(el->getName(), el);
				nItems++;
				}
			}
		classDef = classDef->parent;
		} while(classDef!=NULL);

	if(nItems!=0)
		{
		StringHashIterator iter(&tempHash);

		def    = new cdevElementDefinition * [nItems];
		nItems = 0;

		for(iter.first(); iter.key()!=NULL; iter++)
			{
			def[nItems++] = (cdevElementDefinition *)iter.data();
			}
		}

	return nItems;
	}					


// *****************************************************************************
// * cdevClassDefinition::getName :
// * This method allows the caller to retrieve the name of the class.
// *****************************************************************************
inline char * cdevClassDefinition::getName ( void )
	{
	return name;
	}

 
// *****************************************************************************
// * cdevClassDefinition:: :
// * 	This method allows the caller to retrieve the directory table that
// *	owns this device.
// *****************************************************************************
inline cdevDirectoryTable & cdevClassDefinition::getDirectory ( void )
	{
	return directory;
	}

 
// *****************************************************************************
// * cdevClassDefinition::getParent :
// * 	This method allows the caller to retrieve the class definition that
// *	this class inherits from.
// *****************************************************************************
inline cdevClassDefinition * cdevClassDefinition::getParent ( void )
	{
	return parent;
	}
 
 
// *****************************************************************************
// * cdevClassDefinition::getVerbs :
// * 	This method allows the caller to retrieve the lement definition list 
// *	containing all of the classes verbs.
// *****************************************************************************
inline cdevElementDefinition * cdevClassDefinition::getVerbs ( void )
	{
	return verbs;
	}

 
// *****************************************************************************
// * cdevClassDefinition::getAttributes :
// * 	This method allows the caller to retrieve the element definition list
// *	containing all of the classes verbs.
// *****************************************************************************
inline cdevElementDefinition * cdevClassDefinition::getAttributes ( void )
	{
	return attributes;
	}


 
// *****************************************************************************
// * cdevClassDefinition::getMessages :
// * 	This method allows the caller to retrieve the element definition list
// *	containing all of the classes messages.
// *****************************************************************************
inline cdevElementDefinition * cdevClassDefinition::getMessages ( void )
	{
	return messages;
	}

 
// *****************************************************************************
// * cdevClassDefinition::getDevices :
// * 	This method allows the caller to retrieve the device definition list
// *	containing all of the instances of the class.
// *****************************************************************************
inline cdevDeviceDefinition * cdevClassDefinition::getDevices ( void )
	{
	return deviceHead;
	}

 
// *****************************************************************************
// * cdevClassDefinition::getRedirector :
// * 	This method allows the caller to retrieve the redirection list for
// *	the class.
// *****************************************************************************
inline StringHash & cdevClassDefinition::getRedirector ( void )
	{
	return redirector;
	}

 
// *****************************************************************************
// * cdevClassDefinition::getNext :
// * 	This method allows the caller to retrieve the next class definition in
// *	the list.
// *****************************************************************************
inline cdevClassDefinition * cdevClassDefinition::getNext ( void )
	{
	return next;
	}

 
// *****************************************************************************
// * cdevClassDefinition::setNext :
// * 	This method allows the caller to set the next class definition in the
// *	list.
// *****************************************************************************
inline void cdevClassDefinition::setNext ( cdevClassDefinition * Next )
	{
	next = Next;
	}
 

#endif /* _CDEV_CLASS_DEFINITION_H_ */