Fixes for Windows.

libraries/metavoxels/src/Bitstream.cpp

@@ -79,10 +79,6 @@ IDStreamer& IDStreamer::operator>>(int& value) {
     return *this;
 }
 
-static QByteArray getEnumName(const QMetaEnum& metaEnum) {
-    return QByteArray(metaEnum.scope()) + "::" + metaEnum.name();
-}
-
 int Bitstream::registerMetaObject(const char* className, const QMetaObject* metaObject) {
     getMetaObjects().insert(className, metaObject);
     
@@ -90,16 +86,6 @@ int Bitstream::registerMetaObject(const char* className, const QMetaObject* meta
     for (const QMetaObject* superClass = metaObject; superClass; superClass = superClass->superClass()) {
         getMetaObjectSubClasses().insert(superClass, metaObject);
     }
-    
-    // register the streamers for all enumerators
-    for (int i = 0; i < metaObject->enumeratorCount(); i++) {
-        QMetaEnum metaEnum = metaObject->enumerator(i);
-        const TypeStreamer*& streamer = getEnumStreamers()[QPair<QByteArray, QByteArray>(metaEnum.scope(), metaEnum.name())];
-        if (!streamer) {
-            getEnumStreamersByName().insert(getEnumName(metaEnum), streamer = new EnumTypeStreamer(metaEnum));
-        }
-    }
-    
     return 0;
 }
 
@@ -1030,12 +1016,34 @@ QHash<int, const TypeStreamer*>& Bitstream::getTypeStreamers() {
 }
 
 QHash<QPair<QByteArray, QByteArray>, const TypeStreamer*>& Bitstream::getEnumStreamers() {
-    static QHash<QPair<QByteArray, QByteArray>, const TypeStreamer*> enumStreamers;
+    static QHash<QPair<QByteArray, QByteArray>, const TypeStreamer*> enumStreamers = createEnumStreamers();
+    return enumStreamers;
+}
+
+QHash<QPair<QByteArray, QByteArray>, const TypeStreamer*> Bitstream::createEnumStreamers() {
+    QHash<QPair<QByteArray, QByteArray>, const TypeStreamer*> enumStreamers;
+    foreach (const QMetaObject* metaObject, getMetaObjects()) {
+        for (int i = 0; i < metaObject->enumeratorCount(); i++) {
+            QMetaEnum metaEnum = metaObject->enumerator(i);
+            const TypeStreamer*& streamer = enumStreamers[QPair<QByteArray, QByteArray>(metaEnum.scope(), metaEnum.name())];
+            if (!streamer) {
+                streamer = new EnumTypeStreamer(metaEnum);
+            }
+        }
+    }
     return enumStreamers;
 }
 
 QHash<QByteArray, const TypeStreamer*>& Bitstream::getEnumStreamersByName() {
-    static QHash<QByteArray, const TypeStreamer*> enumStreamersByName;
+    static QHash<QByteArray, const TypeStreamer*> enumStreamersByName = createEnumStreamersByName();
+    return enumStreamersByName;
+}
+
+QHash<QByteArray, const TypeStreamer*> Bitstream::createEnumStreamersByName() {
+    QHash<QByteArray, const TypeStreamer*> enumStreamersByName;
+    foreach (const TypeStreamer* streamer, getEnumStreamers()) {
+        enumStreamersByName.insert(streamer->getName(), streamer);
+    }
     return enumStreamersByName;
 }
 
@@ -1462,17 +1470,21 @@ QDebug& operator<<(QDebug& debug, const QMetaObject* metaObject) {
     return debug << (metaObject ? metaObject->className() : "null");
 }
 
-EnumTypeStreamer::EnumTypeStreamer(const QMetaEnum& metaEnum) :
+EnumTypeStreamer::EnumTypeStreamer(const QMetaObject* metaObject, const char* name) :
-    _metaEnum(metaEnum),
+    _metaObject(metaObject),
-    _name(getEnumName(metaEnum)) {
+    _enumName(name),
+    _name(QByteArray(metaObject->className()) + "::" + name),
+    _bits(-1) {
     
     setType(QMetaType::Int); 
+}
 
-    int highestValue = 0;
+EnumTypeStreamer::EnumTypeStreamer(const QMetaEnum& metaEnum) :
-    for (int j = 0; j < metaEnum.keyCount(); j++) {
+    _name(QByteArray(metaEnum.scope()) + "::" + metaEnum.name()),
-        highestValue = qMax(highestValue, metaEnum.value(j));
+    _metaEnum(metaEnum),
-    }
+    _bits(-1) {
-    _bits = getBitsForHighestValue(highestValue); 
+
+    setType(QMetaType::Int); 
 }
 
 const char* EnumTypeStreamer::getName() const {
@@ -1484,10 +1496,21 @@ TypeReader::Type EnumTypeStreamer::getReaderType() const {
 }
 
 int EnumTypeStreamer::getBits() const {
+    if (_bits == -1) {
+        int highestValue = 0;
+        QMetaEnum metaEnum = getMetaEnum();
+        for (int j = 0; j < metaEnum.keyCount(); j++) {
+            highestValue = qMax(highestValue, metaEnum.value(j));
+        }
+        const_cast<EnumTypeStreamer*>(this)->_bits = getBitsForHighestValue(highestValue);
+    }
     return _bits;
 }
 
 QMetaEnum EnumTypeStreamer::getMetaEnum() const {
+    if (!_metaEnum.isValid()) {
+        const_cast<EnumTypeStreamer*>(this)->_metaEnum = _metaObject->enumerator(_metaObject->indexOfEnumerator(_enumName));
+    }
     return _metaEnum;
 }
 
@@ -1497,12 +1520,12 @@ bool EnumTypeStreamer::equal(const QVariant& first, const QVariant& second) cons
 
 void EnumTypeStreamer::write(Bitstream& out, const QVariant& value) const {
     int intValue = value.toInt();
-    out.write(&intValue, _bits);
+    out.write(&intValue, getBits());
 }
 
 QVariant EnumTypeStreamer::read(Bitstream& in) const {
     int intValue = 0;
-    in.read(&intValue, _bits);
+    in.read(&intValue, getBits());
     return intValue;
 }
 
@@ -1512,7 +1535,7 @@ void EnumTypeStreamer::writeDelta(Bitstream& out, const QVariant& value, const Q
         out << false;
     } else {
         out << true;
-        out.write(&intValue, _bits);
+        out.write(&intValue, getBits());
     }
 }
 
@@ -1521,7 +1544,7 @@ void EnumTypeStreamer::readDelta(Bitstream& in, QVariant& value, const QVariant&
     in >> changed;
     if (changed) {
         int intValue = 0;
-        in.read(&intValue, _bits);
+        in.read(&intValue, getBits());
         value = intValue;
     } else {
         value = reference;
@@ -1530,17 +1553,17 @@ void EnumTypeStreamer::readDelta(Bitstream& in, QVariant& value, const QVariant&
 
 void EnumTypeStreamer::writeRawDelta(Bitstream& out, const QVariant& value, const QVariant& reference) const {
     int intValue = value.toInt();
-    out.write(&intValue, _bits);
+    out.write(&intValue, getBits());
 }
 
 void EnumTypeStreamer::readRawDelta(Bitstream& in, QVariant& value, const QVariant& reference) const {
     int intValue = 0;
-    in.read(&intValue, _bits);
+    in.read(&intValue, getBits());
     value = intValue;
 }
 
 void EnumTypeStreamer::setEnumValue(QVariant& object, int value, const QHash<int, int>& mappings) const {
-    if (_metaEnum.isFlag()) {
+    if (getMetaEnum().isFlag()) {
         int combined = 0;
         for (QHash<int, int>::const_iterator it = mappings.constBegin(); it != mappings.constEnd(); it++) {
             if (value & it.key()) {

libraries/metavoxels/src/Bitstream.h

@@ -427,7 +427,9 @@ private:
     static QMultiHash<const QMetaObject*, const QMetaObject*>& getMetaObjectSubClasses();
     static QHash<int, const TypeStreamer*>& getTypeStreamers();
     static QHash<QPair<QByteArray, QByteArray>, const TypeStreamer*>& getEnumStreamers();
+    static QHash<QPair<QByteArray, QByteArray>, const TypeStreamer*> createEnumStreamers();
     static QHash<QByteArray, const TypeStreamer*>& getEnumStreamersByName();
+    static QHash<QByteArray, const TypeStreamer*> createEnumStreamersByName();
     static QVector<PropertyReader> getPropertyReaders(const QMetaObject* metaObject);
 };
 
@@ -938,6 +940,7 @@ public:
 class EnumTypeStreamer : public TypeStreamer {
 public:
     
+    EnumTypeStreamer(const QMetaObject* metaObject, const char* name);
     EnumTypeStreamer(const QMetaEnum& metaEnum);
 
     virtual const char* getName() const;
@@ -955,8 +958,10 @@ public:
 
 private:
     
-    QMetaEnum _metaEnum;
+    const QMetaObject* _metaObject;
+    const char* _enumName;
     QByteArray _name;
+    QMetaEnum _metaEnum;
     int _bits;
 };
 
@@ -1084,14 +1089,15 @@ public:
     template<> inline void Bitstream::readRawDelta(S::N& value, const S::N& reference) { *this >> value; }
 
 #define IMPLEMENT_ENUM_METATYPE(S, N) \
-    static int S##N##Bits = registerEnumMetaType<S::N>(S::staticMetaObject.enumerator( \
+    static int S##N##MetaTypeId = registerEnumMetaType<S::N>(&S::staticMetaObject, #N); \
-        S::staticMetaObject.indexOfEnumerator(#N))); \
     Bitstream& operator<<(Bitstream& out, const S::N& obj) { \
-        return out.write(&obj, S##N##Bits); \
+        static int bits = Bitstream::getTypeStreamer(qMetaTypeId<S::N>())->getBits(); \
+        return out.write(&obj, bits); \
     } \
     Bitstream& operator>>(Bitstream& in, S::N& obj) { \
+        static int bits = Bitstream::getTypeStreamer(qMetaTypeId<S::N>())->getBits(); \
         obj = (S::N)0; \
-        return in.read(&obj, S##N##Bits); \
+        return in.read(&obj, bits); \
     }
     
 /// Registers a simple type and its streamer.
@@ -1103,12 +1109,11 @@ template<class T> int registerSimpleMetaType() {
 }
 
 /// Registers an enum type and its streamer.
-/// \return the number of bits required to stream the enum
+/// \return the metatype id
-template<class T> int registerEnumMetaType(const QMetaEnum& metaEnum) {
+template<class T> int registerEnumMetaType(const QMetaObject* metaObject, const char* name) {
     int type = qRegisterMetaType<T>();
-    EnumTypeStreamer* streamer = new EnumTypeStreamer(metaEnum);
+    Bitstream::registerTypeStreamer(type, new EnumTypeStreamer(metaObject, name));
-    Bitstream::registerTypeStreamer(type, streamer);
+    return type;
-    return streamer->getBits();
 }
 
 /// Registers a streamable type and its streamer.