AntNum.h

Go to the documentation of this file.

#ifndef GCP_UTIL_ANTNUM_H
#define GCP_UTIL_ANTNUM_H

#define GCC3_2_2_SUCKS 

#include <iostream>
#include <sstream>
#include <string>

namespace gcp {
  namespace util {
    
    class AntNum {
      
      //------------------------------------------------------------
      // Public members
      //------------------------------------------------------------
      
    public:
      
      static const unsigned int NANT = 1;
      static const unsigned int NBASE = (NANT*(NANT-1))/2;
      
      enum Id {
    ANTNONE = 0, // Make these orthogonal bits, so we can OR them
    // together, as below.
    ANT0    = 1,
    ANT1    = 2,
    ANT2    = 4,
    ANT3    = 8,
    ANT4    = 16,
    ANT5    = 32,
    ANT6    = 64,
    ANT7    = 128,
    ANTMAX  = ANT0, // This should always be set to the last valid antenna
    ANTALL  = ANT0
      } id_;
      
      AntNum(Id id);
      
      AntNum(unsigned int);
      
      AntNum();
      
      AntNum(const AntNum& antNum);
      
      AntNum(AntNum* antNum);
      
      bool isValidSingleAnt();
      
      static bool isValidSingleAnt(Id antId);
      
      std::string getObjectName();
      
      std::string getEventChannelName();
      
      std::string getAntennaName();
      
      std::string getString();
      
      std::string getLoggerPrefix();
      
      unsigned int getDelayEngineIntId();
      
      unsigned int getIntId();
      
      Id getId();
      
      unsigned short getDcAntennaIndex();
      unsigned short getDcNodeIndex();
      
      unsigned int getAntMax();
      
      void set(AntNum::Id id);
      
      bool isSet(unsigned id);
      
      bool isSet(AntNum::Id id);
      
      bool isSet(AntNum& antNum);
      
      bool isSet(AntNum* antNum);
      
      void setId(AntNum::Id);
      
      void setId(unsigned int id);
      
      void setId(const AntNum& antNum);
      
      void setIdFromHost();
      
      static AntNum::Id intToId(unsigned int iant);
      
      static unsigned idToInt(AntNum::Id id);
      
      std::string printAntennaSet();
      std::string printAntennaSet(AntNum::Id id);
      
      //------------------------------------------------------------
      // Member operators
      //------------------------------------------------------------
      
      const AntNum operator+(const AntNum& rx);
      
      bool operator<(const AntNum rx);
      
      bool operator<=(const AntNum rx);
      
      bool operator>(const AntNum rx);
      
      bool operator>=(const AntNum rx);
      
      bool operator==(const AntNum rx);
      
      const AntNum& operator++();
      
      const AntNum operator++(int);
      
      //------------------------------------------------------------
      // Non-member operator methods
      //------------------------------------------------------------
      
      friend std::ostream& operator<<(std::ostream& os, const AntNum& rx);
      
      friend AntNum::Id operator+(const AntNum::Id id1, 
                  const AntNum::Id id2);
      
      friend AntNum::Id operator-(const AntNum::Id id1, 
                  const AntNum::Id id2);
      
      friend bool isValidAnt(unsigned int ant);
      
      friend bool isValidAntennaSet(AntNum::Id antennas);
      
      friend std::string printAntennaSet(AntNum::Id antennas);
      
      friend AntNum::Id intToId(unsigned int iant);
      
      friend unsigned idToInt(AntNum::Id id);
      
      //------------------------------------------------------------
      // Private members
      //------------------------------------------------------------
      
    private:
      
      void checkMaxAnt();
      
    }; // End class AntNum
    
     std::ostream& operator<<(std::ostream& os, const AntNum& rx);
    
     AntNum::Id operator+(const AntNum::Id id1, 
                const AntNum::Id id2);
    
     AntNum::Id operator-(const AntNum::Id id1, 
                const AntNum::Id id2);
    
     bool isValidAnt(unsigned int ant);
    
     bool isValidAntennaSet(AntNum::Id antennas);
    
     std::string printAntennaSet(AntNum::Id antennas);
    
     AntNum::Id intToId(unsigned int iant);
    
     unsigned idToInt(AntNum::Id id);
    
  } // End namespace util
} // End namespace gcp


#endif