Sample.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
 */
#include <duds/data/GenericValue.hpp>
#include <boost/uuid/nil_generator.hpp>
#include <limits>

namespace duds { namespace data {

namespace _it_needs_to_go_somewhere_ {
    template <class T>
    struct infinity {
        static constexpr T value = std::numeric_limits<T>::infinity();
    };
    template <class T>
    struct lowest {
        static constexpr T value = std::numeric_limits<T>::lowest();
    };
}

template <typename QT>
static constexpr QT unspecified() {
    return std::conditional<std::numeric_limits<QT>::has_infinity,
        _it_needs_to_go_somewhere_::infinity<QT>,
        _it_needs_to_go_somewhere_::lowest<QT>
    >::type::value;
}

template <class VT = GenericValue, class QT = double>
struct CompactSample;

template <class VT, class QT>
struct GenericSample {
    typedef VT Value;
    typedef QT Quality;
    static constexpr QT unspecified() {
        return duds::data::unspecified<QT>();
    }
    boost::uuids::uuid origin;
    VT value;
    QT accuracy;
    QT precision;
    QT estError;
    QT resolution;
    CompactSample<VT, QT> makeCompactSample() const;
    operator CompactSample<VT, QT> () const {
        return makeCompactSample();
    }
    void clear() {
        origin = boost::uuids::nil_uuid();
        //value = std::string(); // good idea, but template types kills it
        accuracy = precision = estError = resolution = unspecified();
    }
    bool isClear() const {
        // constraining the value is a nice idea, but is type specific
        return /*(value.which() == 0) &&*/ origin.is_nil();
    }
};

typedef GenericSample<GenericValue, double>  Sample;

template <class VT, class QT>  // default types in forward declaration above
struct CompactSample {
    typedef VT Value;
    typedef QT Quality;
    static constexpr QT Unspecified = std::numeric_limits<QT>::infinity();
    VT value;
    QT accuracy;
    QT precision;
    QT resolution;
    /*
     * Produce a Sample using the data in this CompactSample and the given units.
     * @param unit  The units used in the CompactSample; used to fill the units
     *              field of the procuded Sample object.
     */
     /*
    Sample<VT, QT> makeSample(const Unit unit) const {
        Sample<VT, QT> s = { value, accuracy, precision, resolution, unit };
        return s;
    }
    */
};

// no units
template <class VT, class QT>  // default types in forward declaration above
struct SampleNU {
    typedef VT Value;
    typedef QT Quality;
    static constexpr QT Unspecified = std::numeric_limits<QT>::infinity();
    boost::uuids::uuid origin;
    VT value;
    QT accuracy;
    QT precision;
    QT resolution;
    /*
     * Produce a Sample using the data in this CompactSample and the given units.
     * @param unit  The units used in the CompactSample; used to fill the units
     *              field of the procuded Sample object.
     */
     /*
    Sample<VT, QT> makeSample(const Unit unit) const {
        Sample<VT, QT> s = { value, accuracy, precision, resolution, unit };
        return s;
    }
    */
};


template <class VT, class QT>
CompactSample<VT, QT> GenericSample<VT, QT>::makeCompactSample() const {
    CompactSample<VT, QT> cs = { value, accuracy, precision, resolution };
    return cs;
}

template <class VT>
struct ExtraCompactSample {
    VT value;
};

} }