PosixClock.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#ifndef POSIXCLOCK_HPP
#define POSIXCLOCK_HPP

#include <duds/hardware/devices/clocks/Clock.hpp>
#include <time.h>

#ifndef CLOCK_TAI

#define CLOCK_TAI 11
#endif

namespace duds { namespace hardware { namespace devices { namespace clocks {

struct PosixClockUnsupported : ClockError { };

typedef boost::error_info<struct Info_posixclockid, clockid_t>  PosixClockId;

constexpr boost::uuids::uuid PosixClockDeviceId = {
    0x41, 0xba, 0xe3, 0x09,
    0xc2, 0xe9,
    0x4c, 0x02,
    0xb4, 0xd5,
    0x5b, 0x24, 0xc3, 0x99, 0xc7, 0xeb
};

template<class SVT, class SQT, class TVT, class TQT>
class GenericPosixClock : public GenericClock<SVT, SQT, TVT, TQT> {
public:
    typedef duds::data::GenericMeasurement<SVT, SQT, TVT, TQT> Measurement;
private:
    SQT sampleResolution;
    TQT timeResolution;
    int offset;
    
    // are seconds ok? maybe TVT would work better. might work better for using
    // CLOCK_MONOTONIC, although it cannot be corrected over time.
    // for leap seconds, store a duds::time::interstellar::SecondTime with when
    // leap seconds should be inspected again. when now becomes that time value,
    // query for leap seconds, update the offset and the time to do this again.
    // maybe don't use duds::time::interstellar::SecondTime; use something
    // in the form of the data from the clock for a faster comparison.
    
    clockid_t clk;
    static duds::data::int128_t sum(const timespec &ts) {
        return duds::data::int128_t(
            duds::data::int128_t(ts.tv_sec) * std::nano::den +
            duds::data::int128_t(ts.tv_nsec)
        );
    }
    duds::data::int128_t doSample() const {
        timespec ts;
        int res = clock_gettime(clk, &ts);
        if (res) {
            DUDS_THROW_EXCEPTION(ClockError() << PosixClockId(clk));
        }
        ts.tv_sec += offset;
        return sum(ts);
    }
    template <class Sample>
    void setSample(Sample &dest, const duds::data::int128_t &time) const {
        // two resolutions are stored; select one based on type
        if (std::is_same<SQT, typename Sample::Quality>::value) {
            dest.resolution = sampleResolution;
        } else {
            dest.resolution = timeResolution;
        }
        // not all quality values are reported
        dest.accuracy = dest.estError = dest.precision =
            duds::data::unspecified<typename Sample::Quality>();
        // set the time
        GenericClock<SVT, SQT, TVT, TQT>::template convert<std::nano>(
            dest.value, time);
    }
    struct Token { };
    using duds::hardware::devices::GenericDevice<SVT, SQT, TVT, TQT>::sens;
    using duds::hardware::devices::GenericDevice<SVT, SQT, TVT, TQT>::setMeasurement;
public:
    GenericPosixClock(clockid_t id, int os, Token) :
    GenericClock<SVT, SQT, TVT, TQT>(PosixClockDeviceId), clk(id), offset(os) {
        // query the clock for its resolution
        timespec ts;
        int res = clock_getres(clk, &ts);
        if (res) {
            DUDS_THROW_EXCEPTION(PosixClockUnsupported() << PosixClockId(clk));
        }
        // put the resolution into a single value
        duds::data::int128_t rez = sum(ts);
        // convert the resolution into the two quality types found
        // in a Measurement 
        GenericClock<SVT, SQT, TVT, TQT>::template convert<std::nano>(
            sampleResolution, rez);
        GenericClock<SVT, SQT, TVT, TQT>::template convert<std::nano>(
            timeResolution, rez);
    }
    static std::shared_ptr< GenericPosixClock <SVT, SQT, TVT, TQT> > make(
        clockid_t id = CLOCK_REALTIME, int os = 0
    ) {
        return std::make_shared< GenericPosixClock <SVT, SQT, TVT, TQT> >(
            id, os, Token()
        );
    }
    virtual void sampleTime(typename Measurement::TimeSample &time) {
        duds::data::int128_t sum = doSample();
        setSample(time, sum);
    }
    virtual void sample() {
        std::shared_ptr<Measurement> m =
            std::make_shared<Measurement>();
        duds::data::int128_t sum = doSample();
        setSample(m->measured, sum);
        // no timestamp
        m->timestamp.clear();
        // store the measurement
        setMeasurement(std::move(m));
    }
    virtual void sample(const ClockSptr &clock) {
        std::shared_ptr<Measurement> m =
            std::make_shared<Measurement>();
        duds::data::int128_t sum = doSample();
        setSample(m->measured, sum);
        // if the supplied clock driver is this clock driver . . .
        if (this == clock.get()) {
            // sample the clock just once
            setSample(m->timestamp, sum);
        } else if (clock) {
            // sample the other clock
            clock->sampleTime(m->timestamp);
        } else {
            // no timestamp
            m->timestamp.clear();
        }
        // store the measurement
        setMeasurement(std::move(m));
    }
    virtual bool unambiguous() const noexcept {
        return false;
    }
};

typedef GenericPosixClock<
    duds::data::GenericValue,
    double,
    duds::time::interstellar::NanoTime,
    float
>  PosixClock;

typedef std::shared_ptr<PosixClock>  PosixClockSptr;

} } } }


#endif        //  #ifndef POSIXCLOCK_HPP