ArrayTimeInterval.h
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifndef ArrayTimeInterval_CLASS
00028 #define ArrayTimeInterval_CLASS
00029
00030 #include <stdint.h>
00031 #include <LongWrapper.h>
00032 #include <ArrayTime.h>
00033 #include <Interval.h>
00034
00035 #ifndef WITHOUT_ACS
00036 #include <asdmIDLTypesC.h>
00037 #endif
00038
00039 using asdm::Long;
00040 using asdm::Interval;
00041 using asdm::ArrayTime;
00042
00043 #ifndef WITHOUT_ACS
00044 using asdmIDLTypes::IDLArrayTimeInterval;
00045 #endif
00046
00047 namespace asdm {
00048
00055 class ArrayTimeInterval {
00056 friend ostream & operator << ( ostream &, ArrayTimeInterval& );
00057 friend istream & operator >> ( istream &, ArrayTimeInterval& );
00058 private:
00059
00060 ArrayTime start;
00061 Interval duration;
00062
00063 static bool readStartTimeDurationInBin_;
00064 static bool readStartTimeDurationInXML_;
00065
00066 public:
00067
00068
00069
00070 ArrayTimeInterval();
00071 ArrayTimeInterval(ArrayTime start,
00072 Interval duration);
00073
00074 ArrayTimeInterval(double startInMJD,
00075 double durationInDays);
00076
00077 ArrayTimeInterval(int64_t startInNanoSeconds,
00078 int64_t durationInNanoSeconds);
00079
00080 ArrayTimeInterval(ArrayTime start);
00081 ArrayTimeInterval(double startInMJD);
00082 ArrayTimeInterval(int64_t startInNanoSeconds);
00083
00084 #ifndef WITHOUT_ACS
00085 ArrayTimeInterval (IDLArrayTimeInterval t);
00086 #endif
00087
00088 void setStart(ArrayTime start);
00089 void setStart(double start);
00090 void setStart(int64_t start);
00091
00092 void setDuration(Interval duration);
00093 void setDuration(int64_t nanoSeconds);
00094 void setDuration(double days);
00095
00096
00097 ArrayTime getStart() const ;
00098 ArrayTime getMidPoint() const ;
00099 double getStartInMJD() const ;
00100 int64_t getStartInNanoSeconds() const ;
00101
00102 Interval getDuration() const ;
00103 int64_t getDurationInNanoSeconds() const ;
00104 double getDurationInDays() const ;
00105
00106
00107 bool equals(ArrayTimeInterval ati);
00108 bool overlaps(ArrayTimeInterval ati);
00109 bool contains(ArrayTimeInterval ati);
00110 bool contains(ArrayTime at);
00111
00112
00113 bool operator == (ArrayTimeInterval&);
00114 bool operator != (ArrayTimeInterval&);
00115
00116 #ifndef WITHOUT_ACS
00117
00118 const asdmIDLTypes::IDLArrayTimeInterval toIDLArrayTimeInterval() const;
00119 #endif
00120
00128 static void readStartTimeDurationInBin(bool b);
00129
00136 static bool readStartTimeDurationInBin();
00137
00146 static void readStartTimeDurationInXML(bool b);
00147
00154 static bool readStartTimeDurationInXML();
00155
00160 void toBin(EndianOSStream& eoss) const ;
00161
00167 static void toBin(const vector<ArrayTimeInterval>& arrayTimeInterval, EndianOSStream& eoss);
00168
00174 static void toBin(const vector<vector<ArrayTimeInterval> >& arrayTimeInterval, EndianOSStream& eoss);
00175
00181 static void toBin(const vector<vector<vector<ArrayTimeInterval> > >& arrayTimeInterval, EndianOSStream& eoss);
00182
00189 static ArrayTimeInterval fromBin(EndianIStream& eis);
00190
00197 static vector<ArrayTimeInterval> from1DBin(EndianIStream & eis);
00198
00205 static vector<vector<ArrayTimeInterval> > from2DBin(EndianIStream & eis);
00206
00213 static vector<vector<vector<ArrayTimeInterval> > > from3DBin(EndianIStream & eis);
00214
00218 string toString() const ;
00219 };
00220
00221
00222
00223
00224 inline ArrayTimeInterval::ArrayTimeInterval(): start((int64_t)0), duration(0) {}
00225 inline ArrayTimeInterval::ArrayTimeInterval(ArrayTime start_, Interval duration_) {
00226 start = start_;
00227 duration = Interval(min(duration_.get(), Long::MAX_VALUE - start.get()));
00228 }
00229
00230 inline ArrayTimeInterval::ArrayTimeInterval(double startInMJD, double durationInDays) :
00231 start(startInMJD),
00232 duration((int64_t) (ArrayTime::unitsInADay * durationInDays)){}
00233
00234 inline ArrayTimeInterval::ArrayTimeInterval(int64_t startInNanoSeconds,
00235 int64_t durationInNanoSeconds){
00236 start = startInNanoSeconds;
00237 duration = min(durationInNanoSeconds, Long::MAX_VALUE - startInNanoSeconds);
00238 }
00239
00240 inline ArrayTimeInterval::ArrayTimeInterval(ArrayTime start_):
00241 start(start_) {
00242 duration = Interval(Long::MAX_VALUE - start.get());
00243 }
00244
00245 inline ArrayTimeInterval::ArrayTimeInterval(double startInMJD):
00246 start(startInMJD) {
00247 this->duration = Interval(Long::MAX_VALUE - start.get());
00248 }
00249
00250 inline ArrayTimeInterval::ArrayTimeInterval(int64_t startInNanoSeconds):
00251 start(startInNanoSeconds) {
00252 this->duration = Interval(Long::MAX_VALUE - start.get());
00253 }
00254
00255
00256 inline void ArrayTimeInterval::setStart(ArrayTime start) {
00257 this->start = ArrayTime(start);
00258 }
00259
00260 inline void ArrayTimeInterval::setStart(double start) {
00261 this->start = ArrayTime(start);
00262 }
00263
00264 inline void ArrayTimeInterval::setStart(int64_t start) {
00265 this->start = ArrayTime(start);
00266 }
00267
00268 inline void ArrayTimeInterval::setDuration(Interval duration) {
00269 this->duration = Interval(duration);
00270 }
00271
00272
00273 inline void ArrayTimeInterval::setDuration(double duration) {
00274 this->duration = Interval((int64_t) (ArrayTime::unitsInADay * duration));
00275 }
00276
00277 inline void ArrayTimeInterval::setDuration(int64_t duration) {
00278 this->duration = Interval(duration);
00279 }
00280
00281
00282 inline ArrayTime ArrayTimeInterval::getStart() const {
00283 return start;
00284 }
00285
00286 inline ArrayTime ArrayTimeInterval::getMidPoint() const {
00287 return ArrayTime(start.get() + duration.get() / 2);
00288 }
00289
00290 inline double ArrayTimeInterval::getStartInMJD() const {
00291 return start.getMJD();
00292 }
00293
00294 inline int64_t ArrayTimeInterval::getStartInNanoSeconds() const {
00295 return start.get();
00296 }
00297
00298 inline Interval ArrayTimeInterval::getDuration() const {
00299 return duration;
00300 }
00301
00302 inline double ArrayTimeInterval::getDurationInDays() const {
00303 return (((double) duration.get()) / ArrayTime::unitsInADay);
00304 }
00305
00306 inline int64_t ArrayTimeInterval::getDurationInNanoSeconds() const {
00307 return duration.get();
00308 }
00309
00310
00311 inline bool ArrayTimeInterval::equals(ArrayTimeInterval ati) {
00312 return ((start.get() == ati.getStart().get()) &&
00313 (duration.get() == ati.getDuration().get()));
00314 }
00315
00316 inline bool ArrayTimeInterval::overlaps(ArrayTimeInterval ati) {
00317 int64_t start1 = start.get();
00318 int64_t end1 = start1 + duration.get();
00319
00320
00321 int64_t start2 = ati.getStart().get();
00322 int64_t end2 = start2 + ati.getDuration().get();
00323
00324 return (start2 <= start1 && end2 >= start1) ||
00325 (start2 >= start1 && start2 <= end1);
00326 }
00327
00328 inline bool ArrayTimeInterval::contains(ArrayTimeInterval ati) {
00329 int64_t start1 = start.get();;
00330 int64_t end1 = start1 + duration.get();
00331
00332 int64_t start2 = ati.getStart().get();
00333 int64_t end2 = start2 + ati.getDuration().get();
00334
00335 return (start2>=start1 && end2<=end1);
00336 }
00337
00338 inline bool ArrayTimeInterval::contains(ArrayTime ati) {
00339 int64_t start1 = start.get();
00340 int64_t end1 = start1 + duration.get();
00341
00342 int64_t time = ati.get();
00343 return (time >= start1 && time < end1);
00344 }
00345
00346 inline bool ArrayTimeInterval::operator == (ArrayTimeInterval &ati){
00347 return (start == ati.start) && (duration == ati.duration);
00348 }
00349
00350 inline bool ArrayTimeInterval::operator != (ArrayTimeInterval &ati){
00351 return (start != ati.start) || (duration != ati.duration);
00352 }
00353
00354 inline ostream & operator << ( ostream &o, ArrayTimeInterval &ati ) {
00355 o << "(start=" << ati.getStart().get() << ",duration=" << ati.getDuration().get() << ")";
00356 return o;
00357 }
00358
00359 inline istream & operator >> ( istream &i, ArrayTimeInterval &ati) {
00360 i >> ati.start;
00361 i >> ati.duration;
00362 return i;
00363 }
00364 }
00365 #endif // ArrayTimeInterval_CLASS