framecount.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cmath>
#include <cstdint>
#include <limits>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/framenumber.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class FrameCount {
        public:
                PROMEKI_DATATYPE(FrameCount, DataTypeFrameCount, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<FrameCount> readFromStream(DataStream &s);
 
                static constexpr int64_t UnknownValue = -1;
                static constexpr int64_t InfinityValue = -2;
 
                static constexpr FrameCount unknown() {
                        FrameCount c;
                        c._value = UnknownValue;
                        return c;
                }
                static constexpr FrameCount infinity() {
                        FrameCount c;
                        c._value = InfinityValue;
                        return c;
                }
                static constexpr FrameCount empty() {
                        FrameCount c;
                        c._value = 0;
                        return c;
                }
 
                static Result<FrameCount> fromString(const String &str);
 
                constexpr FrameCount() = default;
 
                constexpr FrameCount(int64_t v) : _value(v < 0 ? UnknownValue : v) {}
 
                constexpr bool isValid() const { return _value != UnknownValue; }
 
                constexpr bool isUnknown() const { return _value == UnknownValue; }
 
                constexpr bool isInfinite() const { return _value == InfinityValue; }
 
                constexpr bool isFinite() const { return _value >= 0; }
 
                constexpr bool isEmpty() const { return _value == 0; }
 
                constexpr int64_t value() const { return _value; }
 
                double toDouble() const {
                        if (isUnknown()) return std::numeric_limits<double>::quiet_NaN();
                        if (isInfinite()) return std::numeric_limits<double>::infinity();
                        return static_cast<double>(_value);
                }
 
                static Result<FrameCount> fromDouble(double v) {
                        if (std::isnan(v)) return makeResult(FrameCount::unknown());
                        if (std::isinf(v)) return makeResult(FrameCount::infinity());
                        if (v < 0.0) return makeResult(FrameCount::unknown());
                        return makeResult(FrameCount(static_cast<int64_t>(v)));
                }
 
                FrameCount &operator+=(int64_t n);
 
                FrameCount &operator-=(int64_t n);
 
                FrameCount &operator+=(const FrameCount &other);
 
                FrameCount &operator-=(const FrameCount &other);
 
                FrameCount &operator++() {
                        *this += 1;
                        return *this;
                }
                FrameCount operator++(int) {
                        FrameCount o = *this;
                        *this += 1;
                        return o;
                }
                FrameCount &operator--() {
                        *this -= 1;
                        return *this;
                }
                FrameCount operator--(int) {
                        FrameCount o = *this;
                        *this -= 1;
                        return o;
                }
 
                constexpr bool operator==(const FrameCount &other) const { return _value == other._value; }
                constexpr bool operator!=(const FrameCount &other) const { return _value != other._value; }
 
                bool operator<(const FrameCount &other) const;
                bool operator>(const FrameCount &other) const { return other < *this; }
                bool operator<=(const FrameCount &other) const {
                        if (isUnknown() || other.isUnknown()) return false;
                        return !(other < *this);
                }
                bool operator>=(const FrameCount &other) const {
                        if (isUnknown() || other.isUnknown()) return false;
                        return !(*this < other);
                }
 
                String toString() const;
 
                operator String() const { return toString(); }
 
        private:
                int64_t _value = UnknownValue;
};
 
inline FrameNumber toFrameNumber(const FrameCount &c) {
        return c.isFinite() ? FrameNumber(c.value()) : FrameNumber::unknown();
}
 
inline FrameCount toFrameCount(const FrameNumber &n) {
        return n.isValid() ? FrameCount(n.value()) : FrameCount::unknown();
}
 
inline FrameCount operator+(FrameCount a, const FrameCount &b) {
        a += b;
        return a;
}
inline FrameCount operator-(FrameCount a, const FrameCount &b) {
        a -= b;
        return a;
}
inline FrameCount operator+(FrameCount a, int64_t n) {
        a += n;
        return a;
}
inline FrameCount operator-(FrameCount a, int64_t n) {
        a -= n;
        return a;
}
inline FrameCount operator+(int64_t n, FrameCount a) {
        a += n;
        return a;
}
 
// ----------------------------------------------------------------------
// FrameNumber / FrameCount cross-type arithmetic.
//
// Defined here because framenumber.h cannot see the full FrameCount
// definition (it forward-declares FrameCount), but framecount.h knows
// both types.  Inline so the compiler can still optimise them away.
// ----------------------------------------------------------------------
 
inline FrameNumber operator+(FrameNumber a, const FrameCount &c) {
        if (a.isUnknown() || c.isUnknown() || c.isInfinite()) return FrameNumber::unknown();
        return FrameNumber(a.value() + c.value());
}
 
inline FrameNumber operator-(FrameNumber a, const FrameCount &c) {
        if (a.isUnknown() || c.isUnknown() || c.isInfinite()) return FrameNumber::unknown();
        int64_t nv = a.value() - c.value();
        return nv < 0 ? FrameNumber::unknown() : FrameNumber(nv);
}
 
inline FrameCount operator-(const FrameNumber &a, const FrameNumber &b) {
        if (a.isUnknown() || b.isUnknown()) return FrameCount::unknown();
        int64_t d = a.value() - b.value();
        return d < 0 ? FrameCount::unknown() : FrameCount(d);
}
 
inline FrameNumber &FrameNumber::operator+=(const FrameCount &c) {
        *this = *this + c;
        return *this;
}
inline FrameNumber &FrameNumber::operator-=(const FrameCount &c) {
        *this = *this - c;
        return *this;
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::FrameCount);
 
template <> struct std::hash<promeki::FrameCount> {
                size_t operator()(const promeki::FrameCount &v) const noexcept {
                        return std::hash<int64_t>()(v.value());
                }
};
 
#endif // PROMEKI_ENABLE_CORE