723 lines
23 KiB
C++
723 lines
23 KiB
C++
#ifndef _CDEV_DIRECTORY_TABLE_H_
|
|
#define _CDEV_DIRECTORY_TABLE_H_
|
|
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <cdevSystem.h>
|
|
#include <cdevErrCode.h>
|
|
#include <cdevError.h>
|
|
#include <StringHash.h>
|
|
|
|
#ifdef __VMS
|
|
typedef unsigned long u_long;
|
|
typedef unsigned short u_short;
|
|
#endif
|
|
|
|
|
|
class cdevElementDefinition;
|
|
class cdevClassDefinition;
|
|
class cdevServiceDefinition;
|
|
class cdevAliasDefinition;
|
|
class cdevDeviceDefinition;
|
|
class cdevCollectionDefinition;
|
|
|
|
int CDEV_CLASS_SPEC cdevReportError(int severity, char *name, void *, char *formatString, ...);
|
|
|
|
// *****************************************************************************
|
|
// * class cdevDirectoryTable :
|
|
// * This is the master class that is used to collect and maintain
|
|
// * information associated with the CDEV Device Definition Language file.
|
|
// *
|
|
// * This class maintains a number of tables and lists for the following
|
|
// * purposes...
|
|
// *
|
|
// * collectionClass - This is the single instance of the cdevClassDefinition
|
|
// * for the collection class.
|
|
// *
|
|
// * serviceHead - This is a list of all of the services that have been
|
|
// * serviceTail read from the DDL file in the order in which they
|
|
// * were loaded.
|
|
// *
|
|
// * classHead - This is a list of all of the classes that have been
|
|
// * classTail read from the DDL file in the order in which they
|
|
// * were loaded.
|
|
// *
|
|
// * aliasHead - This is a list of aliases that are defined within
|
|
// * aliasTail the DDL file.
|
|
// *
|
|
// * collectionHead - This is a list of collection devices that are
|
|
// * collectionTail defined within the DDL file.
|
|
// *
|
|
// * serviceHash - This is a hash table that allows for fast lookup of
|
|
// * each of the services that were loaded into the
|
|
// * service list.
|
|
// *
|
|
// * classHash - This is a hash table that allows fast lookup by name
|
|
// * of any of the classes that were loaded into the
|
|
// * class list.
|
|
// *
|
|
// * classInstanceHash - This is a hash table that contains only the names
|
|
// * and addresses of classes that have been used to
|
|
// * instanciate a device.
|
|
// *
|
|
// * deviceHash - This is a hash table that allows the caller to
|
|
// * quickly locate any device that has been defined in
|
|
// * the DDL file.
|
|
// *
|
|
// * collectionHash - This is a hash table that allows the caller to
|
|
// * quickly locate a collection device definition.
|
|
// *****************************************************************************
|
|
class CDEV_CLASS_SPEC cdevDirectoryTable
|
|
{
|
|
public:
|
|
static long BinaryMagic_1_4;
|
|
static long BinaryMagic_1_5;
|
|
static long BinaryMagic;
|
|
|
|
typedef enum {VERB=0, ATTRIBUTE, MESSAGE} ElementType;
|
|
|
|
private:
|
|
cdevClassDefinition * collectionClass;
|
|
|
|
cdevServiceDefinition * serviceHead;
|
|
cdevServiceDefinition * serviceTail;
|
|
cdevClassDefinition * classHead;
|
|
cdevClassDefinition * classTail;
|
|
cdevAliasDefinition * aliasHead;
|
|
cdevAliasDefinition * aliasTail;
|
|
cdevCollectionDefinition * collectionHead;
|
|
cdevCollectionDefinition * collectionTail;
|
|
StringHash serviceHash;
|
|
StringHash classHash;
|
|
StringHash classInstanceHash;
|
|
StringHash deviceHash;
|
|
StringHash collectionHash;
|
|
|
|
public:
|
|
inline cdevDirectoryTable ( void );
|
|
inline ~cdevDirectoryTable ( void );
|
|
|
|
inline int addService ( cdevServiceDefinition *def );
|
|
inline int addService ( char *name,
|
|
char **tags=NULL,
|
|
int nTags=0);
|
|
|
|
inline int addClass ( cdevClassDefinition *def );
|
|
inline int addClass ( char *name,
|
|
cdevClassDefinition *parent = NULL,
|
|
cdevElementDefinition *verbs = NULL,
|
|
cdevElementDefinition *attributes = NULL,
|
|
cdevElementDefinition *messages = NULL);
|
|
|
|
inline int addClassInstance ( cdevClassDefinition * def );
|
|
inline int addDevice ( cdevDeviceDefinition * def );
|
|
inline int addAlias ( cdevAliasDefinition * def );
|
|
inline int addAlias ( char * name, cdevDeviceDefinition & def );
|
|
inline int addCollection ( cdevCollectionDefinition * def );
|
|
inline int addCollection ( char * name, char ** devices, int nDevices );
|
|
|
|
inline void asciiDump ( FILE * fp = stdout );
|
|
inline void asciiDumpRedirector ( FILE * fp = stdout );
|
|
|
|
inline cdevServiceDefinition * findService ( char * name );
|
|
inline cdevClassDefinition * findClass ( char * name );
|
|
|
|
// *********************************************************************
|
|
// * Member access methods.
|
|
// *********************************************************************
|
|
inline cdevServiceDefinition * getServices ( void );
|
|
inline cdevClassDefinition * getClasses ( void );
|
|
inline cdevAliasDefinition * getAliases ( void );
|
|
inline StringHash & getServiceHash ( void );
|
|
inline StringHash & getClassHash ( void );
|
|
inline StringHash & getInstanceHash ( void );
|
|
inline StringHash & getDeviceHash ( void );
|
|
inline StringHash & getCollectionHash (void );
|
|
|
|
// *********************************************************************
|
|
// * External data load/dump methods.
|
|
// *********************************************************************
|
|
int load ( char * inputFile );
|
|
int asciiLoad ( char * inputFile );
|
|
int asciiBufferLoad ( char * buffer );
|
|
void binaryDump ( char * outputFile );
|
|
int binaryLoad ( char * inputFile );
|
|
int loadText ( char * includePath, char * filename, char * &buf, int &buflen, int &cursor);
|
|
void readServices ( char * buf );
|
|
void readClasses ( char * buf );
|
|
void readElements ( cdevClassDefinition &def, ElementType type, char *start, char *end );
|
|
void readDevices ( char * buf );
|
|
void readAliases ( char * buf );
|
|
void readCollections ( char * buf );
|
|
void compressComments ( char * filename, char * buf );
|
|
void compressSpaces ( char * filename, char * buf );
|
|
};
|
|
|
|
#include <cdevDeviceDefinition.h>
|
|
#include <cdevAliasDefinition.h>
|
|
#include <cdevServiceDefinition.h>
|
|
#include <cdevElementDefinition.h>
|
|
#include <cdevRedirectorDefinition.h>
|
|
#include <cdevClassDefinition.h>
|
|
#include <cdevCollectionDefinition.h>
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::cdevDirectoryTable :
|
|
// * Constructor for the cdevDirectoryTable class.
|
|
// *****************************************************************************
|
|
inline cdevDirectoryTable::cdevDirectoryTable ( void )
|
|
: serviceHead(NULL), serviceTail(NULL), classHead(NULL), classTail(NULL),
|
|
aliasHead(NULL), aliasTail(NULL), collectionHead(NULL),
|
|
collectionTail(NULL), serviceHash(0), classHash(0),
|
|
deviceHash(0, 9973), classInstanceHash(0), collectionHash(0)
|
|
{
|
|
// *********************************************************************
|
|
// * Note, by creating a collection class to hold all collection devices
|
|
// * I am preventing the developer from creating his own collection
|
|
// * class.
|
|
// *********************************************************************
|
|
collectionClass = new cdevClassDefinition(*this, strdup("collection"));
|
|
addClass(collectionClass);
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::~cdevDirectoryTable :
|
|
// * This is the destructor for the cdevDirectoryTable class.
|
|
// *****************************************************************************
|
|
inline cdevDirectoryTable::~cdevDirectoryTable ( void )
|
|
{
|
|
while(serviceHead!=NULL)
|
|
{
|
|
cdevServiceDefinition *ptr = serviceHead;
|
|
serviceHead = ptr->getNext();
|
|
serviceHash.remove(ptr->getName());
|
|
delete ptr;
|
|
}
|
|
while(classHead!=NULL)
|
|
{
|
|
cdevClassDefinition *ptr = classHead;
|
|
classHead = ptr->getNext();
|
|
classHash.remove(ptr->getName());
|
|
classInstanceHash.remove(ptr->getName());
|
|
delete ptr;
|
|
}
|
|
while(aliasHead!=NULL)
|
|
{
|
|
cdevAliasDefinition *ptr = aliasHead;
|
|
aliasHead = ptr->getNext();
|
|
deviceHash.remove(ptr->getName());
|
|
delete ptr;
|
|
}
|
|
while(collectionHead!=NULL)
|
|
{
|
|
cdevCollectionDefinition *ptr = collectionHead;
|
|
collectionHead = ptr->getNext();
|
|
collectionHash.remove(ptr->getName());
|
|
delete ptr;
|
|
}
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addService :
|
|
// * Adds a new service to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addService ( cdevServiceDefinition * def )
|
|
{
|
|
int result = CDEV_SUCCESS;
|
|
|
|
if(def!=NULL && def->getName() && *def->getName())
|
|
{
|
|
if(serviceHash.find(def->getName())!=NULL)
|
|
{
|
|
cdevReportError(CDEV_SEVERITY_ERROR, "CDEV Directory", NULL,
|
|
"Service \"%s\" is already defined", def->getName());
|
|
result = CDEV_ERROR;
|
|
}
|
|
else
|
|
{
|
|
serviceHash.insert(def->getName(), def);
|
|
if(serviceTail==NULL)
|
|
{
|
|
serviceTail = def;
|
|
serviceHead = def;
|
|
}
|
|
else {
|
|
serviceTail->setNext(def);
|
|
serviceTail = def;
|
|
}
|
|
}
|
|
}
|
|
else result = CDEV_ERROR;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addService :
|
|
// * Adds a new service to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addService ( char * name, char ** tags, int nTags )
|
|
{
|
|
int result = CDEV_SUCCESS;
|
|
|
|
if(name!=NULL && *name)
|
|
{
|
|
if(serviceHash.find(name)!=NULL)
|
|
{
|
|
cdevReportError(CDEV_SEVERITY_ERROR, "CDEV Directory", NULL,
|
|
"Service \"%s\" is already defined", name);
|
|
result = CDEV_ERROR;
|
|
}
|
|
else
|
|
{
|
|
cdevServiceDefinition *def = new cdevServiceDefinition
|
|
(name, tags, nTags);
|
|
|
|
serviceHash.insert(name, def);
|
|
if(serviceTail==NULL)
|
|
{
|
|
serviceTail = def;
|
|
serviceHead = def;
|
|
}
|
|
else {
|
|
serviceTail->setNext(def);
|
|
serviceTail = def;
|
|
}
|
|
}
|
|
}
|
|
else result = CDEV_ERROR;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addClass :
|
|
// * Adds a new class to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addClass ( cdevClassDefinition * def )
|
|
{
|
|
int result = CDEV_SUCCESS;
|
|
if(def!=NULL && def->getName() && *def->getName())
|
|
{
|
|
if(classHash.find(def->getName())!=NULL)
|
|
{
|
|
cdevReportError(CDEV_SEVERITY_ERROR, "CDEV Directory", NULL,
|
|
"Class \"%s\" is already defined", def->getName());
|
|
result = CDEV_ERROR;
|
|
}
|
|
else
|
|
{
|
|
classHash.insert(def->getName(), def);
|
|
if(classTail==NULL)
|
|
{
|
|
classTail = def;
|
|
classHead = def;
|
|
}
|
|
else {
|
|
classTail->setNext(def);
|
|
classTail = def;
|
|
}
|
|
}
|
|
}
|
|
else result = CDEV_ERROR;
|
|
|
|
return result;
|
|
}
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addClass :
|
|
// * Adds a new class to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addClass
|
|
( char *name,
|
|
cdevClassDefinition *parent,
|
|
cdevElementDefinition *verbs,
|
|
cdevElementDefinition *attributes,
|
|
cdevElementDefinition *messages)
|
|
{
|
|
int result = CDEV_SUCCESS;
|
|
|
|
if(name!=NULL && *name)
|
|
{
|
|
if(classHash.find(name)!=NULL)
|
|
{
|
|
cdevReportError(CDEV_SEVERITY_ERROR, "CDEV Directory", NULL,
|
|
"Class \"%s\" is already defined", name);
|
|
result = CDEV_ERROR;
|
|
}
|
|
else
|
|
{
|
|
cdevClassDefinition *def = new cdevClassDefinition
|
|
(*this, name, parent, verbs, attributes, messages);
|
|
|
|
classHash.insert(name, def);
|
|
if(classTail==NULL)
|
|
{
|
|
classTail = def;
|
|
classHead = def;
|
|
}
|
|
else {
|
|
classTail->setNext(def);
|
|
classTail = def;
|
|
}
|
|
}
|
|
}
|
|
else result = CDEV_ERROR;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addClassInstance :
|
|
// * Adds a new class instance to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addClassInstance ( cdevClassDefinition * def )
|
|
{
|
|
int result = CDEV_SUCCESS;
|
|
if(def!=NULL && def->getName() && *def->getName())
|
|
{
|
|
if(classHash.find(def->getName())==NULL)
|
|
{
|
|
cdevReportError(CDEV_SEVERITY_ERROR, "CDEV Directory", NULL,
|
|
"Class \"%s\" has not been defined", def->getName());
|
|
result = CDEV_ERROR;
|
|
}
|
|
else if(classInstanceHash.find(def->getName())==NULL)
|
|
{
|
|
classInstanceHash.insert(def->getName(), def);
|
|
}
|
|
}
|
|
else result = CDEV_ERROR;
|
|
|
|
return result;
|
|
}
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addDevice :
|
|
// * Adds a new device to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addDevice ( cdevDeviceDefinition * def )
|
|
{
|
|
int result = CDEV_SUCCESS;
|
|
if(def!=NULL && def->getName()!=NULL && *def->getName())
|
|
{
|
|
if(deviceHash.find(def->getName())!=NULL)
|
|
{
|
|
cdevReportError(CDEV_SEVERITY_ERROR, "CDEV Directory", NULL,
|
|
"Device \"%s\" has already been defined", def->getName());
|
|
result = CDEV_ERROR;
|
|
}
|
|
else deviceHash.insert(def->getName(), def);
|
|
}
|
|
else result = CDEV_ERROR;
|
|
|
|
return result;
|
|
}
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addAlias :
|
|
// * Adds a new alias to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addAlias ( cdevAliasDefinition * def )
|
|
{
|
|
int result = CDEV_SUCCESS;
|
|
if(def!=NULL && def->getName() && *def->getName())
|
|
{
|
|
if(deviceHash.find(def->getName())!=NULL)
|
|
{
|
|
cdevReportError(CDEV_SEVERITY_ERROR, "CDEV Directory", NULL,
|
|
"Alias \"%s\" has already been defined", def->getName());
|
|
result = CDEV_ERROR;
|
|
}
|
|
else {
|
|
if(aliasTail==NULL)
|
|
{
|
|
aliasHead = def;
|
|
aliasTail = def;
|
|
}
|
|
else {
|
|
aliasTail->setNext(def);
|
|
aliasTail = def;
|
|
}
|
|
deviceHash.insert(def->getName(), &def->getDevice());
|
|
}
|
|
}
|
|
else result = CDEV_ERROR;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addAlias :
|
|
// * Adds a new alias to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addAlias
|
|
( char * name, cdevDeviceDefinition & device )
|
|
{
|
|
cdevAliasDefinition *def = new cdevAliasDefinition(name, device);
|
|
int result = addAlias(def);
|
|
if(result!=CDEV_SUCCESS) delete def;
|
|
return result;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addCollection :
|
|
// * Adds a new collection to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addCollection ( cdevCollectionDefinition * def )
|
|
{
|
|
int result = CDEV_SUCCESS;
|
|
if(def!=NULL && def->getName()!=NULL && *def->getName())
|
|
{
|
|
if(deviceHash.find(def->getName())!=NULL ||
|
|
collectionHash.find(def->getName())!=NULL)
|
|
{
|
|
cdevReportError(CDEV_SEVERITY_ERROR, "CDEV Directory", NULL,
|
|
"Collection device \"%s\" has already been defined", def->getName());
|
|
result = CDEV_ERROR;
|
|
}
|
|
else {
|
|
if(collectionTail==NULL)
|
|
{
|
|
collectionTail = def;
|
|
collectionHead = def;
|
|
}
|
|
else {
|
|
collectionTail->setNext(def);
|
|
collectionTail = def;
|
|
}
|
|
collectionHash.insert(def->getName(), def);
|
|
collectionClass->addDevice (strdup(def->getName()));
|
|
}
|
|
}
|
|
else result = CDEV_ERROR;
|
|
|
|
return result;
|
|
}
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::addCollection :
|
|
// * Adds a new collection to the directory table.
|
|
// *****************************************************************************
|
|
inline int cdevDirectoryTable::addCollection ( char * name, char ** devices, int nDevices )
|
|
{
|
|
int result;
|
|
|
|
cdevCollectionDefinition * def =
|
|
new cdevCollectionDefinition(name, devices, nDevices);
|
|
|
|
if((result = addCollection(def))!=CDEV_SUCCESS) delete def;
|
|
|
|
return result;
|
|
}
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::findService :
|
|
// * Allows the caller to locate a service by name.
|
|
// *****************************************************************************
|
|
inline cdevServiceDefinition * cdevDirectoryTable::findService ( char * name )
|
|
{
|
|
return (cdevServiceDefinition *)serviceHash.find(name);
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::findClass :
|
|
// * Allows the caller to locate a class by name.
|
|
// *****************************************************************************
|
|
inline cdevClassDefinition * cdevDirectoryTable::findClass ( char * name )
|
|
{
|
|
return (cdevClassDefinition *)classHash.find(name);
|
|
}
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::asciiDump :
|
|
// * This method will write the contents of the cdevDirectory object to
|
|
// * the user provided file pointer.
|
|
// *****************************************************************************
|
|
inline void cdevDirectoryTable::asciiDump ( FILE * fp )
|
|
{
|
|
cdevServiceDefinition *sPtr = serviceHead;
|
|
if(sPtr)
|
|
{
|
|
fprintf(fp, "\n// ******************************************\n");
|
|
fprintf(fp, "// * Table of service definitions... *\n");
|
|
fprintf(fp, "// ******************************************\n");
|
|
}
|
|
while(sPtr!=NULL)
|
|
{
|
|
sPtr->asciiDump(fp);
|
|
sPtr = sPtr->getNext();
|
|
}
|
|
|
|
cdevClassDefinition *cPtr = classHead;
|
|
if(cPtr)
|
|
{
|
|
fprintf(fp, "\n// ******************************************\n");
|
|
fprintf(fp, "// * Table of class definitions... *\n");
|
|
fprintf(fp, "// ******************************************\n");
|
|
}
|
|
while(cPtr!=NULL)
|
|
{
|
|
if(cPtr!=collectionClass) cPtr->asciiDump(fp);
|
|
cPtr = cPtr->getNext();
|
|
}
|
|
|
|
cPtr = classHead;
|
|
if(cPtr)
|
|
{
|
|
fprintf(fp, "\n// ******************************************\n");
|
|
fprintf(fp, "// * Table of class instance definitions... *\n");
|
|
fprintf(fp, "// ******************************************\n");
|
|
}
|
|
while(cPtr!=NULL)
|
|
{
|
|
if(cPtr!=collectionClass) cPtr->asciiDumpInstances(fp);
|
|
cPtr = cPtr->getNext();
|
|
}
|
|
|
|
cdevAliasDefinition *aPtr = aliasHead;
|
|
if(aPtr)
|
|
{
|
|
fprintf(fp, "\n\n// ******************************************\n");
|
|
fprintf(fp, "// * Table of alias definitions... *\n");
|
|
fprintf(fp, "// ******************************************\n");
|
|
}
|
|
while(aPtr!=NULL)
|
|
{
|
|
aPtr->asciiDump(fp);
|
|
aPtr = aPtr->getNext();
|
|
}
|
|
|
|
cdevCollectionDefinition * clPtr = collectionHead;
|
|
if(clPtr)
|
|
{
|
|
fprintf(fp, "\n\n// ******************************************\n");
|
|
fprintf(fp, "// * Table of collection definitions... *\n");
|
|
fprintf(fp, "// ******************************************\n");
|
|
}
|
|
while(clPtr!=NULL)
|
|
{
|
|
clPtr->asciiDump(fp);
|
|
clPtr = clPtr->getNext();
|
|
}
|
|
}
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::asciiDumpRedirector :
|
|
// * This is a diagnostic method that allows the caller to dump the contents
|
|
// * of the redirection table for each class that has been instanciated.
|
|
// *****************************************************************************
|
|
inline void cdevDirectoryTable::asciiDumpRedirector ( FILE * fp )
|
|
{
|
|
int cnt = 0;
|
|
|
|
cdevClassDefinition *def;
|
|
for(def = classHead; def!=NULL; def = def->getNext())
|
|
{
|
|
if(classInstanceHash.find(def->getName())!=NULL)
|
|
{
|
|
def->asciiDumpRedirector(fp);
|
|
cnt++;
|
|
}
|
|
}
|
|
if(!cnt) cdevReportError(CDEV_SEVERITY_WARN, "CDEV Directory", NULL,
|
|
"No devices have been instanciated");
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::getServices :
|
|
// * Returns the list of services that are defined within the directory.
|
|
// *****************************************************************************
|
|
inline cdevServiceDefinition * cdevDirectoryTable::getServices ( void )
|
|
{
|
|
return serviceHead;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::getClasses :
|
|
// * Returns the list of classes that are defined within the directory.
|
|
// *****************************************************************************
|
|
inline cdevClassDefinition * cdevDirectoryTable::getClasses ( void )
|
|
{
|
|
return classHead;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::getAliases :
|
|
// * Returns the list of aliases that are defined within the directory.
|
|
// *****************************************************************************
|
|
inline cdevAliasDefinition * cdevDirectoryTable::getAliases ( void )
|
|
{
|
|
return aliasHead;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::getServiceHash :
|
|
// * Return a hash table of services that are defined within the directory.
|
|
// *****************************************************************************
|
|
inline StringHash & cdevDirectoryTable::getServiceHash ( void )
|
|
{
|
|
return serviceHash;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::getClassHash :
|
|
// * Return a hash table of classes that are defined within the directory.
|
|
// *****************************************************************************
|
|
inline StringHash & cdevDirectoryTable::getClassHash ( void )
|
|
{
|
|
return classHash;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::getInstanceHash :
|
|
// * Return a hash table of classes that have been instanciated within the
|
|
// * directory.
|
|
// *****************************************************************************
|
|
inline StringHash & cdevDirectoryTable::getInstanceHash ( void )
|
|
{
|
|
return classInstanceHash;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::getDeviceHash :
|
|
// * Return a hash table of device names that have been instanciated in all
|
|
// * classes within the directory. This hash-table includes aliases that
|
|
// * have been instanciated.
|
|
// *****************************************************************************
|
|
inline StringHash & cdevDirectoryTable::getDeviceHash ( void )
|
|
{
|
|
return deviceHash;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevDirectoryTable::getCollectionHash :
|
|
// * Return a hash table of collection names that have been instanciated in
|
|
// * the DDL file. Each collection definition contains the list of devices
|
|
// * that it contains.
|
|
// *****************************************************************************
|
|
inline StringHash & cdevDirectoryTable::getCollectionHash ( void )
|
|
{
|
|
return collectionHash;
|
|
}
|
|
|
|
|
|
#endif /* _CDEV_DIRECTORY_TABLE_H_ */
|