psitime.h

Go to the documentation of this file.

/*
 * This file is part of plptools.
 *
 *  Copyright (C) 2000-2002 Fritz Elfert <felfert@to.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  along with this program; if not, see <https://www.gnu.org/licenses/>.
 *
 */
#pragma once
 
#include "config.h"
 
#include <iostream>
#include <cstdint>
 
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
 
#include "plpintl.h"
 
typedef struct psi_timeval_t {
    friend std::ostream &operator<<(std::ostream &o, const psi_timeval_t &ptv) {
        std::ostream::fmtflags old = o.flags();
        uint64_t micro = ptv.tv_high;
        micro = (micro << 32) | ptv.tv_low;
        micro /= 1000000;
        int s = micro % 60;
        micro /= 60;
        int m = micro % 60;
        micro /= 60;
        int h = micro % 24;
        micro /= 24;
        int d = micro % 365;
        micro /= 365;
        int y = micro;
        o << std::dec;
        if (y > 0)
            o << y << ((y > 1) ? _(" years ") : _(" year "));
        if (d > 0)
            o << d << ((d > 1) ? _(" days ") : _(" day "));
        if (h > 0)
            o << h << ((h != 1) ? _(" hours ") : _(" hour "));
        if (m > 0)
            o << m << ((m != 1) ? _(" minutes ") : _(" minute "));
        o << s << ((s != 1) ? _(" seconds") : _(" second"));
        o.flags(old);
        return o;
    }
    uint32_t tv_low;
    uint32_t tv_high;
} psi_timeval;
 
typedef struct psi_timezone_t {
    friend std::ostream &operator<<(std::ostream &s, const psi_timezone_t &ptz) {
        std::ostream::fmtflags old = s.flags();
        int h = ptz.utc_offset / 3600;
        int m = ptz.utc_offset % 3600;
        s << "offs: " << std::dec << h << "h";
        if (m != 0)
            s << ", " << m << "m";
        s.flags(old);
        return s;
    }
    signed long   utc_offset;
    unsigned long dst_zones;
    unsigned long home_zone;
} psi_timezone;
 
class PsiTime {
public:
    PsiTime(struct timeval *_utv, struct timezone *_utz = nullptr);
 
    PsiTime(time_t time);
 
    PsiTime(psi_timeval *_ptv, psi_timezone *_ptz = nullptr);
 
    PsiTime(const uint32_t _ptvHi, const uint32_t _ptvLo);
 
    PsiTime(void);
 
    PsiTime(const PsiTime &t);
 
    ~PsiTime();
 
    void setPsiTime(psi_timeval *_ptv);
 
    void setSiboTime(uint32_t stime);
 
    void setPsiTime(const uint32_t _ptvHi, const uint32_t _ptvLo);
 
    void setPsiZone(psi_timezone *_ptz);
 
    void setUnixTime(struct timeval *_utv);
 
    void setUnixTime(time_t time);
 
    void setUnixNow(void);
 
    struct timeval &getTimeval(void);
 
    time_t getTime(void);
 
    uint32_t getSiboTime();
 
    psi_timeval &getPsiTimeval(void);
 
    uint32_t getPsiTimeLo(void);
 
    uint32_t getPsiTimeHi(void);
 
    friend std::ostream &operator<<(std::ostream &s, const PsiTime &t);
 
    PsiTime &operator=(const PsiTime &t);
 
    bool operator==(const PsiTime &t);
    bool operator<(const PsiTime &t);
    bool operator>(const PsiTime &t);
 
    enum zone {
        PSI_TZ_NONE = 0,
        PSI_TZ_EUROPEAN = 1,
        PSI_TZ_NORTHERN = 2,
        PSI_TZ_SOUTHERN = 4,
        PSI_TZ_HOME = 0x40000000
    };
 
private:
    void psi2unix(void);
    void unix2psi(void);
    void tryPsiZone();
 
    psi_timeval ptv;
    psi_timezone ptz;
    struct timeval utv;
    struct timezone utz;
    bool ptzValid;
};
 
class PsiZone {
    friend class RPCS32;
 
public:
    static PsiZone &getInstance();
 
    bool getZone(psi_timezone &ptz);
 
private:
    static PsiZone *_instance;
 
    PsiZone();
 
    void setZone(psi_timezone &ptz);
 
    bool _ptzValid;
    psi_timezone _ptz;
};