Polaris: Element.h Source File

Element.h Go to the documentation of this file. /// /// #ifndef _ELEMENT_H #define _ELEMENT_H /// /// \class Element /// \brief template for types derived from Listable /// \defgroup Polaris /// \ingroup Polaris /// C++ VDL /// \see Element.h /// /// \endcode /// \section DESCRIPTION DESCRIPTION /// Element is a Collection structure which takes ownership of a /// single Listable object. It can be viewed as providing the /// functionality of a single-element List. However, there is /// much less overhead than a list and a more convenient /// (pointer-esque) interface. /// /// The following examples should describe it: /// /// \code /// void /// example( Statement *stmt, Statement *stmt2) /// { /// Element<Statement> p; /// /// p = stmt; // 'p' now has ownership of 'stmt': Error if stmt already owned. /// // 'p.modify(stmt);' does the same thing. /// /// p = stmt2; // 'p' now owns 'stmt2'. 'stmt' either deleted or zombied. /// /// cout << *p; // '*p' returns a reference to stmt /// cout << p->tag(); // 'p->' allows access to stmt's class members /// /// Element<Statement> q = p; // Copies (clones) p's object /// /// Statement *s = q.grab(); // Returns ownership of object from q /// /// p.del(); // Deletes p's owned object /// } /// \endcode /// /// There also exist methods valid, member and modify_and_grab. /// #include <stream.h> #include "BaseElement.h" /// template <class T> class Element : public Listable { protected: BaseElement _el; public: INLINE Element(); INLINE Element(T &e); INLINE Element(const Element<T> &e); INLINE ~Element(); INLINE Element<T> & operator=(T *l); ///< Element takes ownership of l. If l already ///< owned an error is raised. Previous object deleted or zombied. INLINE const T & operator*() const; INLINE T & operator*(); ///< Return a reference to the object owned by Element. INLINE const T * operator->() const; INLINE T * operator->(); ///< Allows class member access of the object owned by Element INLINE void modify(T *l); ///< Element takes ownership of l. If l already ///< owned an error is raised. Previous object deleted or zombied. INLINE T * grab(); ///< Remove the object from the Element and return it. INLINE void del(); ///< Delete the object (or Zombie it). INLINE void clear(); ///< Delete the object (or Zombie it). INLINE T * modify_and_grab(T *el); ///< Change Element's object to el and return the old object. INLINE Boolean member(T &el) const; ///< Check to see if node 'el' the same as the Element. Return ///< 0 if the element was not the same, else return 1. INLINE Boolean valid() const; ///< Check to see if the element if valid. INLINE Element<T> & operator = (const Element<T> &e); ///< Copy operator copies object of Element INLINE int structures_OK() const; ///< Check the structure of the data for errors or inconsistency ///< Return 0 and print error message if problems found, otherwise ///< return 1 without message. INLINE Listable *listable_clone() const; ///< Needed for Listable class. INLINE void print(ostream &o) const; ///< Needed for Listable class. }; ///< implementation template <class T> INLINE Element<T>::Element() { ///< Nothing to do } template <class T> INLINE Element<T>::Element(const Element<T> &e) { _el = e._el; } template <class T> INLINE Element<T>::~Element() { ///< Nothing to do } template <class T> INLINE void Element<T>::print(ostream & out) const { _el.print(out); } template <class T> INLINE Element<T> & Element<T>::operator=(T *l) { _el = l; return *this; } template <class T> INLINE const T & Element<T>::operator*() const { return (const T &) *_el; } template <class T> INLINE T & Element<T>::operator*() { return (T &) *_el; } template <class T> INLINE const T * Element<T>::operator->() const { return (const T *) _el.operator -> (); } template <class T> INLINE T * Element<T>::operator->() { return (T *) _el.operator -> (); } template <class T> INLINE void Element<T>::modify(T *l) { _el.modify(l); } template <class T> INLINE T * Element<T>::grab() { return (T *) _el.grab(); } template <class T> INLINE void Element<T>::del() { _el.del(); } template <class T> INLINE void Element<T>::clear() { _el.del(); } template <class T> INLINE T * Element<T>::modify_and_grab(T *el) { return (T *) _el.modify_and_grab(el); } template <class T> INLINE Boolean Element<T>::member(T &el) const { return _el.member(el); } template <class T> INLINE Boolean Element<T>::valid() const { return _el.valid(); } template <class T> INLINE Element<T> & Element<T>::operator = (const Element<T> &e) { _el = e._el; return *this; } template <class T> INLINE int Element<T>::structures_OK() const { return 1; ///< I'm OK, you're OK } template <class T> INLINE Listable * Element<T>::listable_clone() const { return (Listable *) new Element<T>(*this); } ///< This interface is for testing purposes only. It invokes a non-virtual ///< member function to print a representation of the data structure at this ///< level of the Collection hierarchy, and, since it is not a class member ///< function, it must be explicitly instantiated before use. template <class T> ostream & operator << (ostream & o, const Element<T> &e) { e.print(o); return o; } #endif

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:05:45 2005