home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / Vcl / systvar.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  8KB  |  273 lines
  1. // SYSTVAR.H: Pascal TVarRec support (Pascal const parameter types)
  2. //
  3. // $Revision:   1.14  $
  4. // $Date:   02 Sep 1999 18:01:08  $
  5. //
  6. // Copyright (c) 1997, 1999 Borland International
  7.  
  8. #if !defined(SYSTVAR_H)
  9. #define SYSTVAR_H
  10.  
  11. #if !defined(SystemHPP)
  12. #error Do not include this file directly.  Include 'system.hpp'.
  13. #endif
  14.  
  15. #if !defined(SYSMAC_H)
  16. #include <sysmac.h>
  17. #endif
  18.  
  19. #if !defined(DSTRING_H)
  20. #include <dstring.h>
  21. #endif
  22.  
  23. #if !defined(WSTRING_H)
  24. #include <wstring.h>
  25. #endif
  26.  
  27. typedef struct tagSAFEARRAY SAFEARRAY;
  28. typedef struct tagVARIANT VARIANT;
  29.  
  30. #pragma option push -w-inl -w-lvc
  31.  
  32. namespace System
  33. {
  34.   // TVarData = VARIANT
  35.   struct TVarData
  36.   {
  37.     union
  38.     {
  39.       Word        VType;    // Delphi-compatible - Variant Type member
  40.       VARTYPE     vt;       // tagVARIANT compatible member
  41.     };
  42.     Word Reserved1;
  43.     Word Reserved2;
  44.     Word Reserved3;
  45.     union
  46.     {
  47.       // Delphi-compatible Variant members
  48.       Smallint      VSmallint;    //  iVal
  49.       Integer       VInteger;     //  lVal
  50.       Single        VSingle;      //  fltVal
  51.       Double        VDouble;      //  dblVal
  52.       CurrencyBase  VCurrency;    //  cyVal
  53.       TDateTimeBase VDate;        //  date
  54.       PWideChar     VOleStr;      //  bstrVal
  55.       IDispatch*    VDispatch;    //  pdispVal
  56.       HResult       VError;       //  scode
  57.       WordBool      VBoolean;     //  boolVal
  58.       IUnknown*     VUnknown;     //  punkVal
  59.       Byte          VByte;        //  bVal
  60.       Pointer       VString;      //  ??????
  61.       PVarArray     VArray;       //  parray
  62.       Pointer       VPointer;     //  byref
  63.  
  64.       // tagVARIANT compatible members (from OAIDL.H)
  65.       // Allowing all types marked as [V] (may appear in a VARIANT to be initialized
  66.       LONG          lVal;
  67.       BYTE          bVal;
  68.       SHORT         iVal;
  69.       FLOAT         fltVal;
  70.       DOUBLE        dblVal;
  71.       VARIANT_BOOL  boolVal;
  72.       SCODE         scode;
  73.       CY            cyVal;
  74.       DATE          date;
  75.       BSTR          bstrVal;
  76.       IUnknown     *punkVal;
  77.       IDispatch    *pdispVal;
  78.       SAFEARRAY    *parray;
  79.       BYTE         *pbVal;
  80.       SHORT        *piVal;
  81.       LONG         *plVal;
  82.       FLOAT        *pfltVal;
  83.       DOUBLE       *pdblVal;
  84.       VARIANT_BOOL *pboolVal;
  85.       SCODE        *pscode;
  86.       CY           *pcyVal;
  87.       DATE         *pdate;
  88.       BSTR         *pbstrVal;
  89.       IUnknown    **ppunkVal;
  90.       IDispatch   **ppdispVal;
  91.       SAFEARRAY   **pparray;
  92.       VARIANT      *pvarVal;
  93.       PVOID         byref;
  94.       CHAR          cVal;
  95.       USHORT        uiVal;
  96.       ULONG         ulVal;
  97.       INT           intVal;
  98.       UINT          uintVal;
  99.       DECIMAL      *pdecVal;
  100.       CHAR         *pcVal;
  101.       USHORT       *puiVal;
  102.       ULONG        *pulVal;
  103.       INT          *pintVal;
  104.       UINT         *puintVal;
  105.     };
  106.   };
  107.  
  108.   class   TVarRec;
  109.   typedef TVarRec* PVarRec;
  110.  
  111.   class TVarRec
  112.   {
  113.   public:
  114.     union
  115.     {
  116.       Integer      VInteger;
  117.       Boolean      VBoolean;
  118.       Char         VChar;
  119.       PExtended    VExtended;
  120.       PShortString VString;
  121.       Pointer      VPointer;
  122.       PChar        VPChar;
  123.       TObject*     VObject;
  124.       TClass       VClass;
  125.       WideChar     VWideChar;
  126.       PWideChar    VPWideChar;
  127.       Pointer      VAnsiString;
  128.       PCurrency    VCurrency;
  129.       PVariant     VVariant;
  130.     };
  131.     union
  132.     {
  133.       Byte VType;
  134.       /*
  135.       long ForceAlignment;
  136.   #if 0
  137.     //! The ForceAlignment should be removed, if alignment set to 4
  138.     //! we don't need this
  139.   #endif
  140.       */
  141.     };
  142.  
  143.     //---- constructors ----
  144.     __fastcall TVarRec(): VType(vtInteger), VInteger(0) {} //default int 0
  145.     __fastcall TVarRec(Integer src): VType(vtInteger), VInteger(src) {}
  146.     __fastcall TVarRec(Boolean src): VType(vtBoolean), VBoolean(src) {}
  147.     __fastcall TVarRec(char src): VType(vtChar), VChar(src) {}
  148.     __fastcall TVarRec(const Extended& src): VType(vtExtended), VExtended(const_cast<Extended*>(&src)) {}
  149.     __fastcall TVarRec(const ShortString& src): VType(vtString), VString(const_cast<PShortString>(&src)) {}
  150.     __fastcall TVarRec(const Pointer src): VType(vtPointer), VPointer(src) {}
  151.     __fastcall TVarRec(const PChar src): VType(vtPChar), VPChar(src) {}
  152.     __fastcall TVarRec(const char* src): VType(vtPChar), VPChar(reinterpret_cast<PChar>(const_cast<char*>(src))) {}
  153.     __fastcall TVarRec(const TObject& src): VType(vtObject), VObject(const_cast<TObject*>(&src)) {}
  154.     __fastcall TVarRec(const TClass src): VType(vtClass), VClass(src) {}
  155.     __fastcall TVarRec(WideChar src): VType(vtWideChar), VWideChar(src) {}
  156.     __fastcall TVarRec(const PWideChar src): VType(vtPWideChar), VPWideChar(src) {}
  157.     __fastcall TVarRec(const AnsiString src): VType(vtAnsiString), VAnsiString(const_cast<void*>(src.data())) {}
  158.     __fastcall TVarRec(const Currency& src): VType(vtCurrency), VCurrency(const_cast<PCurrency>(&src)) {}
  159.     __fastcall TVarRec(const Variant& src): VType(vtVariant), VVariant(const_cast<PVariant>(&src)) {}
  160.  
  161.     //---- assignments ----
  162.     TVarRec& __fastcall operator =(Integer src)
  163.     {
  164.       VType = vtInteger;
  165.       VInteger = src;
  166.       return *this;
  167.     }
  168.  
  169.     TVarRec& __fastcall operator =(Boolean src)
  170.     {
  171.       VType = vtBoolean;
  172.       VBoolean = src;
  173.       return *this;
  174.     }
  175.  
  176.     TVarRec& __fastcall operator =(char src)
  177.     {
  178.       VType = vtChar;
  179.       VChar = src;
  180.       return *this;
  181.     }
  182.  
  183.     TVarRec& __fastcall operator =(const Extended& src)
  184.     {
  185.       VType = vtExtended;
  186.       VExtended = const_cast<PExtended>(&src);
  187.       return *this;
  188.     }
  189.  
  190.     TVarRec& __fastcall operator =(const ShortString& src)
  191.     {
  192.       VType = vtString;
  193.       VString = const_cast<PShortString>(&src);
  194.       return *this;
  195.     }
  196.  
  197.     TVarRec& __fastcall operator =(const Pointer src)
  198.     {
  199.       VType = vtPointer;
  200.       VPointer = src;
  201.       return *this;
  202.     }
  203.  
  204.     TVarRec& __fastcall operator =(const PChar src)
  205.     {
  206.       VType = vtPChar;
  207.       VPChar = src;
  208.       return *this;
  209.     }
  210.  
  211.     TVarRec& __fastcall operator =(const char* src)
  212.     {
  213.       VType = vtPChar;
  214.       VPChar = reinterpret_cast<PChar>(const_cast<char*>(src));
  215.       return *this;
  216.     }
  217.  
  218.     TVarRec& __fastcall operator =(const TObject& src)
  219.     {
  220.       VType = vtObject;
  221.       VObject = const_cast<TObject*>(&src);
  222.       return *this;
  223.     }
  224.  
  225.     TVarRec& __fastcall operator =(const TClass src)
  226.     {
  227.       VType = vtClass;
  228.       VClass = src;
  229.       return *this;
  230.     }
  231.  
  232.     TVarRec& __fastcall operator =(WideChar src)
  233.     {
  234.       VType = vtWideChar;
  235.       VWideChar = src;
  236.       return *this;
  237.     }
  238.  
  239.     TVarRec& __fastcall operator =(const PWideChar src)
  240.     {
  241.       VType = vtPWideChar;
  242.       VPWideChar = src;
  243.       return *this;
  244.     }
  245.  
  246.     TVarRec& __fastcall operator =(const AnsiString src)
  247.     {
  248.       VType = vtAnsiString;
  249.       VAnsiString = const_cast<void*>(src.data());
  250.       return *this;
  251.     }
  252.  
  253.     TVarRec& __fastcall operator =(const Currency& src)
  254.     {
  255.       VType = vtCurrency;
  256.       VCurrency = const_cast<PCurrency>(&src);
  257.       return *this;
  258.     }
  259.  
  260.     TVarRec& __fastcall operator =(const Variant& src)
  261.     {
  262.       VType = vtVariant;
  263.       VVariant = const_cast<PVariant>(&src);
  264.       return *this;
  265.     }
  266.  
  267.   };
  268. }
  269.  
  270. #pragma option              pop
  271.  
  272. #endif
  273.