AntNum.h

Go to the documentation of this file.

#ifndef SZA_UTIL_ANTNUM_H
#define SZA_UTIL_ANTNUM_H

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

namespace sza {
  namespace util {
    
    class AntNum {
      
      //------------------------------------------------------------
      // Public members
      //------------------------------------------------------------
      
    public:
      
      static const unsigned int NANT = 8;
      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  = ANT7, // This should always be set to the last valid antenna
        SPARE   = 256,
        ANTALL  = ANT0 | ANT1 | ANT2 | ANT3 | ANT4 | ANT5 | ANT6 | ANT7
      } 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 short getCarmaAntennaIndex();
      
      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
    
    bool isValidAnt(unsigned int ant);
    
    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 sza

#endif