home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / object10 / obound.h < prev    next >
C/C++ Source or Header  |  1995-04-04  |  13KB  |  332 lines
  1. /* Copyright (c) Oracle Corporation 1994.  All Rights Reserved */
  2. /* Copyright (c) Oracle Corporation 1994.  All Rights Reserved */
  3.  
  4. /*
  5.     This source code is provided as a debugging aid for developers
  6.     who have purchased Oracle Objects for OLE    .  Please see the
  7.     online help for documentation of these classes.
  8. */
  9.  
  10. /*
  11.     Oracle Objects for OLE     C++ Classes
  12.     
  13.     This file is the header for the OBound and OBinder classes
  14.                            
  15.     CREATED    ********   11/22/94
  16.     RWOOLARD    MODIFIED    03/20/95
  17.                 bug#    262553    Added more methods to access the bound dynaset
  18. */
  19.  
  20. #ifndef OBOUND_ORACLE
  21. #define OBOUND_ORACLE
  22.  
  23. #ifndef ORACL_ORACLE
  24. #include "oracl.h"
  25. #endif
  26.  
  27. // declarations for forward references
  28. class OBinderAdvise;
  29. class OEXPORT OBinder;
  30.  
  31. // ----- OBound -----------------------------------------------
  32.  
  33. class OEXPORT OHUGESP OBound
  34. {
  35.     friend class OBinder;
  36.     friend class OBinderAdvise;
  37.  
  38. public:
  39.     OBound(void);
  40.     ~OBound(void);
  41.     
  42.     // to attach bound object to a binder
  43.     oresult BindToBinder(OBinder *binder, const char *fieldname);
  44.     // to detach
  45.     oresult Unbind(void); 
  46.  
  47.     oresult Changed(oboolean changed = TRUE);
  48.     
  49.     const char *GetName(void) const;  // get name of field we're attached to
  50.     ODatabase GetDatabase(void) const;
  51.     ODynaset GetDynaset(void) const;
  52.     
  53.     oboolean IsChanged(void) const;
  54.     
  55.     // declarations of methods so that compiler won't implement these (which would be wrong)
  56.     // at present we don't implement these either...
  57.     OBound(const OBound &other);  // copy constructor
  58.     OBound &operator=(const OBound &other);  // overloaded assignment
  59.     
  60. protected:
  61.     // helper routines for subclasses
  62.     oresult GetValue(OValue *val);       // get current value from database
  63.     oresult SetValue(const OValue &val); // set value in database
  64.     oresult RefreshBound(void);              // get value and call Refresh method
  65.     
  66.     // routines subclasses need to implement
  67.     virtual oresult Refresh(const OValue &val) = 0;  // database -> bound
  68.     virtual oresult SaveChange(void) = 0;  // bound -> database
  69.  
  70. private:
  71.     oboolean m_changed;     // flag indicating we've had a change
  72.     OBinder *m_binder;      // pointer to containing binder
  73.     char    *m_fieldname;   // name of field we're bound to
  74.     int      m_fieldindex;  // index of field we're bound to
  75.     
  76.     oresult SaveChangeBound(void);    
  77.     oresult GetFieldIndex(void);
  78.     oresult UnbindNotify(void); 
  79.     
  80.     oresult ClearChange(void);
  81.  
  82. protected:    
  83.     /*
  84.         Triggers.  These routines are called by OBinder.  At some in OBinder
  85.         these triggers will be fired for all of the objects in a binder.  The
  86.         triggers fire after the corresponding binder triggers (with the exception
  87.         of the Startup and Shutdown triggers). The firing order of the bound objects
  88.         is the order that they were bound to the binder.  If any trigger in a binder
  89.         does not return OSUCCESS, processing will be halted.
  90.         
  91.         The routines are all listed below as
  92.         method
  93.         Fired:  when the trigger fires
  94.         Default: the action taken by the base OBound class method
  95.     */
  96.     virtual oresult Startup(void);
  97.     // Fired: immediately after bound object is bound to binder.  If the binder has not
  98.     //        been opened then GetValue can't be called  
  99.     // Default: no action
  100.     virtual oresult Shutdown(void);
  101.     // Fired: when bound object is unbound from binder, either by an explicit call to
  102.     //        OBinder::UnbindObject or when OBinder::Close is called
  103.     // Default: no action
  104.     virtual oresult PreQuery(void);
  105.     // Fired: before the SQL statement is executed
  106.     // Default: no action
  107.     virtual oresult PostQuery(void);
  108.     // Fired: after SQL statement is executed and new bindings are established
  109.     // Default: refreshes bound object 
  110.     virtual oresult PreDelete(void);
  111.     // Fired: before record is deleted
  112.     // Default: no action
  113.     virtual oresult PostDelete(void);
  114.     // Fired: after record is deleted (but not committed to database)
  115.     // Default: no action
  116.     virtual oresult PreAdd(void);
  117.     // Fired: before new record is added
  118.     // Default: no action
  119.     virtual oresult PostAdd(void);
  120.     // Fired: after a new record is added
  121.     // Default: refreshes bound object - value will generally be NULL
  122.     virtual oresult PreUpdate(void);
  123.     // Fired: just before database is updated
  124.     // Default: no action
  125.     virtual oresult PostUpdate(void);
  126.     // Fired: immediately after database is updated
  127.     // Default: no action
  128.     virtual oresult PreRollback(void);
  129.     // Fired: immediately before a rollback is attempted
  130.     // Default: no action
  131.     virtual oresult PostRollback(void);
  132.     // Fired: immediately after a rollback
  133.     // Default: refresh bound object 
  134.     virtual oresult PreMove(void);
  135.     // Fired: before OBinder moves to a new record
  136.     // Default: no action
  137.     virtual oresult PostMove(void);
  138.     // Fired: after OBinder moves to a new record
  139.     // Default: refreshes bound object 
  140.  
  141. };
  142.  
  143. // ----- OBinder -----------------------------------------------
  144.  
  145. class OEXPORT OBinder
  146. {
  147.     friend class OBinderAdvise;
  148.     friend OBound::BindToBinder(OBinder *binder, const char *fieldname);  // so can call AddToOBinder 
  149.  
  150. public:
  151.     OBinder(void);
  152.     ~OBinder(void);
  153.     
  154.     // start (or restart) a query on the binder
  155.     oresult Open(const char *dbname, const char *username, const char *pwd, const char *sqls, long dynoptions = ODYNASET_DEFAULT);  // data control form
  156.     oresult Open(const ODatabase &odb, const char *sqls, long dynoptions = ODYNASET_DEFAULT);  // using an existing database
  157.     
  158.     oresult Close(oboolean doShutdown = TRUE);
  159.     
  160.     // for resetting the query of the block
  161.     oresult SetSQL(const char *sqls);  // just set the SQL for the next query 
  162. //BUG #262553
  163.     const char *GetSQL(void) const;  // gets sql statement
  164.     oresult RefreshQuery(void);  // refresh query
  165.     
  166.     oresult Refresh(void);  // get values to all bound objects
  167.     
  168.     // navigational methods
  169.     //   (can also call methods on the dynaset returned by GetDynaset)
  170.     oresult MoveFirst(void);
  171.     oresult MovePrev(void);
  172.     oresult MoveNext(void);
  173.     oresult MoveLast(void);
  174.     oresult MoveToMark(const ODynasetMark &mark);
  175.     
  176.     // ask for the binder's dynaset
  177.     const ODynaset GetDynaset(void) const;
  178.     const ODatabase GetDatabase(void) const;
  179.     
  180.     // unbind an object
  181.     oresult UnbindObj(OBound *object, oboolean nofail = FALSE);
  182.     
  183.     // get or set the value of a field (primarily used by OBound)
  184.     oresult GetFieldValue(int index, OValue *val) const;
  185.     oresult SetFieldValue(int index, const OValue &val);
  186.     
  187.     // routine called by a child bound object to get it's field
  188.     oresult GetFieldIndex(int *ofldi, const char *fieldname);
  189.     
  190.     oresult DeleteRecord(void);
  191.     oresult AddNewRecord(void);
  192.     oresult DuplicateRecord(void);
  193.     
  194.     oresult     Changed(oboolean cflag = TRUE);
  195.     oboolean IsChanged(void) const;
  196. //BUG #262553
  197.     oboolean IsOpen(void);
  198.     oboolean IsFirst(void);
  199.     oboolean IsLast(void);
  200.         
  201.     oboolean GetChangedError(long *serr, long *cerr) const; 
  202.     
  203.     // save changes, if any
  204.     oresult Update(void);
  205.     // throw away changes, if any
  206.     oresult DiscardChanges(void);   
  207.     
  208.     // Error handling methods    
  209. //BUG #262553
  210.     long  ErrorNumber(void) const; // return error "number"    
  211.     const char *LookupErrorText(long errnum) const;
  212.                                           // get error text for given error number
  213.     const char *GetErrorText(void) const;  // get description of last error
  214.     // set error information
  215.     void  ErrorReset(void) const;  // reset error state to "no error"
  216.  
  217.     oboolean CanMark(void) const;
  218.     ODynasetMark GetMark(void) const;  // bookmark at current position
  219.     ODynasetMark GetLastModifiedMark(void) const ;    // get bookmark at last modified record
  220.  
  221.     // record access
  222. //BUG #262553
  223.     int GetFieldCount(void) const;  // returns # of fields in a record
  224.     long GetRecordCount(void) const;
  225.     // (dangerous!) gets total number of records in dynaset -- downloads the entire dynaset to the client   
  226.     int GetFieldIndex(const char *fieldname) const;
  227.                                                     // gets the index of a field by name
  228.         
  229.     // declarations of methods so that compiler won't implement these (which would be wrong)
  230.     // at present we don't implement these either...
  231.     OBinder(const OBinder &other);  // copy constructor
  232.     OBinder &operator=(const OBinder &other);  // overloaded assignment
  233.  
  234. protected:
  235.     /*
  236.         Error handling routine.  This routine is called if there is an error during processing
  237.         of Changed.
  238.     */             
  239.     virtual void OnChangedError(void);
  240.     
  241.     /*
  242.         Trigger routines.  These routines are all fired on some action
  243.         They are all documented to show:
  244.         
  245.         Fired: when the trigger fires
  246.         Default: the action of the OBinder base class
  247.         
  248.         The triggers all return an oresult.  If the trigger does not return
  249.         OSUCCESS the current action is cancelled.
  250.         
  251.         After a binder trigger routine is called, the same trigger is called
  252.         on each of the bound objects (routines in OBound), with the exception of
  253.         Startup and Shutdown.  Currently the order
  254.         the triggers are called on the bound objects is not guaranteed.  The
  255.         object triggers will not be called if the binder trigger fails.  If any
  256.         of the object triggers fail, no more processing will be done
  257.     */
  258.     
  259.     virtual oresult Startup(void);
  260.     // Fired: at the time the first bound object is added to the binder
  261.     //        guaranteed to only be called once
  262.     // Default: no action
  263.     virtual oresult Shutdown(void);
  264.     // Fired: when OBinder::Close is called
  265.     // Default: if changes have been made, save them (calls OBound::SaveChange on every object) and
  266.     //          update the record (which as a side effect calls the update triggers)
  267.     virtual oresult PreQuery(void);
  268.     // Fired: before the SQL statement is executed
  269.     // Default: no action
  270.     virtual oresult PostQuery(void);
  271.     // Fired: after SQL statement is executed and new bindings are established
  272.     // Default: no action
  273.     virtual oresult PreDelete(void);
  274.     // Fired: before record is deleted
  275.     // Default: no action
  276.     virtual oresult PostDelete(void);
  277.     // Fired: after record is deleted (but not committed to database)
  278.     // Default: no action
  279.     virtual oresult PreAdd(void);
  280.     // Fired: before new record is added
  281.     // Default: if changes have been made, save them (calls OBound::SaveChange on every object) and
  282.     //          update the record (which as a side effect calls the update triggers)
  283.     virtual oresult PostAdd(void);
  284.     // Fired: after a new record is added
  285.     // Default: no action
  286.     virtual oresult PreUpdate(void);
  287.     // Fired: just before database is updated
  288.     // Default: no action
  289.     virtual oresult PostUpdate(void);
  290.     // Fired: immediately after database is updated
  291.     // Default: no action 
  292.     virtual oresult PreRollback(void);
  293.     // Fired: immediately before a rollback is attempted
  294.     // Default: no action
  295.     virtual oresult PostRollback(void);
  296.     // Fired: immediately after a rollback
  297.     // Default: no action
  298.     virtual oresult PreMove(void);
  299.     // Fired: before OBinder moves to a new record
  300.     // Default: if changes have been made, save them (calls OBound::SaveChange on every object) and
  301.     //          update the record (which as a side effect calls the update triggers)
  302.     virtual oresult PostMove(void);
  303.     // Fired: after OBinder moves to a new record
  304.     // Default: no action
  305.     
  306.  
  307. private:
  308.     ODynaset      m_dynaset;
  309.     ODatabase     m_database;
  310.     OBound      **m_boundlist;
  311.     void           *m_advise;     // pointer to our special advisory
  312.     
  313.     oboolean        m_changed;  // TRUE if binder has been changed since an update
  314.     int             m_nbound;
  315.     
  316.     // errors saved from change
  317.     long         m_changeerr;  // class lib error
  318.     long         m_schangeerr; // server error
  319.     
  320.     // Bind an object to the binder (called by OBound)
  321.     oresult AddObjectToOBinder(OBound *object);
  322.  
  323.     // operations on all the bound objects
  324.     oresult DoAllObjects(oresult (OBound::*ff)(void));  // operate on all via dynaset ref
  325.  
  326.     // routines used to implement default behavior
  327.     oresult SaveRecordChanges(void);
  328. };
  329.  
  330. #endif // OBOUND_ORACLE
  331.  
  332.