framenumber.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/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class FrameCount;
 
class FrameNumber {
        public:
                PROMEKI_DATATYPE(FrameNumber, DataTypeFrameNumber, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<FrameNumber> readFromStream(DataStream &s);
 
                static constexpr int64_t UnknownValue = -1;
 
                static constexpr FrameNumber unknown() { return FrameNumber(); }
 
                static Result<FrameNumber> fromString(const String &str);
 
                constexpr FrameNumber() = default;
 
                constexpr FrameNumber(int64_t v) : _value(v < 0 ? UnknownValue : v) {}
 
                constexpr bool isValid() const { return _value >= 0; }
 
                constexpr bool isUnknown() const { return _value < 0; }
 
                constexpr int64_t value() const { return _value; }
 
                double toDouble() const {
                        return isValid() ? static_cast<double>(_value)
                                         : std::numeric_limits<double>::quiet_NaN();
                }
 
                static Result<FrameNumber> fromDouble(double v) {
                        if (std::isnan(v)) return makeResult(FrameNumber());
                        if (!std::isfinite(v) || v < 0.0) return makeResult(FrameNumber());
                        return makeResult(FrameNumber(static_cast<int64_t>(v)));
                }
 
                FrameNumber &operator++() {
                        if (isValid()) ++_value;
                        return *this;
                }
 
                FrameNumber operator++(int) {
                        FrameNumber old = *this;
                        ++(*this);
                        return old;
                }
 
                FrameNumber &operator--() {
                        if (isValid()) {
                                if (_value == 0)
                                        _value = UnknownValue;
                                else
                                        --_value;
                        }
                        return *this;
                }
 
                FrameNumber operator--(int) {
                        FrameNumber old = *this;
                        --(*this);
                        return old;
                }
 
                FrameNumber &operator+=(int64_t n) {
                        if (isValid()) {
                                int64_t nv = _value + n;
                                _value = nv < 0 ? UnknownValue : nv;
                        }
                        return *this;
                }
 
                FrameNumber &operator-=(int64_t n) {
                        if (isValid()) {
                                int64_t nv = _value - n;
                                _value = nv < 0 ? UnknownValue : nv;
                        }
                        return *this;
                }
 
                FrameNumber &operator+=(const FrameCount &c);
 
                FrameNumber &operator-=(const FrameCount &c);
 
                constexpr bool operator==(const FrameNumber &other) const { return _value == other._value; }
 
                constexpr bool operator!=(const FrameNumber &other) const { return _value != other._value; }
 
                constexpr bool operator<(const FrameNumber &other) const { return _value < other._value; }
                constexpr bool operator<=(const FrameNumber &other) const { return _value <= other._value; }
                constexpr bool operator>(const FrameNumber &other) const { return _value > other._value; }
                constexpr bool operator>=(const FrameNumber &other) const { return _value >= other._value; }
 
                String toString() const;
 
                operator String() const { return toString(); }
 
        private:
                int64_t _value = UnknownValue;
};
 
inline FrameNumber operator+(FrameNumber a, int64_t n) {
        a += n;
        return a;
}
inline FrameNumber operator-(FrameNumber a, int64_t n) {
        a -= n;
        return a;
}
inline FrameNumber operator+(int64_t n, FrameNumber a) {
        a += n;
        return a;
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::FrameNumber);
 
template <> struct std::hash<promeki::FrameNumber> {
                size_t operator()(const promeki::FrameNumber &v) const noexcept {
                        return std::hash<int64_t>()(v.value());
                }
};
 
#endif // PROMEKI_ENABLE_CORE