Polaris: RefElement.h Source File

RefElement.h Go to the documentation of this file. /// /// #ifndef _REF_ELEMENT_H #define _REF_ELEMENT_H /// /// \class RefElement /// \brief template for types derived from Listable /// \defgroup Polaris /// \ingroup Polaris /// C++ VDL /// \see RefElement.h /// /// \endcode /// \section DESCRIPTION DESCRIPTION /// RefElement is a Collection structure which allows a reference to a /// single Listable object. It can be viewed as providing the /// functionality of a single-element RefList. 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) /// { /// RefElement<Statement> p; /// /// p = stmt; // 'p' now references 'stmt' /// // 'p.modify(stmt);' does the same thing. /// /// cout << *p; // '*p' returns a reference to stmt /// cout << p->tag(); // 'p->' allows access to stmt's class members /// /// Element<Statement> q = p; // Copies p's reference /// /// Statement &s = q.grab(); // Returns reference from q /// /// p.del(); // Removes p's reference /// } /// \endcode /// /// There also exist methods valid, member and modify_and_grab. /// #include <stream.h> #include "BaseRefElement.h" /// template <class T> class RefElement : public Listable { protected: BaseRefElement _el; public: INLINE RefElement(); INLINE RefElement(T &e); INLINE RefElement(const RefElement<T> &e); INLINE ~RefElement(); INLINE RefElement<T> & operator=(const T &l); ///< Change reference to l INLINE const T & operator*() const; INLINE T & operator*(); ///< Return a reference to the object referenced by Element. INLINE const T * operator->() const; INLINE T * operator->(); ///< Allows class member access of the object referenced by Element INLINE void modify(T &el); ///< change the reference. INLINE void del(); ///< Delete the reference. INLINE void clear(); ///< Delete the reference. INLINE T & grab(); ///< Delete and return the reference INLINE T & modify_and_grab(T &el); ///< Switch reference to el and return the old reference INLINE Boolean member(T &el) const; ///< Check to see if node 'el' the same as the RefElement. 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 RefElement<T> & operator = (const RefElement<T> &e); ///< Copy operator copies all the reference from RefElement e 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 RefElement<T>::RefElement() { ///< Nothing to do } template <class T> INLINE RefElement<T>::RefElement(const RefElement<T> &e) { _el = e._el; } template <class T> INLINE RefElement<T>::~RefElement() { ///<Nothing to do } template <class T> INLINE void RefElement<T>::print(ostream & out) const { _el.print(out); } template <class T> INLINE RefElement<T> & RefElement<T>::operator=(const T &l) { _el = l; return *this; } template <class T> INLINE const T & RefElement<T>::operator*() const { return (const T &) *_el; } template <class T> INLINE T & RefElement<T>::operator*() { return (T &) *_el; } template <class T> INLINE const T * RefElement<T>::operator->() const { return (const T *) _el.operator -> (); } template <class T> INLINE T * RefElement<T>::operator->() { return (T *) _el.operator -> (); } template <class T> INLINE void RefElement<T>::modify(T &el) { _el.modify(el); } template <class T> INLINE void RefElement<T>::del() { _el.del(); } template <class T> INLINE void RefElement<T>::clear() { _el.del(); } template <class T> INLINE T & RefElement<T>::grab() { return (T &) _el.grab(); } template <class T> INLINE T & RefElement<T>::modify_and_grab(T &el) { return (T &) _el.modify_and_grab(el); } template <class T> INLINE Boolean RefElement<T>::member(T &el) const { return _el.member(el); } template <class T> INLINE Boolean RefElement<T>::valid() const { return _el.valid(); } template <class T> INLINE RefElement<T> & RefElement<T>::operator = (const RefElement<T> &e) { _el = e._el; return *this; } template <class T> INLINE int RefElement<T>::structures_OK() const { return 1; ///< I'm OK, you're OK } template <class T> INLINE Listable * RefElement<T>::listable_clone() const { return (Listable *) new RefElement<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 RefElement<T> &e) { e.print(o); return o; } #endif

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