casa  $Rev:20696$
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Length.h
Go to the documentation of this file.
00001 //Length.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 Length.h
00026  */
00027 #ifndef Length_CLASS
00028 #define Length_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::IDLLength;
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 Length;
00046 Length operator * ( double , const Length & );
00047 ostream & operator << ( ostream &, const Length & );
00048 istream & operator >> ( istream &, Length &);
00059 class Length {
00066   friend Length operator * ( double d, const Length & x );
00072   friend ostream & operator << ( ostream & os, const Length & x);
00076   friend istream & operator >> ( istream & is, Length & x);
00077 public:
00081         Length();
00085         Length(const Length &);
00093         Length(const string &s);
00094 #ifndef WITHOUT_ACS
00095 
00101         Length(const IDLLength & idlLength);
00102 #endif
00103 
00107         Length(double value);
00111         virtual ~Length();
00116         static double fromString(const string& s);
00123         static string toString(double);
00129         static Length getLength(StringTokenizer &st) throw(NumberFormatException);
00130                         
00135         void toBin(EndianOSStream& eoss);
00141         static void toBin(const vector<Length>& angle,  EndianOSStream& eoss);
00142         
00148         static void toBin(const vector<vector<Length> >& angle,  EndianOSStream& eoss);
00149         
00155         static void toBin(const vector<vector<vector<Length> > >& angle,  EndianOSStream& eoss);
00162         static Length fromBin(EndianIStream& eis);
00163         
00170          static vector<Length> from1DBin(EndianIStream & eis);
00171          
00178          static vector<vector<Length> > from2DBin(EndianIStream & eis);
00179          
00186          static vector<vector<vector<Length> > > from3DBin(EndianIStream & eis);         
00187          
00192          Length & operator = (const Length & x);
00193          
00198          Length & operator = (const double d);
00203         Length & operator += (const Length & x);
00208         Length & operator -= (const Length & x);
00213         Length & operator *= (const double x);
00218         Length & operator /= (const double x);
00223         Length operator + (const Length & x) const;
00228         Length operator - (const Length & x) const;
00233         Length operator * (const double x) const;
00238         Length operator / (const double x) const;
00243         bool operator < (const Length & x) const;
00248         bool operator > (const Length & x) const;
00253         bool operator <= (const Length & x) const;
00258         bool operator >= (const Length & x) const;
00263         bool operator == (const Length & x) const;
00268         bool equals(const Length & x) const;
00273         bool operator != (const Length & x) const;
00278         bool isZero() const;
00282         Length operator - () const;
00286         Length operator + () const;
00291         string toString() const;
00295         string toStringI() const;
00300         operator string () const;
00305         double get() const;
00306 #ifndef WITHOUT_ACS
00307 
00311         IDLLength toIDLLength() const;
00312 #endif
00313 
00317         static string unit();
00318 private:
00319         double value;
00320 };
00321 // Length constructors
00322 inline Length::Length() : value(0.0) {
00323 }
00324 inline Length::Length(const Length &t) : value(t.value) {
00325 }
00326 #ifndef WITHOUT_ACS
00327 inline Length::Length(const IDLLength &l) : value(l.value) {
00328 }
00329 #endif
00330 inline Length::Length(const string &s) : value(fromString(s)) {
00331 }
00332 inline Length::Length(double v) : value(v) {
00333 }
00334 // Length destructor
00335 inline Length::~Length() { }
00336 // assignment operator
00337 inline Length & Length::operator = ( const Length &t ) {
00338         value = t.value;
00339         return *this;
00340 }
00341 // assignment operator
00342 inline Length & Length::operator = ( const double v ) {
00343         value = v;
00344         return *this;
00345 }
00346 // assignment with arithmetic operators
00347 inline Length & Length::operator += ( const Length & t) {
00348         value += t.value;
00349         return *this;
00350 }
00351 inline Length & Length::operator -= ( const Length & t) {
00352         value -= t.value;
00353         return *this;
00354 }
00355 inline Length & Length::operator *= ( const double n) {
00356         value *= n;
00357         return *this;
00358 }
00359 inline Length & Length::operator /= ( const double n) {
00360         value /= n;
00361         return *this;
00362 }
00363 // arithmetic functions
00364 inline Length Length::operator + ( const Length &t2 ) const {
00365         Length tmp;
00366         tmp.value = value + t2.value;
00367         return tmp;
00368 }
00369 inline Length Length::operator - ( const Length &t2 ) const {
00370         Length tmp;
00371         tmp.value = value - t2.value;
00372         return tmp;
00373 }
00374 inline Length Length::operator * ( const double n) const {
00375         Length tmp;
00376         tmp.value = value * n;
00377         return tmp;
00378 }
00379 inline Length Length::operator / ( const double n) const {
00380         Length tmp;
00381         tmp.value = value / n;
00382         return tmp;
00383 }
00384 // comparison operators
00385 inline bool Length::operator < (const Length & x) const {
00386         return (value < x.value);
00387 }
00388 inline bool Length::operator > (const Length & x) const {
00389         return (value > x.value);
00390 }
00391 inline bool Length::operator <= (const Length & x) const {
00392         return (value <= x.value);
00393 }
00394 inline bool Length::operator >= (const Length & x) const {
00395         return (value >= x.value);
00396 }
00397 inline bool Length::equals(const Length & x) const {
00398         return (value == x.value);
00399 }
00400 inline bool Length::operator == (const Length & x) const {
00401         return (value == x.value);
00402 }
00403 inline bool Length::operator != (const Length & x) const {
00404         return (value != x.value);
00405 }
00406 // unary - and + operators
00407 inline Length Length::operator - () const {
00408         Length tmp;
00409         tmp.value = -value;
00410         return tmp;
00411 }
00412 inline Length Length::operator + () const {
00413         Length tmp;
00414     tmp.value = value;
00415         return tmp;
00416 }
00417 // Conversion functions
00418 inline Length::operator string () const {
00419         return toString();
00420 }
00421 inline string Length::toString() const {
00422         return toString(value);
00423 }
00424 inline string Length::toStringI() const {
00425         return toString(value);
00426 }
00427 inline double Length::get() const {
00428         return value;
00429 }
00430 #ifndef WITHOUT_ACS
00431 inline IDLLength Length::toIDLLength() const {
00432         IDLLength tmp;
00433         tmp.value = value;
00434         return tmp;
00435 }
00436 #endif
00437 // Friend functions
00438 inline Length operator * ( double n, const Length &x) {
00439         Length tmp;
00440         tmp.value = x.value * n;
00441         return tmp;
00442 }
00443 inline ostream & operator << ( ostream &o, const Length &x ) {
00444         o << x.value;
00445         return o;
00446 }
00447 inline istream & operator >> ( istream &i, Length &x ) {
00448         i >> x.value;
00449         return i;
00450 }
00451 inline string Length::unit() {
00452         return string ("m");
00453 }
00454 } // End namespace asdm
00455 #endif /* Length_CLASS */