Line data    Source code

       1             : //Frequency.h generated on 'Thu Feb 04 10:20:05 CET 2010'. Edit at your own risk.
       2             : /*
       3             :  * ALMA - Atacama Large Millimeter Array
       4             :  * (c) European Southern Observatory, 2002
       5             :  * (c) Associated Universities Inc., 2002
       6             :  * Copyright by ESO (in the framework of the ALMA collaboration),
       7             :  * Copyright by AUI (in the framework of the ALMA collaboration),
       8             :  * All rights reserved.
       9             :  * 
      10             :  * This library is free software; you can redistribute it and/or
      11             :  * modify it under the terms of the GNU Lesser General Public
      12             :  * License as published by the Free software Foundation; either
      13             :  * version 2.1 of the License, or (at your option) any later version.
      14             :  * 
      15             :  * This library is distributed in the hope that it will be useful,
      16             :  * but WITHOUT ANY WARRANTY, without even the implied warranty of
      17             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      18             :  * Lesser General Public License for more details.
      19             :  * 
      20             :  * You should have received a copy of the GNU Lesser General Public
      21             :  * License along with this library; if not, write to the Free Software
      22             :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
      23             :  * MA 02111-1307  USA
      24             :  *
      25             :  * File Frequency.h
      26             :  */
      27             : #ifndef Frequency_CLASS
      28             : #define Frequency_CLASS
      29             : #include <vector>
      30             : #include <iostream>
      31             : #include <string>
      32             : #ifndef WITHOUT_ACS
      33             : #include <asdmIDLTypesC.h>
      34             : #endif
      35             : #include <alma/ASDM/StringTokenizer.h>
      36             : #include <alma/ASDM/NumberFormatException.h>
      37             : #include <alma/ASDM/EndianStream.h>
      38             : namespace asdm {
      39             : class Frequency;
      40             : Frequency operator * ( double , const Frequency & );
      41             : std::ostream & operator << ( std::ostream &, const Frequency & );
      42             : std::istream & operator >> ( std::istream &, Frequency &);
      43             : /**
      44             :  * The Frequency class implements a quantity of frequency in hertz..
      45             :  * 
      46             :  * @version 1.00 Jan. 7, 2005
      47             :  * @author Allen Farris
      48             :  * 
      49             :  * @version 1.1 Aug 8, 2006
      50             :  * @author Michel Caillat 
      51             :  * added toBin/fromBin methods.
      52             :  */
      53             : class Frequency {
      54             :   /**
      55             :    * Overloading of multiplication operator.
      56             :    * @param d a value in double precision .
      57             :    * @param x a const reference to a Frequency .
      58             :    * @return a Frequency 
      59             :    */
      60             :   friend Frequency operator * ( double d, const Frequency & x );
      61             :   /**
      62             :    * Overloading of << to output the value an Frequency on an ostream.
      63             :    * @param os a reference to the ostream to be written on.
      64             :    * @param x a const reference to a Frequency.
      65             :    */
      66             :   friend std::ostream & operator << ( std::ostream & os, const Frequency & x);
      67             :   /**
      68             :    * Overloading of >> to read an Frequency from an istream.
      69             :    */
      70             :   friend std::istream & operator >> ( std::istream & is, Frequency & x);
      71             : public:
      72             :         /**
      73             :          * The nullary constructor (default).
      74             :          */
      75             :         Frequency();
      76             :         /**
      77             :          * The copy constructor.
      78             :          */
      79             :         Frequency(const Frequency &);
      80             :         /**
      81             :          * A constructor from a string representation.
      82             :          * The string passed in argument must be parsable into a double precision
      83             :          * number to express the value in radian of the angle.
      84             :          *
      85             :          * @param s a string.
      86             :          */
      87             :         Frequency(const std::string &s);
      88             : #ifndef WITHOUT_ACS
      89             :         /**
      90             :          *
      91             :          * A constructor from a CORBA/IDL representation.
      92             :          * 
      93             :          * @param idlFrequency a cons ref to an IDLFrequency.
      94             :          */
      95             :         Frequency(const asdmIDLTypes::IDLFrequency & idlFrequency);
      96             : #endif
      97             :         /**
      98             :          * A constructor from a value in double precision.
      99             :          * The value passed in argument defines the value of the Frequency in radian.
     100             :          */
     101             :         Frequency(double value);
     102             :         /**
     103             :          * The destructor.
     104             :          */
     105             :         virtual ~Frequency();
     106             :         /**
     107             :          * A static method equivalent to the constructor from a string.
     108             :          * @param s a string?.
     109             :          */
     110             :         static double fromString(const std::string& s);
     111             :         /**
     112             :          * Conversion into string.
     113             :          * The resulting string contains the representation of the value of this Frequency.
     114             :          *
     115             :          * @return string
     116             :          */
     117             :         static std::string toString(double);
     118             :         /**
     119             :          * Parse the next (string) token of a StringTokenizer into an angle.
     120             :          * @param st a reference to a StringTokenizer.
     121             :          * @return an Frequency.
     122             :          */
     123             :         static Frequency getFrequency(StringTokenizer &st);
     124             :                         
     125             :         /**
     126             :          * Write the binary representation of this to an EndianOSStream .
     127             :          * @param eoss a reference to an EndianOSStream .
     128             :          */             
     129             :         void toBin(EndianOSStream& eoss);
     130             :         /**
     131             :          * Write the binary representation of a vector of Frequency to a EndianOSStream.
     132             :          * @param angle the vector of Frequency to be written
     133             :          * @param eoss the EndianOSStream to be written to
     134             :          */
     135             :         static void toBin(const std::vector<Frequency>& angle,  EndianOSStream& eoss);
     136             :         
     137             :         /**
     138             :          * Write the binary representation of a vector of vector of Frequency to a EndianOSStream.
     139             :          * @param angle the vector of vector of Frequency to be written
     140             :          * @param eoss the EndianOSStream to be written to
     141             :          */     
     142             :         static void toBin(const std::vector<std::vector<Frequency> >& angle,  EndianOSStream& eoss);
     143             :         
     144             :         /**
     145             :          * Write the binary representation of a vector of vector of vector of Frequency to a EndianOSStream.
     146             :          * @param angle the vector of vector of vector of Frequency to be written
     147             :          * @param eoss the EndianOSStream to be written to
     148             :          */
     149             :         static void toBin(const std::vector<std::vector<std::vector<Frequency> > >& angle,  EndianOSStream& eoss);
     150             :         /**
     151             :          * Read the binary representation of an Frequency from a EndianIStream
     152             :          * and use the read value to set an  Frequency.
     153             :          * @param eis the EndianStream to be read
     154             :          * @return an Frequency
     155             :          */
     156             :         static Frequency fromBin(EndianIStream& eis);
     157             :         
     158             :         /**
     159             :          * Read the binary representation of  a vector of  Frequency from an EndianIStream
     160             :          * and use the read value to set a vector of  Frequency.
     161             :          * @param eis a reference to the EndianIStream to be read
     162             :          * @return a vector of Frequency
     163             :          */      
     164             :          static std::vector<Frequency> from1DBin(EndianIStream & eis);
     165             :          
     166             :         /**
     167             :          * Read the binary representation of  a vector of vector of Frequency from an EndianIStream
     168             :          * and use the read value to set a vector of  vector of Frequency.
     169             :          * @param eis the EndianIStream to be read
     170             :          * @return a vector of vector of Frequency
     171             :          */      
     172             :          static std::vector<std::vector<Frequency> > from2DBin(EndianIStream & eis);
     173             :          
     174             :         /**
     175             :          * Read the binary representation of  a vector of vector of vector of Frequency from an EndianIStream
     176             :          * and use the read value to set a vector of  vector of vector of Frequency.
     177             :          * @param eis the EndianIStream to be read
     178             :          * @return a vector of vector of vector of Frequency
     179             :          */      
     180             :          static std::vector<std::vector<std::vector<Frequency> > > from3DBin(EndianIStream & eis);         
     181             :          
     182             :          /**
     183             :           * An assignment operator Frequency = Frequency.
     184             :           * @param x a const reference to an Frequency.
     185             :           */
     186             :          Frequency & operator = (const Frequency & x);
     187             :          
     188             :          /**
     189             :           * An assignment operator Frequency = double.
     190             :           * @param d a value in double precision.
     191             :           */
     192             :          Frequency & operator = (const double d);
     193             :          /**
     194             :           * Operator increment and assign.
     195             :           * @param x a const reference to an Frequency.
     196             :           */
     197             :         Frequency & operator += (const Frequency & x);
     198             :         /**
     199             :          * Operator decrement and assign.
     200             :          * @param x a const reference to an Frequency.
     201             :          */
     202             :         Frequency & operator -= (const Frequency & x);
     203             :         /**
     204             :          * Operator multiply and assign.
     205             :          * @param x a value in double precision.
     206             :          */
     207             :         Frequency & operator *= (const double x);
     208             :         /**
     209             :          * Operator divide and assign.
     210             :          * @param x a valye in double precision.
     211             :          */
     212             :         Frequency & operator /= (const double x);
     213             :         /**
     214             :          * Addition operator.
     215             :          * @param x a const reference to a Frequency.
     216             :          */
     217             :         Frequency operator + (const Frequency & x) const;
     218             :         /**
     219             :          * Substraction operator.
     220             :          * @param x a const reference to a Frequency.
     221             :          */
     222             :         Frequency operator - (const Frequency & x) const;
     223             :         /**
     224             :          * Multiplication operator.
     225             :          * @param x a value in double precision.
     226             :          */
     227             :         Frequency operator * (const double x) const;
     228             :         /**
     229             :          * Division operator.
     230             :          * @param d a value in double precision.
     231             :          */
     232             :         Frequency operator / (const double x) const;
     233             :         /**
     234             :          * Comparison operator. Less-than.
     235             :          * @param x a const reference to a Frequency.
     236             :          */
     237             :         bool operator < (const Frequency & x) const;
     238             :         /**
     239             :          * Comparison operator. Greater-than.
     240             :          * @param x a const reference to a Frequency.
     241             :          */
     242             :         bool operator > (const Frequency & x) const;
     243             :         /**
     244             :          * Comparison operator. Less-than or equal.
     245             :          * @param x a const reference to a Frequency.
     246             :          */     
     247             :         bool operator <= (const Frequency & x) const;
     248             :         /**
     249             :          * Comparison operator. Greater-than or equal.
     250             :          * @param x a const reference to a Frequency.
     251             :          */
     252             :         bool operator >= (const Frequency & x) const;
     253             :         /**
     254             :          * Comparision operator. Equal-to.
     255             :          * @param x a const reference to a Frequency.
     256             :          */
     257             :         bool operator == (const Frequency & x) const;
     258             :         /** 
     259             :          * Comparison method. Equality.
     260             :          * @param x a const reference to a Frequency.
     261             :          */
     262             :         bool equals(const Frequency & x) const;
     263             :         /**
     264             :          * Comparison operator. Not-equal.
     265             :          * @param x a const reference to a Frequency.
     266             :          */
     267             :         bool operator != (const Frequency & x) const;
     268             :         /**
     269             :          * Comparison method. Test nullity.
     270             :          * @return a bool.
     271             :          */
     272             :         bool isZero() const;
     273             :         /**
     274             :          * Unary operator. Opposite.
     275             :          */
     276             :         Frequency operator - () const;
     277             :         /**
     278             :          * Unary operator. Unary plus.
     279             :          */
     280             :         Frequency operator + () const;
     281             :         /**
     282             :          * Converts into a string.
     283             :          * @return a string containing the representation of a the value in double precision.
     284             :          */
     285             :         std::string toString() const;
     286             :         /** 
     287             :          * Idem toString.
     288             :          */
     289             :         std::string toStringI() const;
     290             :         /**
     291             :          * Conversion operator.
     292             :          * Converts into a string.
     293             :          */
     294             :         operator std::string () const;
     295             :         /**
     296             :          * Return the double precision value of the Frequency.
     297             :          * @return double
     298             :          */
     299             :         double get() const;
     300             : #ifndef WITHOUT_ACS
     301             :         /**
     302             :          * Return the IDLFrequency representation of the Frequency.
     303             :          * @return IDLFrequency 
     304             :          */
     305             :     asdmIDLTypes::IDLFrequency toIDLFrequency() const;
     306             : #endif
     307             :         /**
     308             :          * Returns the abbreviated name of the unit implicitely associated to any Frequency.
     309             :          * @return string
     310             :          */
     311             :         static std::string unit();
     312             : private:
     313             :         double value;
     314             : };
     315             : // Frequency constructors
     316       43922 : inline Frequency::Frequency() : value(0.0) {
     317       43922 : }
     318      900876 : inline Frequency::Frequency(const Frequency &t) : value(t.value) {
     319      900876 : }
     320             : #ifndef WITHOUT_ACS
     321             : inline Frequency::Frequency(const asdmIDLTypes::IDLFrequency &l) : value(l.value) {
     322             : }
     323             : #endif
     324        8383 : inline Frequency::Frequency(const std::string &s) : value(fromString(s)) {
     325        8383 : }
     326      200671 : inline Frequency::Frequency(double v) : value(v) {
     327      200671 : }
     328             : // Frequency destructor
     329           0 : inline Frequency::~Frequency() { }
     330             : // assignment operator
     331       35726 : inline Frequency & Frequency::operator = ( const Frequency &t ) {
     332       35726 :         value = t.value;
     333       35726 :         return *this;
     334             : }
     335             : // assignment operator
     336             : inline Frequency & Frequency::operator = ( const double v ) {
     337             :         value = v;
     338             :         return *this;
     339             : }
     340             : // assignment with arithmetic operators
     341             : inline Frequency & Frequency::operator += ( const Frequency & t) {
     342             :         value += t.value;
     343             :         return *this;
     344             : }
     345             : inline Frequency & Frequency::operator -= ( const Frequency & t) {
     346             :         value -= t.value;
     347             :         return *this;
     348             : }
     349             : inline Frequency & Frequency::operator *= ( const double n) {
     350             :         value *= n;
     351             :         return *this;
     352             : }
     353             : inline Frequency & Frequency::operator /= ( const double n) {
     354             :         value /= n;
     355             :         return *this;
     356             : }
     357             : // arithmetic functions
     358             : inline Frequency Frequency::operator + ( const Frequency &t2 ) const {
     359             :         Frequency tmp;
     360             :         tmp.value = value + t2.value;
     361             :         return tmp;
     362             : }
     363             : inline Frequency Frequency::operator - ( const Frequency &t2 ) const {
     364             :         Frequency tmp;
     365             :         tmp.value = value - t2.value;
     366             :         return tmp;
     367             : }
     368             : inline Frequency Frequency::operator * ( const double n) const {
     369             :         Frequency tmp;
     370             :         tmp.value = value * n;
     371             :         return tmp;
     372             : }
     373             : inline Frequency Frequency::operator / ( const double n) const {
     374             :         Frequency tmp;
     375             :         tmp.value = value / n;
     376             :         return tmp;
     377             : }
     378             : // comparison operators
     379             : inline bool Frequency::operator < (const Frequency & x) const {
     380             :         return (value < x.value);
     381             : }
     382             : inline bool Frequency::operator > (const Frequency & x) const {
     383             :         return (value > x.value);
     384             : }
     385             : inline bool Frequency::operator <= (const Frequency & x) const {
     386             :         return (value <= x.value);
     387             : }
     388             : inline bool Frequency::operator >= (const Frequency & x) const {
     389             :         return (value >= x.value);
     390             : }
     391             : inline bool Frequency::equals(const Frequency & x) const {
     392             :         return (value == x.value);
     393             : }
     394         316 : inline bool Frequency::operator == (const Frequency & x) const {
     395         316 :         return (value == x.value);
     396             : }
     397           0 : inline bool Frequency::operator != (const Frequency & x) const {
     398           0 :         return (value != x.value);
     399             : }
     400             : // unary - and + operators
     401             : inline Frequency Frequency::operator - () const {
     402             :         Frequency tmp;
     403             :         tmp.value = -value;
     404             :         return tmp;
     405             : }
     406             : inline Frequency Frequency::operator + () const {
     407             :         Frequency tmp;
     408             :     tmp.value = value;
     409             :         return tmp;
     410             : }
     411             : // Conversion functions
     412             : inline Frequency::operator std::string () const {
     413             :         return toString();
     414             : }
     415      156523 : inline std::string Frequency::toString() const {
     416      156523 :         return toString(value);
     417             : }
     418             : inline std::string Frequency::toStringI() const {
     419             :         return toString(value);
     420             : }
     421        4643 : inline double Frequency::get() const {
     422        4643 :         return value;
     423             : }
     424             : #ifndef WITHOUT_ACS
     425             : inline asdmIDLTypes::IDLFrequency Frequency::toIDLFrequency() const {
     426             :     asdmIDLTypes::IDLFrequency tmp;
     427             :         tmp.value = value;
     428             :         return tmp;
     429             : }
     430             : #endif
     431             : // Friend functions
     432             : inline Frequency operator * ( double n, const Frequency &x) {
     433             :         Frequency tmp;
     434             :         tmp.value = x.value * n;
     435             :         return tmp;
     436             : }
     437             : inline std::ostream & operator << ( std::ostream &o, const Frequency &x ) {
     438             :         o << x.value;
     439             :         return o;
     440             : }
     441           0 : inline std::istream & operator >> ( std::istream &i, Frequency &x ) {
     442           0 :         i >> x.value;
     443           0 :         return i;
     444             : }
     445      186356 : inline std::string Frequency::unit() {
     446      186356 :         return std::string ("Hz");
     447             : }
     448             : } // End namespace asdm
     449             : #endif /* Frequency_CLASS */