---

Persistence.h

Go to the documentation of this file.

// $Id: Persistence.h,v 1.8 2001/01/26 20:57:14 jrb Exp $
// Implementation of the persistence design pattern

#ifndef XMLPERSISTENCE_H
#define XMLPERSISTENCE_H


// #include "xml/Element.h"
#include "facilities/error.h" // for FATAL
#include <dom/DOM_Element.hpp>
#include "xml/Dom.h"
#include <string>
#include <iostream>
#include <iterator>
#include <vector>
#include <map>


// PersistentObject - class declaration

/* The base class supports XML persistence (std::ostream persistence
removed as of September, 2000). Other
types of persistence may be implemented by declaring other static
createPersistence( _Persistence ) methods, where _Persistence
represents the data type being used. Then, a container defined with a
value_type parameter of only those subclasses is defined and a
persist_iterator< _Container, _Persistence > is declared. This can
then be used to assign classes from the _Persistence type into the
container. Note that the new 'base persistence class' in this scheme
(whatever defines the new persistence type) must write and read ALL
persistence information.  */

class DOM_Element;

namespace xml {
  class PersistentObject {      // implements a set of persistent objects.
  public:
    // type declarations
    typedef     std::string     _PersistKey;
    class _Factory {
    public:
      virtual PersistentObject* create(const DOM_Element&);
    };
    
    // ctor
    PersistentObject() {}
    
    // public access to persistence
    static PersistentObject* createPersistence (const DOM_Element&);
    
    static bool addPersistence(const _PersistKey&, 
                               class PersistentObject::_Factory* );
    
    static void killPersistence ();
    
    // equality
    bool operator==(const PersistentObject&) { return true; }
    
    // persist - write persistence information to a persistence stream
    // BY DEFINITION: calling createPersistence with an istream at the
    // same position as called for persist will instantiate an copy of 
    // this object
    
    virtual DOM_Element persist(DOM_Element& parent) const;
    
  protected:    
    
    PersistentObject(DOM_Element&);                     
    
    // subclasses must define a persistence key as a unique ID
    virtual const _PersistKey&  persistKey() const = 0;
    
    // friends
    friend class PersistentObject::_Factory;
    
  private:
    static std::map<_PersistKey, class _Factory*>*      s_persist_table;
  };
  
  // PersistentContainter<_Cont> - wraps any container which provides 
  // begin, end, size to persistence
  //    !! it is important to note that PersistentContainers are not 
  //    !! incorporated  into the overall PersistentObject
  //    !! hierarchy - they are not inserted into any PersistentObject 
  //    !! scheme other than that they provide generic persist( )
  //    !! methods and persistence constructors. The value_type of the 
  //    !!  container must also be a PersistentObject
  //    !! or at least supply a persist method.
  
  template <class _Cont> class PersistentContainer {    
  public:
    // constructors
    PersistentContainer() {} // default
    
    PersistentContainer(const DOM_Element&);
    // destructor
    virtual ~PersistentContainer() {}
    // type declarations/synonyms       
    typedef     _Cont    container;
    typedef typename container::iterator                iterator;
    typedef     typename container::const_iterator      const_iterator;
    typedef typename container::reverse_iterator    reverse_iterator;
    typedef typename container::const_reverse_iterator const_reverse_iterator;
    typedef typename container::value_type              value_type;
    
    // access to container
    iterator            begin () { return m_container.begin(); }
    iterator            end () { return m_container.end(); }
    const_iterator      begin () const { return m_container.begin(); }
    const_iterator      end () const { return m_container.end(); }
    reverse_iterator        rbegin () { return m_container.rbegin(); }
    reverse_iterator        rend () { return m_container.rend(); }
    const_reverse_iterator  rbegin () const { return m_container.rbegin(); }
    const_reverse_iterator  rend () const { return m_container.rend(); }
    container&  operator() (void) { return m_container; }
    const container& operator() (void) const { return m_container; }
    unsigned int        size () const { return m_container.size(); }
    bool                empty () const { return m_container.empty(); }
    
    // public methods
    iterator insert ( iterator& i, value_type& v ) 
      { return m_container.insert(i,v); }
    
    void           load (const DOM_Element&);
    
    
    virtual void persist(DOM_Element& parent) const;
    
  protected:
    
  private:
        container       m_container;
  };
  
