//--------------------------------------------------------------------------- // Copyright (c) 1991,1992 Southeastern Universities Research Association, // Continuous Electron Beam Accelerator Facility // // This software was developed under a United States Government license // described in the NOTICE file included as part of this distribution. //---------------------------------------------------------------------------- // // description: cdevData.h // Self descibing data structure to manage the storage and transport // of data between local cdev functions, as well as remote client and // server applications. // // Author: Walt Akers and Danjin Wu // // Revision History: // cdevData.h,v // Revision 1.24 1997/12/22 13:47:02 akers // Made changeTag method virtual // // Revision 1.23 1997/08/01 19:06:29 akers // Added addTag and tagExists feature to the library // // Revision 1.22 1997/01/14 19:39:39 chen // add += operator // // Revision 1.21 1997/01/09 16:32:39 akers // Corrected anachronism // // Revision 1.20 1996/11/21 17:02:57 akers // Ongoing Developement of CDEV 1.5 // // Revision 1.19 1996/10/01 13:58:19 akers // Changes to support AIX // // Revision 1.18 1996/09/20 19:33:11 akers // Changed protection in cdevDataEntryStorage, cdevDataEntry and cdevData in order to support subclassing of the cdevData object // // Revision 1.17 1996/09/20 15:41:51 akers // Made xdr methods virual // // Revision 1.16 1996/08/26 19:14:05 akers // Adding cdevData.inserttag callback capabilities // // Revision 1.15 1996/08/23 15:34:07 akers // Added comparison operator to cdevData // // Revision 1.14 1996/07/12 18:08:52 chen // change copy and assignment to const cdevData& // // Revision 1.13 1996/04/12 13:40:04 akers // Added char * cast operator // // Revision 1.12 1996/02/27 20:50:05 danjin // add assignment operator from various typed data to cdevData object // // Revision 1.11 1995/11/01 15:43:42 akers // Corrected INLINE definition // // Revision 1.10 1995/10/06 20:09:47 chen // add stdio // // Revision 1.9 1995/10/06 19:38:34 chen // Seperate inline functions // // Revision 1.8 1995/10/03 19:36:34 chen // Use new cdevGlobalTagTable Class // // Revision 1.7 1995/09/22 21:04:24 danjin // added cdevDataIterator mechanism // // Revision 1.6 1995/09/13 15:27:10 danjin // added changeTagName func // // Revision 1.5 1995/09/06 18:34:16 danjin // added time stamp structure and related func // // Revision 1.4 1995/07/20 14:36:52 akers // Mispelling in header // // Revision 1.3 1995/07/19 20:34:06 akers // CVS // // Revision 1.2 1995/07/14 13:20:09 akers // Updated cdevData header file supporting changes specified at June 95 Review // // // //-------------------------------------------------------------------------- #ifndef _CDEV_DATA_H #define _CDEV_DATA_H #include #ifdef _WIN32 #include #include #include #else #include #endif #include #include #include #include #include #include #include #include #ifndef __hpux extern char* ltoa (long val); extern char* ultoa (unsigned long val); #endif #ifndef _WIN32 extern "C" char *ctime (__const time_t *__timer) __THROW; #endif class CDEV_CLASS_SPEC cdevData { friend class cdevDataIterator; protected: cdevDataEntry *entries; // ********************************************************************* // * copy: // * This function copies the contents of the cdevData object // * specified by data into this cdevData object. It is used by // * both the copy constructor and by the assignment operator. // ********************************************************************* cdevData & copy (const cdevData & data); // ********************************************************************* // * lookupTag: // * This function is for internal use and allows a cdevData object // * to locate and optionally create a tagged data item. // ********************************************************************* cdevDataEntry * lookupTag(int tag, int create = 0); cdevDataEntry * lookupTag(char * ctag, int create = 0); // ********************************************************************* // * setupTag: // * This function is for internal use and is used to prepare a new // * cdevDataEntry object prior to inserting data into it. // ********************************************************************* cdevDataEntry * setupTag ( int tag, cdevDataTypes type, size_t elemSize, size_t numElems, size_t numDims ); public: // ********************************************************************* // * This group of static functions allows the user an interface to the // * database of tagged data items that is stored in the // * cdevGlobalTagTable object. // ********************************************************************* static int tagC2I (char *ctag, int *tag); static int tagI2C (int tag, char * &ctag); static void insertTag(int tag, char *ctag); static int tagExists(char * ctag); static int tagExists(int tag); static int addTag (char * ctag); // *************************************************************************** // * addTagCallback : // * This method will add a cdevTagTableCallback object to the list of // * classes that should be notified each time a tag is added to the // * cdevTagTable. // *************************************************************************** static void addTagCallback ( cdevTagTableCallback * cb ); // *************************************************************************** // * delTagCallback : // * This method will remote a cdevTagTableCallback object that was // * previously added to the list of callback classes. // * // * Note: This method does not actually delete the cdevTagTableCallback // * object, it merely removes it from the list. It is the // * responsibility of the owner to delete the object when it is // * no longer needed. // *************************************************************************** static void delTagCallback ( cdevTagTableCallback * cb ); // ***************************************************************************** // * readTagTable : // * This method allows the caller to obtain a list of tag names and // * integers that are currently stored in this tag table. // * // * Note: This method will allocate an array of integers and an array of // * character string pointers. The strings that are stored in the // * string array will be the actual strings from within the // * tag table and should not be deleted... // * // * The data allocated becomes the property of the caller and must // * be deleted when it is no longer needed... the correct syntax to // * delete these items is... // * // * delete tags; // * delete ctags; // * // * This will delete the array, however, it will leave the // * individual array elements intact. // ***************************************************************************** static int readTagTable ( int * &tags, char ** &ctags, int &ntags ); // ********************************************************************* // * cdevData: // * This is the default constructor, it simply initializes // * variables within the cdevData object. // ********************************************************************* cdevData ( void ); // ********************************************************************* // * cdevData: // * Copy constructor. This constructor duplicates the cdevData // * object that it has been passed as a parameter. // ********************************************************************* cdevData ( const cdevData & data ); // ********************************************************************* // * ~cdevData: // * This is the default destructor for the cdevData object. It // * frees any memory allocated for storage and deletes the object. // ********************************************************************* ~cdevData( void ); // ********************************************************************* // * Assignment operator: // * This function copies the contents of a cdevData object to this // * object. // ********************************************************************* cdevData & operator = (const cdevData & data); // ********************************************************************* // * Casting operators: // * These operators provide convenience methods for the user to // * obtain the value tagged data item from the cdevData object. // ********************************************************************* operator char ( void ); operator short ( void ); operator unsigned short ( void ); operator int ( void ); operator unsigned int ( void ); operator long ( void ); operator unsigned long ( void ); operator float ( void ); operator double ( void ); operator char * ( void ); // ********************************************************************* // * Assignment operators: // * These operators provide convenience methods for the user to // * obtain the value tagged cdevData object from various typed data. // ********************************************************************* cdevData& operator= (unsigned char x); cdevData& operator= (short x); cdevData& operator= (unsigned short x); cdevData& operator= (int x); cdevData& operator= (unsigned int x); cdevData& operator= (long x); cdevData& operator= (unsigned long x); cdevData& operator= (float x); cdevData& operator= (double x); // ********************************************************************* // * Append operation: // * This operation will append a cdevData onto an existing cdevData // * and return this object. If there is confilicts among tags, the // * appended one wins // ********************************************************************* cdevData& operator += (const cdevData& data); // ********************************************************************* // * asciiDump: // * Performs a diagnostic dump of the entire contents of the // * cdevData object to the specified file pointer. // ********************************************************************* #ifdef _WIN32 inline void asciiDump ( FILE * fp = stdout ) { int fd = _fileno(fp); long osfHandle = _get_osfhandle(fd); asciiDump(osfHandle); _lseek(fd, 0L, SEEK_END); } void asciiDump ( long osfHandle ); #else void asciiDump ( FILE * fp = stdout ); #endif // ********************************************************************* // * XDR Utilities: // * These functions provide the mechanisms for converting a cdevData // * object into a network portable bninary stream, and then // * reconstructing them after transport. // ********************************************************************* virtual int xdrSize (size_t * bufLen, size_t * elementCount); virtual int xdrExport ( char ** buf, size_t * bufLen ); virtual int xdrExport ( char * buf, size_t bufLen, size_t count); virtual int xdrImport ( char * buf, size_t bufLen); // ********************************************************************* // * remove: // * Removes cdevDataEntry objects from the cdevData object by tag // * integer or by tag string. If no tag is specified, then all // * cdevDataEntry objects will be removed. // ********************************************************************* void remove( void ); void remove( int tag ); void remove( char * ctag ); // ********************************************************************* // * changeTag: // * Replace a new tag with the old one within the // * cdevData object. If the old one can not be not found, // * CDEV_NOTFOUND is returned. If the new tag has already // * been found in that cdevData object, CDEV_ERROR is returned. // ********************************************************************* virtual int changeTag(int oldTag, int newTag); int changeTag(int oldTag, char *c_newTag); int changeTag(char *c_oldTag, int newTag); int changeTag(char *c_oldTag, char *c_newTag); // ********************************************************************* // * getType: // * Retrieves the cdevDataTypes of the referenced tagged data item. // * If no item with that tag is within the cdevData object, then // * CDEV_INVALID is returned. // ********************************************************************* cdevDataTypes getType(int tag); cdevDataTypes getType(char *ctag); // ********************************************************************* // * getDim: // * Obtains the number of dimensions in the specified tagged data // * item. Returns CDEV_SUCCESS if the tagged item exists, otherwise, // * CDEV_NOTFOUND is returned. // ********************************************************************** int getDim(int tag, size_t *dim); int getDim(char *ctag, size_t *dim); // ********************************************************************* // * getElems: // * Obtains the number of elements in the specified tagged data // * item. Returns CDEV_SUCCESS if the tagged item exists, otherwise, // * CDEV_NOTFOUND is returned. // ********************************************************************** int getElems(int tag, size_t *elems); int getElems(char *ctag, size_t *elems); // ********************************************************************* // * getBounds: // * Obtains the bounding dimensions of a cdevDataEntry array. The // * integer array passed as the bounds parameter must be allocated // * by the caller. The number of integers required is 2 times the // * number of dimensions, the first being the offset and the second // * being the length of the dimension. The len parameter specifies // * the actual number of integers allocated. // ********************************************************************* int getBounds(int tag, size_t * bounds, size_t len); int getBounds(char * ctag, size_t * bounds, size_t len); // ********************************************************************* // * getBounds: // * Obtains the bounding dimensions of a cdevDataEntry array. The // * cdevBounds structure passed as the bounds parameter must be // * allocated by the caller. The numBounds variable indicates the // * number of cdevBounds structures allocated by the caller. // ********************************************************************* int getBounds(int tag, cdevBounds * bounds, size_t numBounds); int getBounds(char * ctag, cdevBounds * bounds, size_t numBounds); // ********************************************************************* // * setBounds: // * Allows the caller to set the dimensions of a multidimensional // * tagged data item. The number of integers required is 2 times the // * number of dimensions, the first being the offset and the second // * being the length of the dimension. The len parameter specifies // * the actual number of integers submitted. // ********************************************************************* int setBounds(int tag, size_t * bounds, size_t len); int setBounds(char * ctag, size_t * bounds, size_t len); // ********************************************************************* // * setBounds: // * Allows the caller to set the dimensions of a multidimensional // * tagged data item. The numBounds variable indicates the number // * of cdevBounds structures submitted by the user. // ********************************************************************* int setBounds(int tag, cdevBounds * bounds, size_t numBounds); int setBounds(char * ctag, cdevBounds * bounds, size_t numBounds); // ********************************************************************* // * insert: // * The following functions allow the insertion of scalar data into // * a cdevData object. // ********************************************************************* int insert ( int tag, BYTE data ); int insert ( int tag, short data ); int insert ( int tag, unsigned short data ); int insert ( int tag, long data ); int insert ( int tag, unsigned long data ); int insert ( int tag, float data ); int insert ( int tag, double data ); int insert ( int tag, cdev_TS_STAMP data ); // ********************************************************************* // * Overloaded character tag based insertion mechanism // ********************************************************************* int insert ( char * ctag, BYTE data); int insert ( char * ctag, short data); int insert ( char * ctag, unsigned short data); int insert ( char * ctag, long data); int insert ( char * ctag, unsigned long data); int insert ( char * ctag, float data); int insert ( char * ctag, double data); int insert ( char * ctag, cdev_TS_STAMP data); // ******************************************************************** // * insert: // * The following functions allow the insertion of arrays of data // * into a cdevData object. The len variable contains the total // * number of elements to be inserted, the ndim variable indicates // * the number of dimensions in the array. // ******************************************************************** int insert (int tag, BYTE * data, size_t len, size_t ndim = 1); int insert (int tag, short * data, size_t len, size_t ndim = 1); int insert (int tag, unsigned short * data, size_t len, size_t ndim = 1); int insert (int tag, long * data, size_t len, size_t ndim = 1); int insert (int tag, unsigned long * data, size_t len, size_t ndim = 1); int insert (int tag, float * data, size_t len, size_t ndim = 1); int insert (int tag, double * data, size_t len, size_t ndim = 1); int insert ( int tag, cdev_TS_STAMP *data, size_t len, size_t ndim = 1); // ********************************************************************* // * Overloaded character tag based insertion mechanism // ********************************************************************* int insert (char * ctag, BYTE * data, size_t len, size_t ndim = 1); int insert (char * ctag, short * data, size_t len, size_t ndim = 1); int insert (char * ctag, unsigned short * data, size_t len, size_t ndim = 1); int insert (char * ctag, long * data, size_t len, size_t ndim = 1); int insert (char * ctag, unsigned long * data, size_t len, size_t ndim = 1); int insert (char * ctag, float * data, size_t len, size_t ndim = 1); int insert (char * ctag, double * data, size_t len, size_t ndim = 1); int insert (char * ctag, cdev_TS_STAMP *data, size_t len, size_t ndim =1 ); // ********************************************************************* // * insert: // * The following functions explicitly call the long functions when // * dealing with integer data. On a system with 16 bit integers, // * the short functions should be called. // ********************************************************************* #ifdef DEFAULT_16_BIT_INTEGER int insert ( int tag, int data ); int insert ( int tag, unsigned int data ); int insert ( char * ctag, int data); int insert ( char * ctag, unsigned int data); int insert (int tag, int * data, size_t len, size_t ndim = 1); int insert (int tag, unsigned int * data, size_t len, size_t ndim = 1); int insert (char * ctag, int * data, size_t len, size_t ndim = 1); int insert (char * ctag, unsigned int * data, size_t len, size_t ndim = 1); #else int insert ( int tag, int data ); int insert ( int tag, unsigned int data ) ; int insert ( char * ctag, int data); int insert ( char * ctag, unsigned int data); int insert (int tag, int * data, size_t len, size_t ndim = 1); int insert (int tag, unsigned int * data, size_t len, size_t ndim = 1); int insert (char * ctag, int * data, size_t len, size_t ndim = 1); int insert (char * ctag, unsigned int * data, size_t len, size_t ndim = 1); #endif // ********************************************************************* // * insert: // * The following functions insert character strings and arrays of // * character strings. Their treatment is different from the scalar // * data types. // ********************************************************************* int insert ( int tag, char * data ); int insert ( int tag, char ** data, size_t len = 0, size_t ndim = 1 ); // ********************************************************************* // * Overloaded character tag based insertion mechanism // ********************************************************************* int insert ( char * ctag, char * data); int insert ( char * ctag, char ** data, size_t len = 0, size_t ndim = 1); // ********************************************************************* // * get: // * This group of functions allows the user to extract scalar and // * array data from the cdevData object. // ********************************************************************* int get(int tag, BYTE * data); int get(int tag, short * data); int get(int tag, unsigned short * data); int get(int tag, long * data); int get(int tag, unsigned long * data); int get(int tag, float * data); int get(int tag, double * data); int get(int tag, char * data, size_t len); int get(int tag, char ** data); int get(int tag, cdev_TS_STAMP * data); // ********************************************************************* // * Overloaded character tag based extraction mechanism // ********************************************************************* int get(char * ctag, BYTE * data); int get(char * ctag, short * data); int get(char * ctag, unsigned short * data); int get(char * ctag, long * data); int get(char * ctag, unsigned long * data); int get(char * ctag, float * data); int get(char * ctag, double * data); int get(char * ctag, char * data, size_t len); int get(char * ctag, char ** data); int get(char * ctag, cdev_TS_STAMP * data); // ********************************************************************* // * get: // * The following get functions explicitly call the long integer // * functions unless the user is on a system with 16 bit integers. // ********************************************************************* #ifdef DEFAULT_16_BIT_INTEGER int get(int tag, int * data); int get(int tag, unsigned int * data); int get(char *ctag, int * data); int get(char *ctag, unsigned int * data); #else int get(int tag, int * data); int get(int tag, unsigned int * data); int get(char *ctag, int * data); int get(char *ctag, unsigned int * data); #endif // ********************************************************************* // * find: // * These functions allow the user to obtain a pointer to data // * within the actual data variables within the cdevData object. // ********************************************************************* int find(int tag, void* &data); int find(char * ctag, void* &data); // ********************************************************************* // * operator ==, operator !=: // * These methods provides a fast way for the caller to identify if two // * cdevData objects contain the identical fields and values... // ********************************************************************* int operator == (cdevData & data); int operator != (cdevData & data) { return !(operator == (data)); } }; class CDEV_CLASS_SPEC cdevDataIterator { public: cdevDataIterator(cdevData* data); ~cdevDataIterator() {}; int init(); int operator !(); int operator ++(); int tag(void); protected: cdevData *dataobj_; cdevDataEntry *cur_; }; #undef INLINE #ifndef _CDEV_NO_INLINE #define INLINE inline #include "cdevData.i" #else #define INLINE #endif #endif