home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1996 November / VPR9611B.ISO / vabasic / ntclnt.exe / DISK8 / data.8 / datab / INCLUDE / VUUID.H < prev    next >
C/C++ Source or Header  |  1996-07-29  |  6KB  |  145 lines
  1. /*****************************************************************************
  2.  ***   $Source: /rcs/crcs/general/vuuid.h,v $
  3.  ***   Checked int by: $Author: dan $
  4.  ***   $Date: 1996/04/10 15:17:30 $
  5.  ***   $Revision: 1.7 $
  6.  *****************************************************************************
  7.  ***                                       ***
  8.  ***          Copyright (c) 1995, Visual Edge Software Ltd.           ***
  9.  ***                                        ***
  10.  ***   All rights reserved.  This notice is  intended  as  a  precaution   ***
  11.  ***   against    inadvertent publication, and shall not be deemed to con-   ***
  12.  ***   stitute an acknowledgment that publication has  occurred     nor  to   ***
  13.  ***   imply  any  waiver  of confidentiality.    The year included in the   ***
  14.  ***   notice is the year of the creation of the work.               ***
  15.  ***                                        ***
  16.  *****************************************************************************/
  17.  
  18. #ifndef VUUID_H
  19. #define VUUID_H
  20.  
  21. #include <iptrhash.hh>        // for typedef VIHashKey.
  22. #include <vatom.h>        // for VAtomP.
  23.  
  24. /*==========================================================================
  25.  * VUUIDDECL is used to declare a persistent ID in a header file.
  26.  * The first and only argument is the identifier that you are going
  27.  * to use throughout the C code.
  28.  *--------------------------------------------------------------------------*/
  29.  
  30. #define VUUIDDECL(uuid) VDATADECL(VTUniqueID) uuid
  31.  
  32. /*==========================================================================
  33.  * VUUIDDEF is used to define a persistent ID in a source file.
  34.  * For each given ID, this should be in only one source file.
  35.  * The first argument is the identifier that you are going to
  36.  * use throughout the C code.
  37.  * The second argument is a string that represents a unique id.
  38.  * The member itsAtom is initialized at NULL. The first time
  39.  * VUUIDKEY is called on the argument 'uuid' (which can happen
  40.  * when a comparison is made between two uuids), a look up for
  41.  * an atom is done.
  42.  *--------------------------------------------------------------------------*/
  43.  
  44. #define VUUIDDEF(uuid,idStr)                        \
  45.         VTUniqueIDData    uuid##Data = { idStr, 0 };        \
  46.         VDATADEF(VTUniqueID) uuid = { & uuid##Data }
  47.  
  48. /*==========================================================================
  49.  * VUUIDFROMATOM declares a VTUniqueID variable given an
  50.  * atom.  The uniqueID should only be used as a local variable
  51.  *--------------------------------------------------------------------------*/
  52.  
  53. #define VUUIDFROMATOM(uuid,atom)                    \
  54.         VTUniqueIDData    uuid##Data;                \
  55.         VTUniqueID uuid;                    \
  56.         uuid##Data.itsString = 0;                \
  57.         uuid##Data.itsAtom = atom;                \
  58.         uuid.itsID = &uuid##Data;
  59.  
  60. /*==========================================================================
  61.  * VUUID_ATOM_LOOKUP returns a valid VAtomP given a VTUniqueID as argument.
  62.  * This method is not intended to be called by a user.
  63.  * The macro first checks if itsAtom has ever been looked up. If not, a
  64.  * look up is done and assigned to itsAtom.
  65.  * NEVER CHANGE the VAtomP returned by this macro.
  66.  *--------------------------------------------------------------------------*/
  67.  
  68. #define VUUID_ATOM_LOOKUP(uuid)                        \
  69.         (uuid.itsID->itsAtom ? uuid.itsID->itsAtom :        \
  70.         (uuid.itsID->itsAtom = VeLookupAtom(uuid.itsID->itsString)))
  71.  
  72. /*==========================================================================
  73.  * VUUIDKEY returns a unique key that can be used in hash tables, for
  74.  * instance.
  75.  * NEVER CHANGE the VAtomP returned by this macro.
  76.  * In C++, you don't have to use this macro; we have a cast operator that
  77.  * cast a uuid to a VIHashKey.
  78.  *--------------------------------------------------------------------------*/
  79.  
  80. #define VUUIDKEY(uuid)    (VIHashKey)VUUID_ATOM_LOOKUP(uuid)
  81.  
  82. /*==========================================================================
  83.  * VeEqualID compares two ID to see if they describe the same value.
  84.  *--------------------------------------------------------------------------*/
  85.  
  86. #define VeEqualID(a, b) (VUUID_ATOM_LOOKUP(a) == VUUID_ATOM_LOOKUP(b))
  87.  
  88. /*==========================================================================
  89.  * VTUniqueIDInfo contains the unique identification data of a UUID.
  90.  * Only one instance of this should exist for any given ID in one DLL.
  91.  *--------------------------------------------------------------------------*/
  92.  
  93. typedef struct VUniqueIDDataStruct
  94. {
  95.     const char    *itsString;
  96.     VTAtomP        itsAtom;
  97. } VTUniqueIDData;
  98.  
  99. /*==========================================================================
  100.  * VTUniqueID is the unique ID reference which is used in all comparisons.
  101.  * There can be many instances of this for each ID data object.
  102.  *--------------------------------------------------------------------------*/
  103.  
  104. typedef struct VTUniqueIDStruct
  105. {
  106.     VTUniqueIDData    *itsID;
  107.  
  108. #ifdef __cplusplus
  109.     operator VIHashKey () { return VUUIDKEY((*this)); }
  110.     operator VTAtomP ()   { return VUUID_ATOM_LOOKUP((*this)); }
  111.     operator VeAtomRef () { return VUUID_ATOM_LOOKUP((*this)); }
  112. #endif
  113. } VTUniqueID;
  114.  
  115.  
  116. #ifdef __cplusplus
  117.  
  118. /*==========================================================================
  119.  * C++ operators == and != compare two ID's to determine equality.
  120.  *--------------------------------------------------------------------------*/
  121.  
  122. inline bool_t operator ==(const VTUniqueID &a, const VTUniqueID &b)
  123. {
  124.     return VeEqualID(a, b);
  125. }
  126.  
  127. inline bool_t operator !=(const VTUniqueID &a, const VTUniqueID &b)
  128. {
  129.     return !VeEqualID(a, b);
  130. }
  131.  
  132. inline bool_t operator ==(const VTUniqueID &a, const VeAtomRef &b)
  133. {
  134.     return VUUID_ATOM_LOOKUP(a) == (VTAtomP)b;
  135. }
  136.  
  137. inline bool_t operator !=(const VTUniqueID &a, const VeAtomRef &b)
  138. {
  139.     return !(VUUID_ATOM_LOOKUP(a) == (VTAtomP)b);
  140. }
  141.  
  142. #endif
  143.  
  144. #endif /* VUUID_H */
  145.