home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / object10 / oobject.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-20  |  12.1 KB  |  472 lines
  1. /* Copyright (c) Oracle Corporation 1994.  All Rights Reserved */
  2.  
  3. /*
  4.     This source code is provided as a debugging aid for developers
  5.     who have purchased Oracle Objects for OLE    .  Please see the
  6.     online help for documentation of these classes.
  7. */
  8.  
  9. /*
  10.     Oracle Objects for OLE     C++ Classes
  11.     
  12.     This file implements the OOracleObject class
  13.                            
  14.     CREATED    ********   11/22/94
  15.     RWOOLARD    MODIFIED    03/20/95
  16.                 bug#    262912    *ErrorText should return "" and not NULL
  17.                         262914    *ErrorText should return const char *
  18. */
  19.  
  20. #include "windows.h"
  21. #include <ole2.h>
  22. #include <olenls.h>       
  23. #include <dispatch.h>  
  24.  
  25. #ifndef ORACL_ORACLE
  26. #include "oracl.h"
  27. #endif
  28.  
  29. #ifndef _OracleInProcServer_H_
  30. #include <oratlb.h>
  31. #endif
  32.  
  33. #ifndef ORAOBJI_ORACLE
  34. #include "oraobji.h"
  35. #endif
  36.  
  37. static const IID IID_IExDispatch =
  38. {0x51309a40, 0x14ba, 0x101b, { 0x91, 0x9e, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };
  39.  
  40. // values for error state
  41. #define OERROR_OBJECT -1 // use the normal object error interface
  42. #define OERROR_OTHER -2  // indicates that we should use "other" interface
  43. #define OERROR_INTERNAL -3  // some error in our code - no error interface has the error 
  44.  
  45.  
  46. // ----- OOracleObject -----------------------------------------------
  47.  
  48. // default constructor
  49. OOracleObject::OOracleObject(void)
  50. {
  51.     // we haven't opened interfaces yet - they're null
  52.     m_obji = 0;
  53.     m_erri = 0;
  54.     m_errotheri = 0;
  55.     m_errstate = OERROR_OBJECT;
  56.     m_errno = OERROR_NONE;
  57.     m_lasterrstring = 0;
  58. }
  59.  
  60. // copy construtor
  61. OOracleObject::OOracleObject(const OOracleObject &other)
  62. {
  63.     m_obji = 0;
  64.     m_erri = 0;
  65.     m_errotheri = 0;
  66.     m_errstate = OERROR_OBJECT;
  67.     m_errno = OERROR_NONE;
  68.     m_lasterrstring = 0;
  69.     // copy new state
  70.     Copy(other);
  71. }
  72.  
  73. // destructor
  74. OOracleObject::~OOracleObject(void)
  75. {
  76.     // clean out current state
  77.     Cleanup();
  78. }
  79.  
  80. // overloaded assignment operator
  81. OOracleObject &OOracleObject::operator=(const OOracleObject &other)
  82. {
  83.     if (&other == this)
  84.         return(*this); // self assignment - do nothing
  85.     
  86.     // clear out our old state
  87.     if (OSUCCESS == Cleanup())
  88.     {
  89.         Copy(other); // call copy constructor
  90.     }
  91.     // if the cleanup failed (possible but unlikely) we don't do the copy
  92.     //    and as a result, we pass on the unmodified (or partly cleaned!) object
  93.     
  94.     return(*this);
  95. } 
  96.  
  97. int OOracleObject::operator==(const OOracleObject &other) const
  98. {
  99.     // closed objects are never equal to anything
  100.     if (!m_obji)
  101.         return(FALSE);
  102.     return(m_obji == other.m_obji);
  103. }
  104.  
  105. int OOracleObject::operator!=(const OOracleObject &other) const
  106. {
  107.     // closed objects are never equal to anything
  108.     if (!m_obji)
  109.         return(TRUE);
  110.     
  111.     return(m_obji != other.m_obji);
  112. }
  113.  
  114. void *OOracleObject::Internal(void) const
  115. {
  116.     return m_obji;
  117. }
  118.  
  119. oboolean OOracleObject::IsOpen(void) const
  120. {
  121.     return (m_obji ? TRUE : FALSE);
  122. }
  123.  
  124. // routine to clean up current state
  125. //   This routine makes the object look as it did after default constructor
  126. oresult OOracleObject::Cleanup(void)
  127. {
  128.     if (m_obji)
  129.     {  // release object interface
  130.         ((IDispatch *) m_obji)->Release();
  131.         m_obji = 0;
  132.     }
  133.     
  134.     if (m_erri)
  135.     {   // release error interface
  136.         ((_IExDispatch *) m_erri)->Release();
  137.         m_erri = 0;
  138.     }
  139.     
  140.     if (m_errotheri)
  141.     {   // release error interface
  142.         ((_IExDispatch *) m_errotheri)->Release();
  143.         m_errotheri = 0;
  144.     }
  145.     
  146.     if (m_lasterrstring)
  147.     {
  148.         OObjectFreeString(m_lasterrstring);
  149.         m_lasterrstring = 0;
  150.     }
  151.     
  152.     m_errstate = OERROR_OBJECT;
  153.     m_errno = OERROR_NONE;
  154.     
  155.     return(OSUCCESS);
  156. }
  157.  
  158. oresult OOracleObject::Copy(const OOracleObject &other)
  159. {
  160.     if (other.m_obji)
  161.     { // copy the object interface
  162.         m_obji = other.m_obji;
  163.         ((IDispatch *) m_obji)->AddRef();
  164.     }
  165.     else
  166.         m_obji = 0;
  167.     
  168.     // copy error information
  169.     if (other.m_erri)
  170.     { // copy the error interface
  171.         m_erri = other.m_erri;
  172.         ((_IExDispatch *) m_erri)->AddRef();
  173.     }
  174.     else
  175.         m_erri = 0;
  176.     
  177.     if (other.m_errotheri)
  178.     { // copy the other error interface
  179.         m_errotheri = other.m_errotheri;
  180.         ((_IExDispatch *) m_errotheri)->AddRef();
  181.     }
  182.     else
  183.         m_errotheri = 0;
  184.     
  185.     m_errno = other.m_errno;
  186.     m_errstate = other.m_errstate;
  187.     
  188.     // we don't bother copying m_lasterrstring
  189.     m_lasterrstring = 0;
  190.     
  191.     
  192.     return(OSUCCESS);    
  193. }
  194.  
  195. // SetObjectInterface - lets subclasses set the object interface
  196. oresult OOracleObject::SetObjectInterface(void *obji, oboolean geterror)
  197. {
  198.     // get rid of old object & error interfaces
  199.     OOracleObject::Cleanup();
  200.     
  201.     // take care of error interface
  202.     if (geterror)
  203.     {  // try to get error interface from object
  204.         HRESULT hc;
  205.         hc = ((IDispatch *) obji)->QueryInterface(IID_IExDispatch, &m_erri);
  206.         if (FAILED(hc))
  207.         {
  208.             m_erri = 0; // to be sure 
  209.         
  210.             // set error condition
  211.             SetInternalError(OERROR_NOINTER);
  212.             return(OFAILURE);
  213.         }
  214.     }
  215.     else
  216.     { // don't even try to get error interface (maybe there isn't one...)
  217.         m_erri = 0;
  218.     }
  219.     
  220.     // everything went fine
  221.     
  222.     // set the new object interface
  223.     m_obji = obji;
  224.     
  225.     ErrorReset();
  226.     
  227.     return(OSUCCESS);
  228. }
  229.  
  230. // helper routine for all the routines that do something...
  231. oresult OOracleObject::ActionStart(void) const
  232. {
  233.     if (!IsOpen())
  234.     {
  235.         SetInternalError(OERROR_NOTOPEN);
  236.         return(OFAILURE);
  237.     }
  238.     ErrorReset();
  239.  
  240.     return(OSUCCESS);
  241. }
  242.  
  243. // helper routine for all the routines that return an object...
  244. oresult OOracleObject::ActionGetStart(const OOracleObject *nobj) const
  245. {
  246.     if (!IsOpen())
  247.     {
  248.         SetInternalError(OERROR_NOTOPEN);
  249.         nobj->SetInternalError(OERROR_INVPARENT);
  250.         return(OFAILURE);
  251.     }
  252.     ErrorReset();
  253.  
  254.     return(OSUCCESS);
  255. }
  256.  
  257. void OOracleObject::ErrorReset(void) const
  258. {
  259.     // we need non-const version of "this" for manipulating error state
  260.     OOracleObject *op = (OOracleObject *) this;
  261.     
  262.     if (m_erri)
  263.     {
  264.         ((_IExDispatch *) m_erri)->Reset();
  265.     }
  266.     
  267.     if (m_errotheri)
  268.     {   // release other error interface (we don't need it anymore)
  269.         ((_IExDispatch *) m_errotheri)->Release();
  270.         op->m_errotheri = 0;
  271.     }
  272.     
  273.     if (m_lasterrstring)
  274.     {
  275.         OObjectFreeString(m_lasterrstring);
  276.         op->m_lasterrstring = 0;
  277.     }
  278.     
  279.     op->m_errstate = OERROR_OBJECT;
  280.     op->m_errno = OERROR_NONE;
  281.     
  282.     return;   
  283. }
  284.  
  285. void OOracleObject::SetOtherError(void *otheri) const
  286. {
  287.     // we need non-const version of "this" for manipulating error state
  288.     OOracleObject *op = (OOracleObject *) this;
  289.     
  290.     if (m_errotheri)
  291.     {   // release old other error interface (we don't need it anymore)
  292.         ((_IExDispatch *) m_errotheri)->Release();
  293.         op->m_errotheri = 0;
  294.     }
  295.     
  296.     if (m_lasterrstring)
  297.     {
  298.         OObjectFreeString(m_lasterrstring);
  299.         op->m_lasterrstring = 0;
  300.     }
  301.     
  302.     // try to get other error interface
  303.     HRESULT hc;
  304.     void *errotheri;
  305.     hc = ((IDispatch *) otheri)->QueryInterface(IID_IExDispatch, &errotheri);
  306.     if (FAILED(hc))
  307.     {// yikes! now we don't have the proper error info at all!
  308.         // we'd better not ever get here...
  309.         op->m_errotheri = 0; // to be sure 
  310.         
  311.         // set error condition
  312.         SetInternalError(OERROR_NOINTER);
  313.     }
  314.     else
  315.     { // we got the error interface
  316.         op->m_errotheri = errotheri;
  317.         op->m_errstate = OERROR_OTHER;
  318.         op->m_errno = OERROR_NONE;  // actual error is contained in the other interface
  319.     }
  320.     
  321.     return;
  322. }
  323.  
  324. void OOracleObject::SetInternalError(long errno) const
  325. {
  326.     // we need non-const version of "this" for manipulating error state
  327.     OOracleObject *op = (OOracleObject *) this;
  328.     
  329.     if (m_errotheri)
  330.     {   // release other error interface (we don't need it anymore)
  331.         ((_IExDispatch *) m_errotheri)->Release();
  332.         op->m_errotheri = 0;
  333.     }
  334.     
  335.     if (m_lasterrstring)
  336.     {
  337.         OObjectFreeString(m_lasterrstring);
  338.         op->m_lasterrstring = 0;
  339.     }
  340.     
  341.     op->m_errstate = OERROR_INTERNAL;
  342.     op->m_errno = errno;
  343.     
  344.     return;
  345. }
  346.  
  347. long OOracleObject::ErrorNumber(void) const
  348. {
  349.     // note that just because m_errno contains OERROR_NONE doesn't mean that
  350.     // there is no error.  If the errstate is OERROR_OBJECT or OERROR_OTHER there
  351.     // may be an error in the interface we don't know about yet
  352.     
  353.     long errno = 0;
  354.     HRESULT hr;
  355.  
  356.     if (m_errstate == OERROR_INTERNAL)
  357.     { // internal error condition
  358.         return(m_errno);
  359.     }
  360.     else if (m_errstate == OERROR_OBJECT)
  361.     {
  362.         if (m_erri)
  363.         {
  364.             hr = ((_IExDispatch *) m_erri)->get_ResultCode();
  365.             long scode = GetScode(hr);
  366.             if (SUCCEEDED(scode))
  367.                 errno = OERROR_NONE;
  368.             else
  369.             { // try to translate the error
  370.                 // what facility is this?
  371.                 if (SCODE_FACILITY(scode) == 4)
  372.                 { // this is interface-specific errors, that's us
  373.                     errno = SCODE_CODE(scode);
  374.                 }
  375.                 else // some other facility - just return generic "implementation" error
  376.                     errno = OERROR_SYSTEM;
  377.             }
  378.         }
  379.         else
  380.         { // must be object that doesn't have error interface
  381.             errno = m_errno;
  382.         }
  383.     }
  384.     else if (m_errstate == OERROR_OTHER && m_errotheri)
  385.     {
  386.         hr = ((_IExDispatch *) m_errotheri)->get_ResultCode();
  387.         long scode = GetScode(hr);
  388.         if (SUCCEEDED(scode))
  389.             errno = OERROR_NONE;
  390.         else
  391.         {
  392.             if (SCODE_FACILITY(scode) == 4)
  393.             { // this is interface-specific errors, that's us
  394.                 errno = SCODE_CODE(scode);
  395.             }
  396.             else // some other facility - just return generic "implementation" error
  397.                 errno = OERROR_SYSTEM;
  398.         }
  399.     }
  400.     else
  401.     { // error state indicated an interface that is gone!
  402.         errno = OERROR_BADERR;
  403.     }    
  404.     
  405.     return(errno);
  406. }
  407.  
  408. // BUG #262914
  409. const char *OOracleObject::LookupErrorText(long errno) const
  410. {
  411.     // we need non-const version of "this" for manipulating error state
  412.     OOracleObject *op = (OOracleObject *) this;
  413.     
  414.     // any such text message should be obtainable from the error object (?)
  415.     if (m_erri)
  416.     {
  417.         if (m_lasterrstring)
  418.         {  // we've already got a string - free it
  419.             OObjectFreeString(m_lasterrstring);
  420.             op->m_lasterrstring = 0;
  421.         }
  422.  
  423.         op->m_lasterrstring = ((_IExDispatch *) m_erri)->LookupScodeText(errno);
  424.         return(m_lasterrstring ? m_lasterrstring : "");
  425.     }
  426.     else
  427. // BUG #262912
  428.         return("");       
  429. }
  430.  
  431. // BUG #262914
  432. const char *OOracleObject::GetErrorText(void) const
  433. {
  434.     // we need non-const version of "this" for manipulating error state
  435.     OOracleObject *op = (OOracleObject *) this;
  436.     
  437.     if (m_lasterrstring)
  438.     {  // we've already got a string - free it
  439.         OObjectFreeString(m_lasterrstring);
  440.         op->m_lasterrstring = 0;
  441.     }
  442.  
  443.     if (m_errstate == OERROR_INTERNAL)
  444.     { // internal error condition
  445.         op->m_lasterrstring = 0;
  446.     }
  447.     else if (m_errstate == OERROR_OBJECT)
  448.     {
  449.         if (m_erri)
  450.             op->m_lasterrstring = ((_IExDispatch *) m_erri)->get_ResultText();
  451.         else
  452.             op->m_lasterrstring = 0;  // object with no error interface
  453.     }
  454.     else if (m_errstate == OERROR_OTHER && m_errotheri)
  455.     {
  456.         op->m_lasterrstring = ((_IExDispatch *) m_errotheri)->get_ResultText();
  457.     }
  458.     else
  459.     { // error state indicated an interface that is gone!
  460.         op->m_lasterrstring = 0;
  461.     }
  462.     
  463. // BUG #262912
  464.     return(m_lasterrstring ? m_lasterrstring : "");   
  465. }
  466.  
  467.  
  468.  
  469.  
  470.  
  471.  
  472.