acstimeEpochHelper.h

Go to the documentation of this file.

/* @(#) $Id: acstimeEpochHelper.h,v 1.18 2008/10/09 07:31:16 cparedes Exp $
 *
 * Copyright (C) 2001
 * Associated Universities, Inc. Washington DC, USA.
 *
 * Produced for the ALMA project
 *
 * This library is free software; you can redistribute it and/or modify it it 
 * under the terms of the GNU Library General Public License as published by 
 * the Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This library is distributed in the hope that it will be useful but WITHOUT 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Library General Public License 
 * along with this library; if not, write to the Free Software Foundation, 
 * Inc., 675 Massachusetts Ave, Cambridge, MA, 02139, USA.
 *
 * Correspondence concerning ALMA should be addressed as follows:
 * Internet email: alma-sw-admin@nrao.edu
 */
/* ----------------------------------------------------------------*/
#ifndef ACSTIME_EPOCH_HELPER_H
#define ACSTIME_EPOCH_HELPER_H
/* ----------------------------------------------------------------*/
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
/* ----------------------------------------------------------------*/
#include "acstimeTimeUtil.h"
#include "acstimeDurationHelper.h"
/* ----------------------------------------------------------------*/
class EpochHelper : TimeUtil
{
  public:
    /* ----------------------------------------------------------------*/
    EpochHelper(const acstime::Epoch &epoch);
    
    EpochHelper();

    EpochHelper(long double MJDSeconds);

    EpochHelper(const ACS::Time &value);

    virtual ~EpochHelper(){};
    /* ----------------------------------------------------------------*/
    acstime::Epoch value();

    void value(const acstime::Epoch &epoch);

    void value(const ACS::Time &epoch);

    void value(long double MJDSeconds);
    /* ----------------------------------------------------------------*/
    CORBA::ULong year();

    void year(const CORBA::ULong&);
    /* ----------------------------------------------------------------*/
    CORBA::Long month();

    void month(const CORBA::Long&);
    /* ----------------------------------------------------------------*/
    CORBA::Long day();

    void day(const CORBA::Long&);
    /* ----------------------------------------------------------------*/
    CORBA::Long dayOfYear();

    void dayOfYear(const CORBA::Long&);
    /* ----------------------------------------------------------------*/
    CORBA::ULong dayOfWeek();
    /* ----------------------------------------------------------------*/
    CORBA::Long hour();

    void hour(const CORBA::Long&);
    /* ----------------------------------------------------------------*/
    CORBA::Long minute();

    void minute(const CORBA::Long&);
    /* ----------------------------------------------------------------*/
    CORBA::Long second();

    void second(const CORBA::Long&);
    /* ----------------------------------------------------------------*/
    CORBA::Long microSecond();

    void microSecond(const CORBA::Long&);
    /* ----------------------------------------------------------------*/
    CORBA::Boolean normalize();

    void normalize(const CORBA::Boolean&);
    /* ----------------------------------------------------------------*/
    void reset();
    /* ----------------------------------------------------------------*/
    acstime::TimeComparison 
    compare(const acstime::Epoch &epoch);
    //These are the equivalent of the compare method()
    CORBA::Boolean operator==(const acstime::Epoch &epoch) const;
    CORBA::Boolean operator<=(const acstime::Epoch &epoch) const;
    CORBA::Boolean operator<(const acstime::Epoch &epoch) const;
    CORBA::Boolean operator>=(const acstime::Epoch &epoch) const;
    CORBA::Boolean operator>(const acstime::Epoch &epoch) const;

    void add(const acstime::Duration&);
    
    EpochHelper& operator+=(const acstime::Duration &duration);

    void subtract(const acstime::Duration&);
    
    EpochHelper& operator-=(const acstime::Duration &duration);

    acstime::Duration difference(const acstime::Epoch &subtrahend);

    void modulo(const acstime::Epoch &epoch);

    EpochHelper& operator%=(const acstime::Epoch &epoch);
    
    CORBA::Double toUTCdate(CORBA::Long array2TAI, CORBA::Long TAI2UTC);

    long double toMJDseconds();
    
    CORBA::Double toJulianYear(CORBA::Long array2TAI, CORBA::Long TAI2UTC);
    /* ----------------------------------------------------------------*/
    std::string toString(acstime::TimeSystem, const char*, const CORBA::Long array2TAI, const CORBA::Long TAI2UTC);

    void fromString(acstime::TimeSystem, const char*);

    friend DurationHelper* operator% (const EpochHelper&, const ACS::TimeInterval &);
    friend DurationHelper* operator% (const ACS::TimeInterval &, const EpochHelper&);

  private:
    /* ----------------------------------------------------------------*/
    void m_toValue(CORBA::Boolean booVal);
    
    void m_toAttributes();
    
    long m_calcLeap();
    
    void m_almostUnix(std::ostringstream&);
    void m_iso8601date(std::ostringstream&);
    void m_iso8601full(std::ostringstream&);
    void m_abbrevMonth(std::ostringstream&);
    void m_abbrevWeekday(std::ostringstream&);
    void m_microSec(std::ostringstream&, int);
    /* ----------------------------------------------------------------*/
    //The real variables affected by calls to public methods.
    acstime::Epoch value_m;
    CORBA::ULong year_m;
    CORBA::Long month_m;
    CORBA::Long day_m;
    CORBA::Long day_mOfYear;
    CORBA::ULong dayOfWeek_m;
    CORBA::Long hour_m;
    CORBA::Long minute_m;
    CORBA::Long second_m;
    CORBA::Long microSecond_m;
    CORBA::Boolean normalize_m;
    
    EpochHelper(const EpochHelper&);
    
    void operator= (const EpochHelper&);
};

DurationHelper* operator% (const EpochHelper&, const ACS::TimeInterval &);

DurationHelper* operator% (const ACS::TimeInterval &, const EpochHelper&);

#endif