element.h

Go to the documentation of this file.

/**
 * \file rvc/element.h
 * \brief interface for the RVC::ELEMDBASE class.
 *
 * \if NODOC
 * $Id: element.h_v 1.9 2004/07/22 15:27:26 dwilliss Exp $
 *
 * $Log: element.h_v $
 * Revision 1.9  2004/07/22 15:27:26  dwilliss
 * Added an operator< so I could use RVC::ELEMENT as a key in std::map
 *
 * Revision 1.8  2004/04/14 19:21:44  dwilliss
 * Added a couple #includes so it would compile in isolation
 *
 * Revision 1.7  2004/03/22 16:15:58  scowan
 * Added clear method.
 *
 * Revision 1.6  2003/09/25 21:56:37  dwilliss
 * doxygen
 *
 * Revision 1.5  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.4  2002/04/19 16:43:02  mju
 * Make ctor from elemnum explicit.
 *
 * Revision 1.3  2002/04/11 19:48:41  mju
 * Forgot to inline non-member operators.
 *
 * Revision 1.2  2002/04/11 17:56:46  mju
 * Add comparison operators.
 *
 * Revision 1.1  2002/04/11 17:46:11  scowan
 * Initial revision
 * \endif
**/
 
#ifndef INC_RVC_ELEMENT_H
#define INC_RVC_ELEMENT_H

#ifndef INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

#ifndef INC_MI32_ELEMTYPE_H
#include <mi32/elemtype.h>
#endif


namespace RVC {

//! Container for spatial element specifying type and number.
class ELEMENT {
   public:

      //! Default constructor.   
      ELEMENT (
         ) : m_ElemNum(-1), m_ElemType(ELEMTYPE_Empty) {}

      //! Construct from element number.
      explicit ELEMENT (
         INT32 ElemNum
         ) : m_ElemNum(ElemNum), m_ElemType(ELEMTYPE_Empty) {}

      //! Construct from element number and type.
      ELEMENT (
         INT32 ElemNum,
         ELEMTYPE ElemType
         ) : m_ElemNum(ElemNum), m_ElemType(ElemType) {}

      //! Copy construct from ELEMENT and fallback element type.
      ELEMENT (
         const ELEMENT& elem,                //!< Element to copy
         ELEMTYPE ElemType                   //!< Fallback element type, used if not set in 'elem'
         ) : m_ElemNum(elem.m_ElemNum), m_ElemType((elem.m_ElemType == ELEMTYPE_Empty) ? ElemType : elem.m_ElemType) {}

      //! Clear to element info back to no element       
      void Clear (
         ) { 
         m_ElemNum = -1; 
         m_ElemType = ELEMTYPE_Empty; 
         }

      //! Get the stored element number.
      //! @return Element number
      INT32 GetNumber (
         ) const { return (m_ElemNum); }
         
      //! Get the stored ELEMTYPE.
      //! @return ELEMTYPE       
      ELEMTYPE GetType (
         ) const { return (m_ElemType); }

      //! Set the element number.
      void SetNumber (
         INT32 ElemNum
         ) { m_ElemNum = ElemNum; }

      //! Set the element type (ELEMTYPE).         
      void SetType (
         ELEMTYPE ElemType
         ) { m_ElemType = ElemType; }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      INT32 m_ElemNum;
      ELEMTYPE m_ElemType;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
   };

//! Compare ELEMENTs for equality.
inline bool operator== (
   const ELEMENT& lhs,
   const ELEMENT& rhs
   ) { return (lhs.GetNumber() == rhs.GetNumber() && lhs.GetType() == rhs.GetType()); }
   
//! Compare ELEMENTs for inequality.
inline bool operator!= (
   const ELEMENT& lhs,
   const ELEMENT& rhs
   ) { return (!operator==(lhs,rhs)); }
   
//! Compare ELEMENTs for ordering.
//! Elements are sorted by type then by element number.
//! This comparison it to allow RVC::ELEMENT to be used as a Key in std::map
inline bool operator< (
   const ELEMENT& lhs,
   const ELEMENT& rhs
   ) {
   if (lhs.GetType() == rhs.GetType()) return (lhs.GetNumber() < rhs.GetNumber());
   return (static_cast<int>(lhs.GetType()) < static_cast<int>(rhs.GetType()));
   }
   
}     //! End of RVC namespace

#endif   //!< INC_RVC_ELEMENT_H

---