KanPersistable

class KanPersistable

    private:

                      KanPersistable(const KanPersistable&)
      KanPersistable& operator=(const KanPersistable&)

    protected:

                 virtual Bool_t fillPtrHook(KanEventReader& eR)
                 virtual Bool_t fillReadRefHook(KanEventReader& eR)
                 virtual Bool_t fillSelfPointers(KanEventReader& eR)
                 virtual Bool_t fillSelfReadRefs(KanEventReader& eR)
                 virtual Bool_t fillSelfWriteRefs(KanEventWriter& eW)
                 virtual Bool_t fillWriteRefHook(KanEventWriter& eW)
                 virtual Bool_t flushHook(KanEventReader& eR)
                 virtual Bool_t flushSelf(KanEventReader& eR)
      KanPersistable::Status_t& persStatus() const
                   virtual void resetHook(Dna::Scope scope = Dna::Event)
                   virtual void resetSelf(Dna::Scope scope = Dna::Event)
                   virtual void setReadID(const KanReadCache* rc)
                           void setStatusFlushed() const
                   virtual void setWriteID(const KanWriteCache* rc, KanEventWriter& eW)
                           void streamerSetStatus() const
                 virtual Bool_t syncHook(KanEventWriter& eW)
                 virtual Bool_t syncSelf(KanEventWriter& eW)

    public:

                          KanPersistable()
                  virtual ~KanPersistable()
      virtual const char* className() const
                   Bool_t fillOwnPointers(KanEventReader& eR)
                   Bool_t fillReadRefs(KanEventReader* eR = 0)
                   Bool_t fillWriteRefs(KanEventWriter& eW)
                   Bool_t flush(KanEventReader& eR)
             virtual void print(ostream& os = std::cout) const
                     void reset(Dna::Scope scope = Dna::Event)
                   Bool_t sync(KanEventWriter&)

Data Members

    private:

      Kan::Status_t _persStatus  ! Object Status
        KanIDHolder _idh         || 

Class Description

      The base class for all Kanga persistent objects.

      The key point about KanPersistable (and Kanga) is that each persistent object
      caches a transient representation of the same data.  To manage the book-keeping,
      KanPersistable defines four states.
         Kan::Reset   -> Persistent and Transient Data both InValid.
         Kan::Synced  -> Persistent data Valid, transient InValid.
         Kan::Flushed -> Persistent data InValid, transient Valid.
         Kan::Valid   -> Persistent and Transient Data both Valid.


      Six public method define the operations that manage the state of a
      KanPersistable:

        // Fill persisted data from a transient reprsentation and set status to Valid.
        Bool_t sync(KanEventWriter& eW);

        // Fill transient representation from persistent data and set status to Valid.
        Bool_t flush(KanEventReader& eR);

        // Reset both transient and persistent data and set status to Reset.
        // This is a no-op if the scope doesn't match the scope of the object.
        void reset(Dna::Scope scope)

        // Call sync on all of the persistent references used in this object.
        // Returns false if a reference look-up fails
        Bool_t fillWriteRefs(KanEventWriter& eW);

        // Call flush on all of the persistent references used in this object.
        // Returns false if a reference look-up fails
        Bool_t fillReadRefs(KanEventReader& eR);

        // Do any last-minute repairs on an object before sending it out into the world.
        Bool_t fillPointers(KanEventReader& eR);


      Each of these six function calls in turn two virtual methods (Self and Hook).

      The Self functions are overridden in Core Kanga code to actually do need operations,
      (like passing calls along to vector data or owned sub-objects).

      The Hook functions can be overridden in User code to do extra operations at a particular
      time.


      On writing data the event sequence is:
        reset, sync, fillWriteRefs {Write}

      On reading data the event sequence is :
        reset, {Read} fillReadRefs, flush, fillPointers

 d'tor

 Syncronize the persistent object to the current transient data.

 reset the object

 Flush the transient data from the current persistent cache

 Fill this object's refs using its cached transient

 Fill this object's refs using its cached transient

 Fill the pointers in this object's cached transient

Inline Functions

                             void print(ostream& os = std::cout) const
                      const char* className() const
        KanPersistable::Status_t& persStatus() const
                             void streamerSetStatus() const
                             void setStatusFlushed() const
                           Bool_t syncSelf(KanEventWriter& eW)
                             void resetSelf(Dna::Scope scope = Dna::Event)
                           Bool_t flushSelf(KanEventReader& eR)
                           Bool_t fillSelfWriteRefs(KanEventWriter& eW)
                           Bool_t fillSelfReadRefs(KanEventReader& eR)
                           Bool_t fillSelfPointers(KanEventReader& eR)
                           Bool_t syncHook(KanEventWriter& eW)
                             void resetHook(Dna::Scope scope = Dna::Event)
                           Bool_t flushHook(KanEventReader& eR)
                           Bool_t fillWriteRefHook(KanEventWriter& eW)
                           Bool_t fillReadRefHook(KanEventReader& eR)
                           Bool_t fillPtrHook(KanEventReader& eR)
                             void setReadID(const KanReadCache* rc)
                             void setWriteID(const KanWriteCache* rc, KanEventWriter& eW)
                   KanPersistable KanPersistable(const KanPersistable&)
                  KanPersistable& operator=(const KanPersistable&)