umid.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <cstring>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/array.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class UMID {
        public:
                PROMEKI_DATATYPE(UMID, DataTypeUMID, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<UMID> readFromStream(DataStream &s);
 
                enum Length {
                        Invalid = 0,  
                        Basic = 32,   
                        Extended = 64 
                };
 
                static constexpr size_t BasicSize = 32;
 
                static constexpr size_t ExtendedSize = 64;
 
                static constexpr size_t UniversalLabelSize = 12;
 
                using DataFormat = Array<uint8_t, ExtendedSize>;
 
                static UMID generate(Length len = Extended);
 
                static Result<UMID> fromString(const String &str);
 
                static UMID fromBytes(const uint8_t *bytes, size_t byteLen);
 
                UMID() : d{}, _length(Invalid) {}
 
                UMID(const UMID &other) : d(other.d), _length(other._length) {}
 
                UMID &operator=(const UMID &other) {
                        d = other.d;
                        _length = other._length;
                        return *this;
                }
 
                bool isValid() const { return _length != Invalid; }
 
                Length length() const { return _length; }
 
                size_t byteSize() const { return static_cast<size_t>(_length); }
 
                bool isExtended() const { return _length == Extended; }
 
                String toString() const;
 
                operator String() const { return toString(); }
 
                const DataFormat &data() const { return d; }
 
                const uint8_t *raw() const { return d.data(); }
 
                bool operator==(const UMID &other) const {
                        if (_length != other._length) return false;
                        return std::memcmp(d.data(), other.d.data(), static_cast<size_t>(_length)) == 0;
                }
 
                bool operator!=(const UMID &other) const { return !(*this == other); }
 
                bool operator<(const UMID &other) const {
                        if (_length != other._length) return _length < other._length;
                        return std::memcmp(d.data(), other.d.data(), static_cast<size_t>(_length)) < 0;
                }
 
                bool operator>(const UMID &other) const { return other < *this; }
 
                bool operator<=(const UMID &other) const { return !(other < *this); }
 
                bool operator>=(const UMID &other) const { return !(*this < other); }
 
        private:
                DataFormat d;
                Length     _length;
};
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::UMID);
 
#endif // PROMEKI_ENABLE_CORE