Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-09 22:17:57 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

aded encoded length to property flags

Browse source
This commit is contained in:
ZappoMan 2014-06-09 10:41:11 -07:00
parent 6943b3f763
commit 8834da60b9
1 changed files with 24 additions and 12 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
libraries/shared/src/PropertyFlags.h
View file

@ -12,6 +12,9 @@
// TODO: // TODO:
// * consider adding iterator to enumerate the properties that have been set? // * consider adding iterator to enumerate the properties that have been set?
// * operator QSet<Enum> - this would be easiest way to handle enumeration // * operator QSet<Enum> - this would be easiest way to handle enumeration
// * make encode(), QByteArray<< operator, and QByteArray operator const by moving calculation of encoded length to
// setFlag() and other calls
// * should the QByteArray<< operator and QByteArray>> operator return the shifted versions of the byte arrays?
#ifndef hifi_PropertyFlags_h #ifndef hifi_PropertyFlags_h
#define hifi_PropertyFlags_h #define hifi_PropertyFlags_h
@ -28,27 +31,29 @@ template<typename Enum>class PropertyFlags {
public: public:
typedef Enum enum_type; typedef Enum enum_type;
inline PropertyFlags() : inline PropertyFlags() :
_maxFlag(INT_MIN), _minFlag(INT_MAX), _trailingFlipped(false) { }; _maxFlag(INT_MIN), _minFlag(INT_MAX), _trailingFlipped(false), _encodedLength(0) { };
inline PropertyFlags(const PropertyFlags& other) : inline PropertyFlags(const PropertyFlags& other) :
_flags(other._flags), _maxFlag(other._maxFlag), _minFlag(other._minFlag), _flags(other._flags), _maxFlag(other._maxFlag), _minFlag(other._minFlag),
_trailingFlipped(other._trailingFlipped) {} _trailingFlipped(other._trailingFlipped), _encodedLength(0) {}
inline PropertyFlags(Enum flag) :
_maxFlag(INT_MIN), _minFlag(INT_MAX), _trailingFlipped(false) { setHasProperty(flag); }
inline PropertyFlags(const QByteArray& fromEncoded) :
_maxFlag(INT_MIN), _minFlag(INT_MAX), _trailingFlipped(false) { decode(fromEncoded); }
void clear() { _flags.clear(); _maxFlag = INT_MIN; _minFlag = INT_MAX; _trailingFlipped = false; } inline PropertyFlags(Enum flag) :
_maxFlag(INT_MIN), _minFlag(INT_MAX), _trailingFlipped(false), _encodedLength(0) { setHasProperty(flag); }
inline PropertyFlags(const QByteArray& fromEncoded) :
_maxFlag(INT_MIN), _minFlag(INT_MAX), _trailingFlipped(false), _encodedLength(0) { decode(fromEncoded); }
void clear() { _flags.clear(); _maxFlag = INT_MIN; _minFlag = INT_MAX; _trailingFlipped = false; _encodedLength = 0; }
Enum firstFlag() const { return (Enum)_minFlag; } Enum firstFlag() const { return (Enum)_minFlag; }
Enum lastFlag() const { return (Enum)_maxFlag; } Enum lastFlag() const { return (Enum)_maxFlag; }
void setHasProperty(Enum flag, bool value = true); void setHasProperty(Enum flag, bool value = true);
bool getHasProperty(Enum flag); bool getHasProperty(Enum flag);
QByteArray encode() const; QByteArray encode();
void decode(const QByteArray& fromEncoded); void decode(const QByteArray& fromEncoded);
operator QByteArray() const { return encode(); }; operator QByteArray() { return encode(); };
bool operator==(const PropertyFlags& other) const { return _flags == other._flags; } bool operator==(const PropertyFlags& other) const { return _flags == other._flags; }
bool operator!=(const PropertyFlags& other) const { return _flags != other._flags; } bool operator!=(const PropertyFlags& other) const { return _flags != other._flags; }
@ -97,6 +102,8 @@ public:
void debugDumpBits(); void debugDumpBits();
int getEncodedLength() const { return _encodedLength; }
private: private:
void shinkIfNeeded(); void shinkIfNeeded();
@ -105,6 +112,7 @@ private:
int _maxFlag; int _maxFlag;
int _minFlag; int _minFlag;
bool _trailingFlipped; /// are the trailing properties flipping in their state (e.g. assumed true, instead of false) bool _trailingFlipped; /// are the trailing properties flipping in their state (e.g. assumed true, instead of false)
int _encodedLength;
}; };
template<typename Enum> PropertyFlags<Enum>& operator<<(PropertyFlags<Enum>& out, const PropertyFlags<Enum>& other) { template<typename Enum> PropertyFlags<Enum>& operator<<(PropertyFlags<Enum>& out, const PropertyFlags<Enum>& other) {
@ -147,7 +155,7 @@ template<typename Enum> inline bool PropertyFlags<Enum>::getHasProperty(Enum fla
const int BITS_PER_BYTE = 8; const int BITS_PER_BYTE = 8;
template<typename Enum> inline QByteArray PropertyFlags<Enum>::encode() const { template<typename Enum> inline QByteArray PropertyFlags<Enum>::encode() {
QByteArray output; QByteArray output;
if (_maxFlag < _minFlag) { if (_maxFlag < _minFlag) {
@ -180,6 +188,8 @@ template<typename Enum> inline QByteArray PropertyFlags<Enum>::encode() const {
char thisBit = ( bitValue << shiftBy); char thisBit = ( bitValue << shiftBy);
output[i / BITS_PER_BYTE] = (original | thisBit); output[i / BITS_PER_BYTE] = (original | thisBit);
} }
_encodedLength = lengthInBytes;
return output; return output;
} }
@ -213,6 +223,8 @@ template<typename Enum> inline void PropertyFlags<Enum>::decode(const QByteArray
} }
} }
encodedByteCount++; // always at least one byte encodedByteCount++; // always at least one byte
_encodedLength = encodedByteCount;
int expectedBitCount = encodedByteCount * BITS_PER_BYTE; int expectedBitCount = encodedByteCount * BITS_PER_BYTE;
// Now, keep reading... // Now, keep reading...
@ -419,7 +431,7 @@ template<typename Enum> inline void PropertyFlags<Enum>::shinkIfNeeded() {
} }
} }
template<typename Enum> inline QByteArray& operator<<(QByteArray& out, const PropertyFlags<Enum>& value) { template<typename Enum> inline QByteArray& operator<<(QByteArray& out, PropertyFlags<Enum>& value) {
return out = value; return out = value;
} }