Interval.h

Go to the documentation of this file.
00001 /*
00002  * ALMA - Atacama Large Millimeter Array
00003  * (c) European Southern Observatory, 2002
00004  * (c) Associated Universities Inc., 2002
00005  * Copyright by ESO (in the framework of the ALMA collaboration),
00006  * Copyright by AUI (in the framework of the ALMA collaboration),
00007  * All rights reserved.
00008  * 
00009  * This library is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU Lesser General Public
00011  * License as published by the Free software Foundation; either
00012  * version 2.1 of the License, or (at your option) any later version.
00013  * 
00014  * This library is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY, without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017  * Lesser General Public License for more details.
00018  * 
00019  * You should have received a copy of the GNU Lesser General Public
00020  * License along with this library; if not, write to the Free Software
00021  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
00022  * MA 02111-1307  USA
00023  *
00024  * File Interval.h
00025  */
00026 
00027 #ifndef Interval_CLASS
00028 #define Interval_CLASS
00029 
00030 #include <stdint.h>
00031 #include <vector>
00032 #include <iostream>
00033 #include <string>
00034 using namespace std;
00035 
00036 #ifndef WITHOUT_ACS
00037 #include <asdmIDLTypesC.h>
00038 using asdmIDLTypes::IDLInterval;
00039 #endif
00040 
00041 #include <StringTokenizer.h>
00042 #include <NumberFormatException.h>
00043 using asdm::StringTokenizer;
00044 using asdm::NumberFormatException;
00045 
00046 #include <EndianStream.h>
00047 using asdm::EndianOSStream;
00048 using asdm::EndianISStream;
00049 
00050 namespace asdm {
00051 
00052 class Interval;
00053 Interval operator * ( int64_t , const Interval & );
00054 ostream & operator << ( ostream &, const Interval & );
00055 istream & operator >> ( istream &, Interval&);
00056 
00064 class Interval {
00065         friend Interval operator * ( int64_t , const Interval & );
00066     friend ostream & operator << ( ostream &, const Interval & );
00067         friend istream & operator >> ( istream &, Interval&);
00068 
00069 public:
00070         static int64_t fromString(const string&);
00071         static string toString(int64_t);
00072         static Interval getInterval(StringTokenizer &t) throw(NumberFormatException);
00073 
00074         Interval();                                             // default constructor
00075         Interval(const Interval &);                                             // X const X& constructor
00076         Interval(const string &s);
00077 #ifndef WITHOUT_ACS
00078         Interval(const IDLInterval &);
00079 #endif
00080         Interval(int64_t value);
00081         virtual ~Interval();                                                    // destructor
00082 
00083         Interval& operator = (const Interval&);                 // assignment operator
00084         Interval& operator = (const int64_t);                   // assignment operator
00085 
00086         Interval& operator += (const Interval&);                // assignment with arithmetic
00087         Interval& operator -= (const Interval&);                //      operators
00088         Interval& operator *= (const int64_t);
00089         Interval& operator /= (const int64_t);
00090 
00091         Interval operator + (const Interval&) const;    // arithmetic operators
00092         Interval operator - (const Interval&) const;
00093         Interval operator * (const int64_t) const;
00094         Interval operator / (const int64_t) const;
00095 
00096         bool operator < (const Interval&) const;                // comparison operators
00097         bool operator > (const Interval&) const;
00098         bool operator <= (const Interval&) const;
00099         bool operator >= (const Interval&) const;
00100         bool operator == (const Interval&) const;
00101         bool equals(const Interval&) const;
00102         bool operator != (const Interval&) const;
00103 
00104         bool isZero() const;
00105 
00106         Interval operator - () const;                                   // unary minus
00107         Interval operator + () const;                           // unary plus
00108 
00109         string toString() const;
00110         string toStringI() const;
00111         
00117         void  toBin(EndianOSStream& eoss) ;
00118         
00124         static void toBin(vector<Interval> interval, EndianOSStream& eoss) ;
00125         
00131         static void toBin(vector<vector<Interval> > interval, EndianOSStream& eoss) ;
00132         
00139         static Interval fromBin(EndianISStream& eiss);
00140         
00147         static vector<Interval> from1DBin(EndianISStream& eiss);
00148         
00155         static vector<vector<Interval> >from2DBin(EndianISStream& eiss);        
00156         
00157         operator string () const;
00158         int64_t get() const;
00159 #ifndef WITHOUT_ACS
00160         IDLInterval toIDLInterval() const;
00161 #endif
00162         static string unit();
00163 
00164 private:
00165         int64_t value;
00166 
00167 };
00168 
00169 // Interval constructors
00170 inline Interval::Interval() : value(0L) {
00171 }
00172 
00173 inline Interval::Interval(const Interval &t) : value(t.value) {
00174 }
00175 
00176 #ifndef WITHOUT_ACS
00177 inline Interval::Interval(const IDLInterval &l) : value(l.value) {
00178 }
00179 #endif
00180 
00181 inline Interval::Interval(const string &s) : value(fromString(s)) {
00182 }
00183 
00184 inline Interval::Interval(int64_t v) : value(v) {
00185 }
00186 
00187 // Interval destructor
00188 inline Interval::~Interval() { }
00189 
00190 // assignment operator
00191 inline Interval& Interval::operator = ( const Interval &t ) {
00192         value = t.value;
00193         return *this;
00194 }
00195 
00196 // assignment operator
00197 inline Interval& Interval::operator = ( const int64_t v ) {
00198         value = v;
00199         return *this;
00200 }
00201 
00202 // assignment with arithmetic operators
00203 inline Interval& Interval::operator += ( const Interval& t) {
00204         value += t.value;
00205         return *this;
00206 }
00207 
00208 inline Interval& Interval::operator -= ( const Interval& t) {
00209         value -= t.value;
00210         return *this;
00211 }
00212 
00213 inline Interval& Interval::operator *= ( const int64_t n) {
00214         value *= n;
00215         return *this;
00216 }
00217 
00218 inline Interval& Interval::operator /= ( const int64_t n) {
00219         value /= n;
00220         return *this;
00221 }
00222 
00223 // arithmetic functions
00224 inline Interval Interval::operator + ( const Interval &t2 ) const {
00225         Interval tmp;
00226         tmp.value = value + t2.value;
00227         return tmp;
00228 }
00229 
00230 inline Interval Interval::operator - ( const Interval &t2 ) const {
00231         Interval tmp;
00232         tmp.value = value - t2.value;
00233         return tmp;
00234 }
00235 inline Interval Interval::operator * ( const int64_t n) const {
00236         Interval tmp;
00237         tmp.value = value * n;
00238         return tmp;
00239 }
00240 
00241 inline Interval Interval::operator / ( const int64_t n) const {
00242         Interval tmp;
00243         tmp.value = value / n;
00244         return tmp;
00245 }
00246 
00247 // comparison operators
00248 inline bool Interval::operator < (const Interval& x) const {
00249         return (value < x.value);
00250 }
00251 
00252 inline bool Interval::operator > (const Interval& x) const {
00253         return (value > x.value);
00254 }
00255 
00256 inline bool Interval::operator <= (const Interval& x) const {
00257         return (value <= x.value);
00258 }
00259 
00260 inline bool Interval::operator >= (const Interval& x) const {
00261         return (value >= x.value);
00262 }
00263 
00264 inline bool Interval::operator == (const Interval& x) const {
00265         return (value == x.value);
00266 }
00267 inline bool Interval::equals(const Interval& x) const {
00268         return (value == x.value);
00269 }
00270 
00271 inline bool Interval::operator != (const Interval& x) const {
00272         return (value != x.value);
00273 }
00274 
00275 // unary - and + operators
00276 inline Interval Interval::operator - () const {
00277         Interval tmp;
00278         tmp.value = -value;
00279         return tmp;
00280 }
00281 
00282 inline Interval Interval::operator + () const {
00283         Interval tmp;
00284     tmp.value = value;
00285         return tmp;
00286 }
00287 
00288 // Conversion functions
00289 inline Interval::operator string () const {
00290         return toString();
00291 }
00292 
00293 inline string Interval::toString() const {
00294         return toString(value);
00295 }
00296 
00297 inline string Interval::toStringI() const {
00298         return toString(value);
00299 }
00300 
00301 inline int64_t Interval::get() const {
00302         return value;
00303 }
00304 
00305 #ifndef WITHOUT_ACS
00306 inline IDLInterval Interval::toIDLInterval() const {
00307         IDLInterval tmp;
00308         tmp.value = value;
00309         return tmp;
00310 }
00311 #endif
00312 
00313 // Friend functions
00314 
00315 inline Interval operator * ( int64_t n, const Interval &x) {
00316         Interval tmp;
00317         tmp.value = x.value * n;
00318         return tmp;
00319 }
00320 
00321 inline ostream & operator << ( ostream &o, const Interval &x ) {
00322         o << x.value;
00323         return o;
00324 }
00325 
00326 inline istream & operator >> ( istream &i, Interval &x ) {
00327         i >> x.value;
00328         return i;
00329 }
00330 
00331 inline string Interval::unit() {
00332         return string ("nanosec");
00333 }
00334 
00335 } // End namespace asdm
00336 
00337 #endif /* Interval_CLASS */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines