casa  $Rev:20696$
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Speed.h
Go to the documentation of this file.
00001 //Speed.h generated on 'Thu Feb 04 10:20:05 CET 2010'. Edit at your own risk.
00002 /*
00003  * ALMA - Atacama Large Millimeter Array
00004  * (c) European Southern Observatory, 2002
00005  * (c) Associated Universities Inc., 2002
00006  * Copyright by ESO (in the framework of the ALMA collaboration),
00007  * Copyright by AUI (in the framework of the ALMA collaboration),
00008  * All rights reserved.
00009  * 
00010  * This library is free software; you can redistribute it and/or
00011  * modify it under the terms of the GNU Lesser General Public
00012  * License as published by the Free software Foundation; either
00013  * version 2.1 of the License, or (at your option) any later version.
00014  * 
00015  * This library is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY, without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018  * Lesser General Public License for more details.
00019  * 
00020  * You should have received a copy of the GNU Lesser General Public
00021  * License along with this library; if not, write to the Free Software
00022  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
00023  * MA 02111-1307  USA
00024  *
00025  * File Speed.h
00026  */
00027 #ifndef Speed_CLASS
00028 #define Speed_CLASS
00029 #include <vector>
00030 #include <iostream>
00031 #include <string>
00032 using namespace std;
00033 #ifndef WITHOUT_ACS
00034 #include <asdmIDLTypesC.h>
00035 using asdmIDLTypes::IDLSpeed;
00036 #endif
00037 #include <StringTokenizer.h>
00038 #include <NumberFormatException.h>
00039 using asdm::StringTokenizer;
00040 using asdm::NumberFormatException;
00041 #include "EndianStream.h"
00042 using asdm::EndianOSStream;
00043 using asdm::EndianIStream;
00044 namespace asdm {
00045 class Speed;
00046 Speed operator * ( double , const Speed & );
00047 ostream & operator << ( ostream &, const Speed & );
00048 istream & operator >> ( istream &, Speed &);
00059 class Speed {
00066   friend Speed operator * ( double d, const Speed & x );
00072   friend ostream & operator << ( ostream & os, const Speed & x);
00076   friend istream & operator >> ( istream & is, Speed & x);
00077 public:
00081         Speed();
00085         Speed(const Speed &);
00093         Speed(const string &s);
00094 #ifndef WITHOUT_ACS
00095 
00101         Speed(const IDLSpeed & idlSpeed);
00102 #endif
00103 
00107         Speed(double value);
00111         virtual ~Speed();
00116         static double fromString(const string& s);
00123         static string toString(double);
00129         static Speed getSpeed(StringTokenizer &st) throw(NumberFormatException);
00130                         
00135         void toBin(EndianOSStream& eoss);
00141         static void toBin(const vector<Speed>& angle,  EndianOSStream& eoss);
00142         
00148         static void toBin(const vector<vector<Speed> >& angle,  EndianOSStream& eoss);
00149         
00155         static void toBin(const vector<vector<vector<Speed> > >& angle,  EndianOSStream& eoss);
00162         static Speed fromBin(EndianIStream& eis);
00163         
00170          static vector<Speed> from1DBin(EndianIStream & eis);
00171          
00178          static vector<vector<Speed> > from2DBin(EndianIStream & eis);
00179          
00186          static vector<vector<vector<Speed> > > from3DBin(EndianIStream & eis);  
00187          
00192          Speed & operator = (const Speed & x);
00193          
00198          Speed & operator = (const double d);
00203         Speed & operator += (const Speed & x);
00208         Speed & operator -= (const Speed & x);
00213         Speed & operator *= (const double x);
00218         Speed & operator /= (const double x);
00223         Speed operator + (const Speed & x) const;
00228         Speed operator - (const Speed & x) const;
00233         Speed operator * (const double x) const;
00238         Speed operator / (const double x) const;
00243         bool operator < (const Speed & x) const;
00248         bool operator > (const Speed & x) const;
00253         bool operator <= (const Speed & x) const;
00258         bool operator >= (const Speed & x) const;
00263         bool operator == (const Speed & x) const;
00268         bool equals(const Speed & x) const;
00273         bool operator != (const Speed & x) const;
00278         bool isZero() const;
00282         Speed operator - () const;
00286         Speed operator + () const;
00291         string toString() const;
00295         string toStringI() const;
00300         operator string () const;
00305         double get() const;
00306 #ifndef WITHOUT_ACS
00307 
00311         IDLSpeed toIDLSpeed() const;
00312 #endif
00313 
00317         static string unit();
00318 private:
00319         double value;
00320 };
00321 // Speed constructors
00322 inline Speed::Speed() : value(0.0) {
00323 }
00324 inline Speed::Speed(const Speed &t) : value(t.value) {
00325 }
00326 #ifndef WITHOUT_ACS
00327 inline Speed::Speed(const IDLSpeed &l) : value(l.value) {
00328 }
00329 #endif
00330 inline Speed::Speed(const string &s) : value(fromString(s)) {
00331 }
00332 inline Speed::Speed(double v) : value(v) {
00333 }
00334 // Speed destructor
00335 inline Speed::~Speed() { }
00336 // assignment operator
00337 inline Speed & Speed::operator = ( const Speed &t ) {
00338         value = t.value;
00339         return *this;
00340 }
00341 // assignment operator
00342 inline Speed & Speed::operator = ( const double v ) {
00343         value = v;
00344         return *this;
00345 }
00346 // assignment with arithmetic operators
00347 inline Speed & Speed::operator += ( const Speed & t) {
00348         value += t.value;
00349         return *this;
00350 }
00351 inline Speed & Speed::operator -= ( const Speed & t) {
00352         value -= t.value;
00353         return *this;
00354 }
00355 inline Speed & Speed::operator *= ( const double n) {
00356         value *= n;
00357         return *this;
00358 }
00359 inline Speed & Speed::operator /= ( const double n) {
00360         value /= n;
00361         return *this;
00362 }
00363 // arithmetic functions
00364 inline Speed Speed::operator + ( const Speed &t2 ) const {
00365         Speed tmp;
00366         tmp.value = value + t2.value;
00367         return tmp;
00368 }
00369 inline Speed Speed::operator - ( const Speed &t2 ) const {
00370         Speed tmp;
00371         tmp.value = value - t2.value;
00372         return tmp;
00373 }
00374 inline Speed Speed::operator * ( const double n) const {
00375         Speed tmp;
00376         tmp.value = value * n;
00377         return tmp;
00378 }
00379 inline Speed Speed::operator / ( const double n) const {
00380         Speed tmp;
00381         tmp.value = value / n;
00382         return tmp;
00383 }
00384 // comparison operators
00385 inline bool Speed::operator < (const Speed & x) const {
00386         return (value < x.value);
00387 }
00388 inline bool Speed::operator > (const Speed & x) const {
00389         return (value > x.value);
00390 }
00391 inline bool Speed::operator <= (const Speed & x) const {
00392         return (value <= x.value);
00393 }
00394 inline bool Speed::operator >= (const Speed & x) const {
00395         return (value >= x.value);
00396 }
00397 inline bool Speed::equals(const Speed & x) const {
00398         return (value == x.value);
00399 }
00400 inline bool Speed::operator == (const Speed & x) const {
00401         return (value == x.value);
00402 }
00403 inline bool Speed::operator != (const Speed & x) const {
00404         return (value != x.value);
00405 }
00406 // unary - and + operators
00407 inline Speed Speed::operator - () const {
00408         Speed tmp;
00409         tmp.value = -value;
00410         return tmp;
00411 }
00412 inline Speed Speed::operator + () const {
00413         Speed tmp;
00414     tmp.value = value;
00415         return tmp;
00416 }
00417 // Conversion functions
00418 inline Speed::operator string () const {
00419         return toString();
00420 }
00421 inline string Speed::toString() const {
00422         return toString(value);
00423 }
00424 inline string Speed::toStringI() const {
00425         return toString(value);
00426 }
00427 inline double Speed::get() const {
00428         return value;
00429 }
00430 #ifndef WITHOUT_ACS
00431 inline IDLSpeed Speed::toIDLSpeed() const {
00432         IDLSpeed tmp;
00433         tmp.value = value;
00434         return tmp;
00435 }
00436 #endif
00437 // Friend functions
00438 inline Speed operator * ( double n, const Speed &x) {
00439         Speed tmp;
00440         tmp.value = x.value * n;
00441         return tmp;
00442 }
00443 inline ostream & operator << ( ostream &o, const Speed &x ) {
00444         o << x.value;
00445         return o;
00446 }
00447 inline istream & operator >> ( istream &i, Speed &x ) {
00448         i >> x.value;
00449         return i;
00450 }
00451 inline string Speed::unit() {
00452         return string ("m/s");
00453 }
00454 } // End namespace asdm
00455 #endif /* Speed_CLASS */