  // persist_iterator - used to make persistence construction generic
  // _Iterator should be an input_iterator into some container, _Persistence
  // is a valid persistence data type
  template <class _Iterator, class _Persistence>
    class persist_iterator {
    public:
    // type declarations
    typedef _Iterator iterator;
    typedef typename iterator::value_type       value_type;
    typedef _Persistence persistence;
    
    explicit persist_iterator ( iterator& it );
    
    persist_iterator&   operator=(persistence& p);
    
    persist_iterator&   operator* ();
    persist_iterator&   operator++ ();
    persist_iterator&   operator ++ (int);
    
    private:
    iterator&   m_iter;
  };
  
  // PersistentObject inline implementation
  
  // createPersistence
  // - creates a persistent object (+ children) from an XML element
    inline PersistentObject*
    PersistentObject::createPersistence(const DOM_Element& elem) {
      std::string temp_string(Dom::transToChar(elem.getTagName()));
     _PersistKey key(temp_string);
    if (!s_persist_table) FATAL("Persistence information not initialized.");
    
    
    std::map<_PersistKey, _Factory*>::iterator mit =
      s_persist_table->find(key); 
    
    if (mit != s_persist_table->end()) {
      return (*mit).second->create(elem);
    }
    else   return 0;
  }
  
  
  // killPersistence
  // - deletes all of the PersistenceKey-factory pairs
  inline void PersistentObject::killPersistence() {
    if (!s_persist_table) return;
    for (std::map<_PersistKey, _Factory*>::iterator it = 
           s_persist_table->begin(); it != s_persist_table->end();   ++it) {
      delete (*it).second;
    }
  }
  
  // PersistentContainer - inline implementations
  template <class _Cont>
    inline void PersistentContainer<_Cont>::persist(DOM_Element& parent) const
    {
      // note that this occurs in reverse order such that
      // the contents are read back in in the same order... 
      for (const_reverse_iterator it = rbegin(); it != rend(); ++it) {
        (*it)->persist(parent);    
      }
    }
  
  template <class _Cont>
    inline void PersistentContainer<_Cont>::load(const DOM_Element& elem) {
    DOM_NodeList children = elem.getChildNodes();
    int          len = children.getLength();
    int          iChild;
    iterator     thisIt = begin();
    
    for (iChild = 0; iChild < len; iChild++) {
      if (children.item(iChild).getNodeType() == DOM_Node::ELEMENT_NODE) {
        DOM_Node    child_tmp = children.item(iChild);
        DOM_Element child = DOM_Element(static_cast<DOM_Element&>(child_tmp));
        // value_type is, e.g. GlastDetector* 
        value_type newObj = 
          static_cast<value_type> (PersistentObject::createPersistence(child));
        if (newObj) thisIt = insert(thisIt, newObj);
      }
    }
  }
  
  // persist_iterator implementation
  template <class _Iterator, class _Persistence>
    inline persist_iterator<_Iterator, _Persistence>::persist_iterator 
    (persist_iterator<_Iterator, _Persistence>::iterator& it)
    : m_iter(it) {}
  
  template <class _Iterator, class _Persistence>
    inline persist_iterator<_Iterator, _Persistence>&
    persist_iterator<_Iterator, _Persistence>::operator=
    (persist_iterator<_Iterator, _Persistence>::persistence& p) {
      value_type* o = value_type::createPersistence(p);
      if (o != 0) {
        *m_iter = o;
        ++m_iter;
      }
      return *this;
    }
  
  template <class _Iterator, class _Persistence>
    inline persist_iterator<_Iterator, _Persistence>&
    persist_iterator<_Iterator, _Persistence>::operator* () {
    return *this;
  }
  
  template <class _Iterator, class _Persistence>
    inline persist_iterator<_Iterator, _Persistence>&
    persist_iterator<_Iterator, _Persistence>::operator++ () {
    return *this;
  }
  
  template <class _Iterator, class _Persistence>
    inline persist_iterator<_Iterator, _Persistence>&
    persist_iterator<_Iterator, _Persistence>::operator++ (int) {
    return *this;
  }
}         // end namespace xml
#endif  // _H_PERSISTENCEHEADER

---