home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / object10 / obound.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-13  |  25.3 KB  |  1,004 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 OBinder and OBound classes
  13.                            
  14.     CREATED    ********   11/22/94
  15.     RWOOLARD    MODIFIED    03/20/95
  16.                 bug#    262162    IsChanged() not correct following Refresh()
  17.                         266266    m_fieldname being initialized to 0
  18.                         266270    BindToBinder(NULL, "ename") causes GPF 
  19.                         266277    BindToBinder(&bind, NULL) returns success
  20.                         267021    UnBindObj(NULL, TRUE) causes GPF
  21. */
  22.  
  23. #include "windows.h"
  24. #include <ole2.h>
  25. #include <olenls.h>       
  26. #include <dispatch.h>  
  27.  
  28. #ifndef OBOUND_ORACLE
  29. #include "OBound.h"
  30. #endif
  31.  
  32. #ifndef ORAOBJI_ORACLE
  33. #include "oraobji.h"
  34. #endif
  35.  
  36. // ----- OBinderAdvise -----------------------------------------------
  37. // this is a helper for OBinder
  38.  
  39. class OBinderAdvise : public OAdvise
  40. {
  41. public:
  42.     OBinderAdvise(OBinder *parent = NULL) {m_binder = parent;}
  43.     
  44.     // on requests and notifys call trigger routines in OBinder and OBound
  45.     oboolean ActionRequest(int movekind);
  46.     void    ActionNotify(int movekind);
  47.     
  48. private:
  49.     OBinder *m_binder;
  50.        
  51. };
  52.  
  53. // ----- OBound -----------------------------------------------
  54.  
  55. OBound::OBound(void)
  56. {
  57. // BUG #266266
  58.     m_fieldname = OObjectAllocString ("");
  59.     m_changed = FALSE;
  60.     m_binder = 0;
  61.     m_fieldindex = -1;  // invalid index
  62. }
  63.  
  64. OBound::~OBound(void)
  65. {
  66.     if (m_fieldname)
  67.         OObjectFreeString(m_fieldname);
  68.     
  69.     // make sure our binder knows we're gone
  70.     if (m_binder)
  71.         m_binder->UnbindObj(this, TRUE);
  72. }
  73.  
  74. oresult OBound::Unbind(void)
  75. { 
  76.     if (m_binder)
  77.     {
  78.         oresult ores = m_binder->UnbindObj(this, FALSE);
  79.         if (ores == OSUCCESS)
  80.         {
  81.             m_binder = 0;
  82.             return(OSUCCESS);
  83.         }
  84.         else
  85.             return(OFAILURE);
  86.     }
  87.     else    
  88.         return(OSUCCESS); // already unbound
  89. }
  90.  
  91. oresult OBound::GetValue(OValue *val)
  92. {
  93.     if (m_binder)
  94.         return(m_binder->GetFieldValue(m_fieldindex, val));
  95.     else
  96.         return(OFAILURE);
  97. }
  98.  
  99. oresult OBound::SetValue(const OValue &val)
  100. {
  101.     if (m_binder)
  102.         return(m_binder->SetFieldValue(m_fieldindex, val));
  103.     else
  104.         return(OFAILURE);
  105. }
  106.  
  107. const char *OBound::GetName(void) const
  108. {
  109.     return(m_fieldname);  // this is NULL if we haven't done BindToBinder yet
  110. }
  111.  
  112. ODatabase OBound::GetDatabase(void) const
  113. {
  114.     if (m_binder)
  115.         return(m_binder->GetDatabase());
  116.     else
  117.     { // return closed database
  118.         ODatabase odb;
  119.         return(odb);
  120.     }
  121. }
  122.  
  123. ODynaset OBound::GetDynaset(void) const
  124. {
  125.     if (m_binder)
  126.         return(m_binder->GetDynaset());
  127.     else
  128.     { // return closed dynaset
  129.         ODynaset dyn;
  130.         return(dyn);
  131.     }
  132. }
  133.     
  134. oresult OBound::GetFieldIndex(void)
  135. {
  136.     if (m_binder)
  137.         return(m_binder->GetFieldIndex(&m_fieldindex, m_fieldname));
  138.     else
  139.         return(OFAILURE);
  140. }
  141.  
  142. oresult OBound::BindToBinder(OBinder *binder, const char *fieldname)
  143. {   
  144. // BUG #266270 and 266277
  145.     if (!binder || !fieldname)
  146.     {
  147.         // Set error here when error handling code is available
  148.         return(OFAILURE);
  149.     }
  150.         
  151.     if (m_binder)
  152.     { // we're already bound - try to unbind
  153.         if (m_binder->UnbindObj(this, FALSE) != OSUCCESS)
  154.             return(OFAILURE);
  155.         m_binder = 0;
  156.     }
  157.     
  158.     // remember field name
  159.     if (m_fieldname)
  160.         OObjectFreeString(m_fieldname);
  161.     m_fieldname = OObjectAllocString(fieldname);
  162.     
  163.     // remember containing binder
  164.     m_binder = binder;
  165.     
  166.     return(m_binder->AddObjectToOBinder(this));
  167. }
  168.  
  169. oresult OBound::SaveChangeBound(void)
  170. {
  171.     if (!m_changed)
  172.         return(OSUCCESS);  // don't even call subclass
  173.     
  174.     return(SaveChange());  // do the real work
  175. }
  176.  
  177. oresult OBound::RefreshBound(void)
  178. {
  179.     if (!m_binder || m_fieldindex < 0)
  180.         return(OFAILURE);  // can't get the value
  181.     
  182.     // get the new data
  183.     OValue val;
  184.     m_binder->GetFieldValue(m_fieldindex,&val);
  185.     
  186.     // call subclass to do the work
  187.     oresult ores = Refresh(val);
  188.     
  189.     if (ores == OSUCCESS)
  190.         m_changed = FALSE;  // new value means we haven't got any changes
  191.     
  192.     return(ores);
  193. }
  194.  
  195. oresult OBound::Changed(oboolean changed) 
  196. {
  197.     if ((changed && m_changed) || (!changed && !m_changed))
  198.         return(OSUCCESS);  // we already know this
  199.     
  200.     if (changed && m_binder)
  201.     { // try to start change in dynaset (will do a StartEdit, which may fail)
  202.         if (m_binder->Changed(TRUE) != OSUCCESS)
  203.             return(OFAILURE);
  204.     }
  205.     
  206.     m_changed = changed;  // remember changed-ness
  207.         
  208.     return(OSUCCESS);
  209. } 
  210.  
  211. oboolean OBound::IsChanged(void) const
  212. {
  213.     return(m_changed);
  214. }
  215.  
  216. oresult OBound::UnbindNotify(void)
  217. {
  218.     // the binder is letting go of us
  219.     m_binder = 0;
  220.     
  221.     return(OSUCCESS);
  222. }
  223.  
  224. oresult OBound::ClearChange(void)
  225. {
  226.     // the binder is telling us that the change has been saved
  227.     Changed(FALSE);
  228.     return(OSUCCESS);
  229. }
  230.  
  231. // default trigger implementations
  232. oresult OBound::Startup(void)
  233. {return OSUCCESS;}
  234.  
  235. oresult OBound::Shutdown(void)
  236. {return OSUCCESS;}
  237.  
  238. oresult OBound::PreQuery(void)
  239. {return OSUCCESS;}
  240.  
  241. oresult OBound::PostQuery(void)
  242. {return RefreshBound();}
  243.  
  244. oresult OBound::PreDelete(void)
  245. {return OSUCCESS;}
  246.  
  247. oresult OBound::PostDelete(void)
  248. {return OSUCCESS;}
  249.  
  250. oresult OBound::PreAdd(void)
  251. {return OSUCCESS;}
  252.  
  253. oresult OBound::PostAdd(void)
  254. {return RefreshBound();}
  255.  
  256. oresult OBound::PreUpdate(void)
  257. {return OSUCCESS;}
  258.  
  259. oresult OBound::PostUpdate(void)
  260. {return OSUCCESS;}
  261.  
  262. oresult OBound::PreRollback(void)
  263. {return OSUCCESS;}
  264.  
  265. oresult OBound::PostRollback(void)
  266. {return RefreshBound();}
  267.  
  268. oresult OBound::PreMove(void)
  269. {return OSUCCESS;}
  270.  
  271. oresult OBound::PostMove(void)
  272. {return RefreshBound();}
  273.  
  274. // ----- OBinder -----------------------------------------------
  275.  
  276. // # of OBound pointers in each chunk
  277. #define OBinder_NBOUND 30
  278.  
  279. OBinder::OBinder(void)
  280. {
  281.     m_boundlist = 0;
  282.     m_advise = 0;
  283.    
  284.     m_changed = FALSE;
  285.     m_nbound = 0;   // # of bound objects
  286.  
  287.     m_schangeerr = 0;
  288.     m_changeerr = OERROR_NONE;
  289. }
  290.  
  291. OBinder::~OBinder(void)
  292. {
  293.     Close(FALSE);  // close, but don't fire shutdown triggers
  294. }
  295.  
  296. oresult OBinder::Close(oboolean doShutdown)
  297. {
  298.     if (doShutdown)
  299.     {  // fire shutdown triggers
  300.         if (OSUCCESS != Shutdown())
  301.             return(OFAILURE);
  302.         if (OSUCCESS != DoAllObjects(OBound::Shutdown))
  303.             return(OFAILURE);
  304.     }
  305.     
  306.     // tell all bound objects that they aren't bound anymore
  307.     DoAllObjects(OBound::UnbindNotify);
  308.     
  309.     // clean up the binder object
  310.     
  311.     // get rid of advisory sink
  312.     delete (OBinderAdvise *) m_advise;
  313.     m_advise = 0;
  314.     
  315.     // delete the list of bound objects
  316.     //  note that we are only deleting our pointers.  We don't delete the objects
  317.     OBound **curchunk;
  318.     OBound **nextchunk;
  319.     
  320.     curchunk = m_boundlist;
  321.     while (curchunk)
  322.     {
  323.         nextchunk = (OBound **) *(curchunk+(OBinder_NBOUND-1));
  324.         delete [] curchunk;
  325.         curchunk = nextchunk;
  326.     }
  327.     m_boundlist = 0;
  328.     m_nbound = 0;
  329.     m_changed = FALSE;
  330.     
  331.     return(OSUCCESS);      
  332. }
  333.  
  334. // routine to have all bound objects refresh their values
  335. oresult OBinder::Refresh(void)
  336. {
  337.     oresult ores = DoAllObjects(&OBound::RefreshBound);
  338. //BUG #262162    
  339.     if (ores == OSUCCESS)
  340.         m_changed = FALSE;
  341.     return ores;
  342. }
  343.  
  344. // routine called by bound object to get its field index
  345. oresult OBinder::GetFieldIndex(int *ofldi, const char *fieldname)
  346. {
  347.     // get field index
  348.     *ofldi = m_dynaset.GetFieldIndex(fieldname);
  349.     return(*ofldi >= 0 ? OSUCCESS : OFAILURE);   
  350. }
  351.  
  352. oresult OBinder::AddObjectToOBinder(OBound *object)
  353. {
  354.     /*
  355.         We keep pointers to the bound objects in a linked list
  356.         of chunks of pointers.  Each chunk contains OBinder_NBOUND-1 pointers
  357.         and a pointer to the next chunk.  This is a "fat" linked list.
  358.     */
  359.     
  360.     int ii;
  361.     OBound **op;
  362.     
  363.     if (!m_boundlist)
  364.     { // start the binder
  365.         
  366.         // allocate first chunk of bound object list
  367.         m_boundlist = new OBound *[OBinder_NBOUND];
  368.         if (!m_boundlist)
  369.             return(OFAILURE);  // no memory!
  370.         
  371.         // make sure all the pointers are 0
  372.         for (ii=0, op=m_boundlist; ii<OBinder_NBOUND; ii++, op++)
  373.             *op = 0;          
  374.  
  375.         // call the startup trigger
  376.         if (Startup() != OSUCCESS)
  377.             return(OFAILURE);       
  378.     }
  379.     
  380.     // scan through list to find all the objects.  We want to place ours after
  381.     //   all the already bound objects
  382.     op = m_boundlist;
  383.     int nfound = 0;
  384.     while(1)
  385.     {
  386.         for (ii=0; ii<OBinder_NBOUND-1; ii++, op++)
  387.         {
  388.             if (*op)
  389.                 nfound++;
  390.             else if (nfound >= m_nbound)
  391.                 break;  // found a zero pointer after all set pointers
  392.         }
  393.         
  394.         if (ii < OBinder_NBOUND-1)
  395.             break; // we found a spot
  396.         
  397.         // go to the next chunk
  398.         if (!*op)
  399.         { // next chunk isn't allocated yet - do it
  400.             *op = (OBound *) new OBound *[OBinder_NBOUND];
  401.             OBound **op2;
  402.             for (ii=0, op2 = (OBound **) (*op); ii<OBinder_NBOUND; ii++, op2++)
  403.                 *op2 = 0;  // make sure all the pointers are zeroed
  404.         }
  405.         
  406.         op = (OBound **) (*op); // point at beginning of next chunk
  407.     }
  408.     
  409.     // now op is pointing at an open spot
  410.     *op = object; 
  411.     m_nbound++;
  412.     
  413.     oresult ores = OSUCCESS;
  414.     if (m_dynaset.IsOpen())
  415.     {
  416.         ores = object->GetFieldIndex();  // have object get its field index
  417.         object->Startup();   // fire startup trigger for object
  418.         /*
  419.          * This line was commented out of the original code, but I think it should be
  420.          * there to give the value to an object that is being bound to an alraedy open dynaset.
  421.          * Suspect this line of code if OBinder starts to fail mysteriously
  422.          */
  423.         // object->RefreshBound();   // give the object its value
  424.     }
  425.     else
  426.         object->Startup();  // just fire startup trigger
  427.     
  428.     return (ores);    
  429. }
  430.  
  431. oresult OBinder::Open(const char *dbname, const char *username, const char *pwd, const char *sqls, long dynoptions)
  432. {
  433.     // open the database with the given arguments
  434.     oresult ores = m_database.Open(dbname, username, pwd);
  435.     
  436.     // and call the database version of the open method
  437.     if (ores == OSUCCESS)
  438.         ores = Open(m_database, sqls, dynoptions);
  439.     
  440.     return(ores);   
  441. }
  442.  
  443. oresult OBinder::Open(const ODatabase &odb, const char *sqls, long dynoptions)
  444. {
  445.     if (m_dynaset.IsOpen())
  446.     { // open on old database - close it
  447.         delete (OBinderAdvise *) m_advise;  // get rid of invalid advisory
  448.         m_advise = 0;
  449.         if (m_dynaset.Close() != OSUCCESS)
  450.             return(OFAILURE);
  451.     }
  452.     
  453.     // copy the database
  454.     m_database = odb;
  455.     if (!m_database.IsOpen())
  456.         return(OFAILURE);  // not a whole lot we can do
  457.     
  458.     if (!sqls)
  459.     { // caller hasn't specified a sql statement - we won't do a query
  460.         return(OSUCCESS);
  461.     }
  462.     
  463.     // call pre-action triggers
  464.     if (PreQuery() != OSUCCESS)
  465.         return(OFAILURE);
  466.     if (DoAllObjects(&OBound::PreQuery) != OSUCCESS)
  467.         return(OFAILURE);
  468.     
  469.     // create new dynaset and advice sink
  470.  
  471.     // open dynaset and move to first record
  472.     if (m_dynaset.Open(odb, sqls, dynoptions) != OSUCCESS)
  473.         return(OFAILURE); // couldn't open dynaset
  474.     
  475.     m_advise = (void *) new OBinderAdvise(this);
  476.     if (OSUCCESS != ((OBinderAdvise *) m_advise)->Open(m_dynaset))
  477.         return(OFAILURE);  // couldn't attach advisory
  478.     
  479.     // have all the bound objects get their field indices
  480.     DoAllObjects(&OBound::GetFieldIndex);        
  481.     
  482.     // post action triggers
  483.     if (PostQuery() != OSUCCESS)
  484.         return(OFAILURE);
  485.     if (DoAllObjects(&OBound::PostQuery) != OSUCCESS)   // by default, refreshes
  486.         return(OFAILURE);
  487.     
  488.     return(OSUCCESS);
  489. }
  490.  
  491. // navigational methods
  492. oresult OBinder::MoveFirst(void)
  493. {
  494.     return(m_dynaset.MoveFirst());
  495. }
  496.  
  497. oresult OBinder::MoveLast(void)
  498. {
  499.     return(m_dynaset.MoveLast());
  500. }
  501.  
  502. oresult OBinder::MoveNext(void)
  503. {
  504.     return(m_dynaset.MoveNext(FALSE));  // bounded move
  505. }
  506.  
  507. oresult OBinder::MovePrev(void)
  508. {
  509.     return(m_dynaset.MovePrev(FALSE));  // bounded move
  510. }
  511.  
  512. oresult OBinder::MoveToMark(const ODynasetMark &mark)
  513. {
  514.     return(m_dynaset.MoveToMark(mark));
  515. }
  516.  
  517. //BUG #262553
  518. oboolean OBinder::CanMark(void) const 
  519. {
  520.     return m_dynaset.CanMark();
  521. }
  522.  
  523. ODynasetMark OBinder::GetMark(void) const 
  524. {
  525.     return m_dynaset.GetMark();
  526. }  // bookmark at current position
  527.  
  528. ODynasetMark OBinder::GetLastModifiedMark(void) const 
  529. {
  530.     return m_dynaset.GetLastModifiedMark();    // get bookmark at last modified record
  531. }
  532.  
  533. // set SQL for the next query
  534. oresult OBinder::SetSQL(const char *sqls)
  535. {
  536.     if (!m_dynaset.IsOpen())
  537.     { // really open now that we have sql statement
  538.         return(Open(m_database, sqls));
  539.     }
  540.     else
  541.         return(m_dynaset.SetSQL(sqls));
  542. }
  543.  
  544. //BUG #262553
  545. const char * OBinder::GetSQL(void) const
  546. {
  547.     return m_dynaset.GetSQL();
  548. }  // gets sql statement
  549.  
  550. oresult OBinder::RefreshQuery(void)
  551. {
  552.     if (!m_dynaset.IsOpen())
  553.         return(OFAILURE);
  554.     return(m_dynaset.Refresh());
  555.     
  556.     // triggers fired in advisory
  557. }
  558.  
  559. const ODynaset OBinder::GetDynaset(void) const
  560. {
  561.     return(m_dynaset);
  562. }
  563.  
  564. const ODatabase OBinder::GetDatabase(void) const
  565. {
  566.     return(m_database);
  567. }
  568.  
  569. oboolean OBinder::IsChanged(void) const
  570. {
  571.     return m_changed;
  572. }
  573.  
  574. //BUG #262553
  575. oboolean OBinder::IsOpen(void) 
  576. {
  577.     return m_dynaset.IsOpen();
  578. }
  579.  
  580. oresult OBinder::GetFieldValue(int index, OValue *val) const
  581. {
  582.     return(m_dynaset.GetFieldValue(index, val));
  583. }
  584.  
  585. oresult OBinder::SetFieldValue(int index, const OValue &val)
  586. {
  587.     return(m_dynaset.SetFieldValue(index, val));
  588. }
  589.  
  590. oresult OBinder::DeleteRecord(void)
  591. {
  592.     if (!m_dynaset.IsOpen())
  593.         return(OFAILURE);  // can't delete record - no dynaset
  594.     
  595.     // delete the record
  596.     m_dynaset.DeleteRecord();
  597.     
  598.     // now move off the deleted record
  599.     m_dynaset.MoveNext();  // just to get off deleted record
  600.     if (m_dynaset.IsEOF())
  601.     { // whoops - we moved past last.  Backup
  602.         m_dynaset.MovePrev();
  603.         // if we've deleted the last record we're now on an invalid record
  604.     }
  605.     
  606.     return(OSUCCESS);
  607. }
  608.  
  609. oresult OBinder::AddNewRecord(void)
  610. {
  611.     if (!m_dynaset.IsOpen())
  612.         return(OFAILURE);
  613.    
  614.     if (m_dynaset.AddNewRecord() != OSUCCESS)
  615.         return(OFAILURE);
  616.     
  617.     // now call postadd triggers       
  618.     if (PostAdd() != OSUCCESS)
  619.         return(OFAILURE);
  620.     if (DoAllObjects(OBound::PostAdd) != OSUCCESS)
  621.         return(OFAILURE);
  622.     
  623.     return(OSUCCESS);
  624. }
  625.  
  626. oresult OBinder::DuplicateRecord(void)
  627. {
  628.     if (!m_dynaset.IsOpen())
  629.         return(OFAILURE);
  630.    
  631.     if (m_dynaset.DuplicateRecord() != OSUCCESS)
  632.         return(OFAILURE);
  633.     
  634.     // now call postadd triggers       
  635.     if (PostAdd() != OSUCCESS)
  636.         return(OFAILURE);
  637.     if (DoAllObjects(OBound::PostAdd) != OSUCCESS)
  638.         return(OFAILURE);
  639.     
  640.     return(OSUCCESS);
  641. }
  642.  
  643. oresult OBinder::Changed(oboolean cflag)
  644. {
  645.     // clear the change error state
  646.     m_schangeerr = 0;
  647.     m_changeerr = OERROR_NONE;
  648.     
  649.     if (cflag && m_changed || !cflag && !m_changed)
  650.         return(OSUCCESS);  // no change from current state
  651.     
  652.     if (cflag && (m_dynaset.GetEditMode() == ODYNASET_EDIT_NOEDIT))
  653.     { // we're starting a change
  654.         if (m_dynaset.StartEdit() != OSUCCESS)
  655.         {
  656.             OnChangedError();
  657.             return(OFAILURE);  // we can't start the edit, for some reason
  658.         }
  659.     }
  660.     
  661.     m_changed = cflag;
  662.     
  663.     return(OSUCCESS);     
  664. }
  665.  
  666. void OBinder::OnChangedError(void)
  667. {
  668.     // remember the error we have
  669.     m_changeerr = m_dynaset.ErrorNumber();
  670.     m_schangeerr = m_dynaset.GetSession().ServerErrorNumber();
  671.     
  672.     return;
  673. }
  674.  
  675. oboolean OBinder::GetChangedError(long *serr, long *cerr) const
  676. {
  677.     if (serr)
  678.         *serr = m_schangeerr;
  679.     if (cerr)
  680.         *cerr = m_changeerr;
  681.     
  682.     return(m_schangeerr != 0 || m_changeerr != OERROR_NONE);
  683. }
  684.  
  685. // public way to save changes
  686. oresult OBinder::Update(void)
  687. {
  688.     return(SaveRecordChanges());
  689. }
  690.  
  691. // the way we throw away changes to the current record
  692. oresult OBinder::DiscardChanges(void)
  693. {
  694.     if (!IsChanged())
  695.         return(OSUCCESS);  // nothing to do 
  696.     
  697.     m_changed = FALSE;
  698.     
  699.     // we have done a StartEdit, but we haven't changed any field values yet
  700.     // so cancel the edit
  701.     if (m_dynaset.CancelEdit() != OSUCCESS)
  702.         return(OFAILURE);
  703.     
  704.     // tell all the bound objects to refresh
  705.     return(Refresh());
  706. }
  707.  
  708. oresult OBinder::DoAllObjects(oresult (OBound::*ff)(void))
  709. {
  710.     // just go through the list of objects and refresh them all
  711.     OBound **op = m_boundlist;
  712.     int      ii;
  713.     int      ndone = 0;
  714.     
  715.     while (op && ndone < m_nbound)
  716.     { // for all chunks
  717.         for (ii=0; ii<OBinder_NBOUND-1; ii++, op++)
  718.         { // for every pointer in this chunk
  719.             if (*op)
  720.             {
  721.                 if ((**op.*ff)() != OSUCCESS)
  722.                     return(OFAILURE);
  723.                 ndone++;
  724.                 if (ndone >= m_nbound)
  725.                     break;  // note that this makes op calculation below into nonsense
  726.             }
  727.         }
  728.         
  729.         // move to the next chunk
  730.         op = (OBound **) (*op); // point at beginning of next chunk
  731.     }
  732.     
  733.     return(OSUCCESS); 
  734. }
  735.  
  736. oresult OBinder::UnbindObj(OBound *object, oboolean nofail)
  737. {   
  738. //BUG #267021    
  739.     if (! object)
  740.     {
  741.         // Set error here when error handling code is available
  742.         return(OFAILURE);
  743.     }
  744.  
  745.     // just go through the list of objects and find the object to be unbound
  746.     OBound **op = m_boundlist;
  747.     int      ii;
  748.     
  749.     while (op)
  750.     { // for all chunks
  751.         for (ii=0; ii<OBinder_NBOUND-1; ii++, op++)
  752.         { // for every pointer in this chunk
  753.             if (*op == object)
  754.             {
  755.                 if (OSUCCESS != (*op)->Shutdown() && !nofail)
  756.                     return(OFAILURE);  // object doesn't want to go away
  757.                 (*op)->UnbindNotify();  // tell object it isn't bound anymore
  758.                 *op = 0;  // we don't free the object, just clear our pointer to it
  759.                 m_nbound--;
  760.                 break;
  761.             }
  762.             // note that we never free any memory - we keep all the chunks
  763.         }
  764.         
  765.         if (ii < OBinder_NBOUND-1)
  766.             break;  // we found the object
  767.         
  768.         // move to the next chunk
  769.         op = (OBound **) (*op); // point at beginning of next chunk
  770.     }
  771.     
  772.     return(OSUCCESS); 
  773. }
  774.  
  775. // private way to save changes
  776. oresult OBinder::SaveRecordChanges(void)
  777. {
  778.     // if there have been changes, save them
  779.     if (m_changed && m_dynaset.IsOpen())
  780.     { // save the change before we move
  781.         if (DoAllObjects(&OBound::SaveChangeBound) != OSUCCESS)        
  782.             return(OFAILURE);  // somebody didn't want to change
  783.         
  784.         if (m_dynaset.Update() != OSUCCESS) // as side effect, fires the update triggers
  785.         { 
  786.             return(OFAILURE);
  787.         }
  788.         m_changed = FALSE;
  789.         
  790.         // tell all bound objects that the changes have been saved
  791.         DoAllObjects(OBound::ClearChange);       
  792.     }
  793.     
  794.     return(OSUCCESS);
  795. }
  796.  
  797. // default trigger routines
  798. oresult OBinder::Startup(void)
  799. {return OSUCCESS;}
  800.  
  801. oresult OBinder::Shutdown(void)
  802. {
  803.     return(SaveRecordChanges());
  804. }
  805.  
  806. oresult OBinder::PreQuery(void)
  807. {return OSUCCESS;}
  808.  
  809. oresult OBinder::PostQuery(void)
  810. {return OSUCCESS;}
  811.  
  812. oresult OBinder::PreDelete(void)
  813. {return OSUCCESS;}
  814.  
  815. oresult OBinder::PostDelete(void)
  816. {return OSUCCESS;}
  817.  
  818. oresult OBinder::PreAdd(void)
  819. {
  820.     return(SaveRecordChanges());
  821. }
  822.  
  823. oresult OBinder::PostAdd(void)
  824. {return OSUCCESS;}
  825.  
  826. oresult OBinder::PreUpdate(void)
  827. {return OSUCCESS;}
  828.  
  829. oresult OBinder::PostUpdate(void)
  830. {return OSUCCESS;}
  831.  
  832. oresult OBinder::PreRollback(void)
  833. {return OSUCCESS;}
  834.  
  835. oresult OBinder::PostRollback(void)
  836. {return OSUCCESS;}
  837.  
  838. oresult OBinder::PreMove(void)
  839. { 
  840.     return(SaveRecordChanges());
  841. }
  842.  
  843. oresult OBinder::PostMove(void)
  844. {return OSUCCESS;}
  845.  
  846. oboolean OBinder::IsFirst(void)
  847. {
  848.     return m_dynaset.IsFirst ();
  849. }
  850.  
  851. oboolean OBinder::IsLast(void)
  852. {
  853.     return m_dynaset.IsLast ();
  854. }
  855.  
  856. //BUG #262553
  857. long OBinder::ErrorNumber(void) const 
  858. {    // return error "number"
  859.     return m_dynaset.ErrorNumber();
  860. }
  861.     
  862. const char *OBinder::LookupErrorText(long errnum) const 
  863. {    // get error text for given error number
  864.     return m_dynaset.LookupErrorText(errnum);
  865. }
  866.                                           
  867. const char *OBinder::GetErrorText(void) const 
  868. {    // get description of last error
  869.     return m_dynaset.GetErrorText();
  870. }
  871.  
  872. void OBinder::ErrorReset(void) const 
  873. {    // reset error state to "no error"
  874.     m_dynaset.ErrorReset();
  875. }  
  876.  
  877. int OBinder::GetFieldCount(void) const 
  878. {    // returns # of fields in a record
  879.     return m_dynaset.GetFieldCount();
  880. }
  881.   
  882. long OBinder::GetRecordCount(void) const 
  883. {   // (dangerous!) gets total number of records in dynaset -- downloads the entire dynaset to the client
  884.     return m_dynaset.GetRecordCount();
  885. }
  886.    
  887. int OBinder::GetFieldIndex(const char *fieldname) const 
  888. {    // gets the index of a field by name
  889.     return m_dynaset.GetFieldIndex(fieldname);
  890. }
  891.                                                     
  892.                                                     
  893. // ----- OBinderAdvise -----------------------------------------------
  894.  
  895. oboolean OBinderAdvise::ActionRequest(int otherkind)
  896. {
  897.     // fire pre-action triggers
  898.     
  899.     switch (otherkind)
  900.     {
  901.     case OADVISE_MOVE_FIRST:
  902.     case OADVISE_MOVE_NEXT:
  903.     case OADVISE_MOVE_PREV:
  904.     case OADVISE_MOVE_LAST:
  905.     case OADVISE_MOVE_TOMARK:
  906.         if (m_binder->PreMove() != OSUCCESS)
  907.             return(FALSE);
  908.         if (m_binder->DoAllObjects(OBound::PreMove) != OSUCCESS)
  909.             return(FALSE);
  910.         break;   
  911.     case OADVISE_DELETE:
  912.         if (m_binder->PreDelete() != OSUCCESS)
  913.             return(FALSE);
  914.         if (m_binder->DoAllObjects(OBound::PreDelete) != OSUCCESS)
  915.             return(FALSE);
  916.         break;
  917.     case OADVISE_ADDNEW:
  918.         if (m_binder->PreAdd() != OSUCCESS)
  919.             return(FALSE);
  920.         if (m_binder->DoAllObjects(OBound::PreAdd) != OSUCCESS)
  921.             return(FALSE);
  922.         break;    
  923.     case OADVISE_UPDATE:
  924.         if (m_binder->PreUpdate() != OSUCCESS)
  925.             return(FALSE);
  926.         if (m_binder->DoAllObjects(OBound::PreUpdate) != OSUCCESS)
  927.             return(FALSE);
  928.         break; 
  929.     case OADVISE_ROLLBACK:
  930.         if (m_binder->PreRollback() != OSUCCESS)
  931.             return(FALSE);
  932.         if (m_binder->DoAllObjects(OBound::PreRollback) != OSUCCESS)
  933.             return(FALSE);
  934.         break;
  935.     case OADVISE_REFRESH:
  936.         if (m_binder->PreQuery() != OSUCCESS)
  937.             return(FALSE);
  938.         if (m_binder->DoAllObjects(OBound::PreQuery) != OSUCCESS)
  939.             return(FALSE);
  940.         break;
  941.     default:
  942.         // unknown triggers 
  943.         int ii = 3;
  944.         break;
  945.     }
  946.     
  947.     return(TRUE);
  948. }
  949.  
  950. void OBinderAdvise::ActionNotify(int otherkind)
  951. {
  952.     // fire post-action triggers
  953.     
  954.     switch (otherkind)
  955.     {
  956.     case OADVISE_MOVE_FIRST:
  957.     case OADVISE_MOVE_NEXT:
  958.     case OADVISE_MOVE_PREV:
  959.     case OADVISE_MOVE_LAST:
  960.     case OADVISE_MOVE_TOMARK:
  961.         if (m_binder->PostMove() != OSUCCESS)
  962.             return;
  963.         m_binder->DoAllObjects(OBound::PostMove);
  964.         break;   
  965.     case OADVISE_DELETE:
  966.         if (m_binder->PostDelete() != OSUCCESS)
  967.             return;
  968.         m_binder->DoAllObjects(OBound::PostDelete);
  969.         break;
  970.     case OADVISE_ADDNEW:
  971.         // the postadd triggers are called directly from AddNewRecord
  972.         //   and Duplicate record.  That's so the trigger is called AFTER
  973.         //   all the dynaset (and in the case of duplicate ODynaset) work
  974.         //   is completely done 
  975.         break;
  976.     case OADVISE_UPDATE:
  977.         if (m_binder->PostUpdate() != OSUCCESS)
  978.             return;
  979.         m_binder->DoAllObjects(OBound::PostUpdate);
  980.         break;
  981.     case OADVISE_ROLLBACK:
  982.         m_binder->Changed(FALSE);  // rollback means changes are gone
  983.         // tell all bound objects that the changes are gone
  984.         m_binder->DoAllObjects(OBound::ClearChange);
  985.                
  986.         if (m_binder->PostRollback() != OSUCCESS)
  987.             return;
  988.         m_binder->DoAllObjects(OBound::PostRollback);
  989.         break;
  990.     case OADVISE_REFRESH:
  991.         m_binder->DoAllObjects(&OBound::GetFieldIndex); // have all the bound objects get their field indices again 
  992.         // is a new field set needed?       
  993.         if (m_binder->PostQuery() != OSUCCESS)
  994.             return;
  995.         m_binder->DoAllObjects(OBound::PostQuery);
  996.         break;
  997.     default:
  998.         // unknown triggers
  999.         break;
  1000.     }
  1001.     
  1002.     return;
  1003. }
  1004.