NIFStream: rename input stream and file methods

To conform to modern style conventions

components/nif/nifstream.cpp

@@ -7,7 +7,7 @@ namespace Nif
     osg::Quat NIFStream::getQuaternion()
     {
         float f[4];
-        readBufferOfType<4, float>(inp, f);
+        readBufferOfType<4, float>(mStream, f);
         osg::Quat quat;
         quat.w() = f[0];
         quat.x() = f[1];
@@ -34,20 +34,20 @@ namespace Nif
     /// Read in a string, either from the string table using the index or from the stream using the specified length
     std::string NIFStream::getString()
     {
-        return getVersion() < generateVersion(20, 1, 0, 1) ? getSizedString() : file.getString(getUInt());
+        return getVersion() < generateVersion(20, 1, 0, 1) ? getSizedString() : mReader.getString(getUInt());
     }
 
     // Convenience utility functions: get the versions of the currently read file
     unsigned int NIFStream::getVersion() const
     {
-        return file.getVersion();
+        return mReader.getVersion();
     }
     unsigned int NIFStream::getUserVersion() const
     {
-        return file.getBethVersion();
+        return mReader.getBethVersion();
     }
     unsigned int NIFStream::getBethVersion() const
     {
-        return file.getBethVersion();
+        return mReader.getBethVersion();
     }
 }

components/nif/nifstream.hpp

@@ -65,72 +65,70 @@ namespace Nif
 
     class NIFStream
     {
-        const Reader& file;
+        const Reader& mReader;
-
+        Files::IStreamPtr mStream;
-        /// Input stream
-        Files::IStreamPtr inp;
 
     public:
-        explicit NIFStream(const Reader& file, Files::IStreamPtr&& inp)
+        explicit NIFStream(const Reader& reader, Files::IStreamPtr&& stream)
-            : file(file)
+            : mReader(reader)
-            , inp(std::move(inp))
+            , mStream(std::move(stream))
         {
         }
 
-        const Reader& getFile() const { return file; }
+        const Reader& getFile() const { return mReader; }
 
-        void skip(size_t size) { inp->ignore(size); }
+        void skip(size_t size) { mStream->ignore(size); }
 
         template <class T>
         void read(T& data)
         {
-            data = readType<T>(inp);
+            data = readType<T>(mStream);
         }
 
-        void read(osg::Vec3f& data) { readBufferOfType<3, float>(inp, data._v); }
+        void read(osg::Vec3f& data) { readBufferOfType<3, float>(mStream, data._v); }
-        void read(osg::Vec4f& data) { readBufferOfType<4, float>(inp, data._v); }
+        void read(osg::Vec4f& data) { readBufferOfType<4, float>(mStream, data._v); }
 
         template <class T>
         T get()
         {
-            return readType<T>(inp);
+            return readType<T>(mStream);
         }
 
         template <class T>
         void readVector(std::vector<T>& vec, size_t size)
         {
             vec.resize(size);
-            readDynamicBufferOfType<T>(inp, vec.data(), size);
+            readDynamicBufferOfType<T>(mStream, vec.data(), size);
         }
 
         template <class T, size_t size>
         void readArray(std::array<T, size>& arr)
         {
-            readDynamicBufferOfType<T>(inp, arr.data(), size);
+            readDynamicBufferOfType<T>(mStream, arr.data(), size);
         }
 
         // DEPRECATED: Use read() or get() whenever relevant
-        char getChar() { return readType<char>(inp); }
+        char getChar() { return readType<char>(mStream); }
 
         // DEPRECATED: Use read() or get() whenever relevant
-        short getShort() { return readType<short>(inp); }
+        short getShort() { return readType<short>(mStream); }
 
         // DEPRECATED: Use read() or get() whenever relevant
-        unsigned short getUShort() { return readType<unsigned short>(inp); }
+        unsigned short getUShort() { return readType<unsigned short>(mStream); }
 
         // DEPRECATED: Use read() or get() whenever relevant
-        int getInt() { return readType<int>(inp); }
+        int getInt() { return readType<int>(mStream); }
 
         // DEPRECATED: Use read() or get() whenever relevant
-        unsigned int getUInt() { return readType<unsigned int>(inp); }
+        unsigned int getUInt() { return readType<unsigned int>(mStream); }
 
         // DEPRECATED: Use read() or get() whenever relevant
-        float getFloat() { return readType<float>(inp); }
+        float getFloat() { return readType<float>(mStream); }
 
         osg::Vec2f getVector2()
         {
             osg::Vec2f vec;
-            readBufferOfType<2, float>(inp, vec._v);
+            readBufferOfType<2, float>(mStream, vec._v);
             return vec;
         }
 
@@ -138,21 +136,21 @@ namespace Nif
         osg::Vec3f getVector3()
         {
             osg::Vec3f vec;
-            readBufferOfType<3, float>(inp, vec._v);
+            readBufferOfType<3, float>(mStream, vec._v);
             return vec;
         }
 
         osg::Vec4f getVector4()
         {
             osg::Vec4f vec;
-            readBufferOfType<4, float>(inp, vec._v);
+            readBufferOfType<4, float>(mStream, vec._v);
             return vec;
         }
 
         Matrix3 getMatrix3()
         {
             Matrix3 mat;
-            readBufferOfType<9, float>(inp, (float*)&mat.mValues);
+            readBufferOfType<9, float>(mStream, (float*)&mat.mValues);
             return mat;
         }
 
@@ -178,8 +176,8 @@ namespace Nif
         std::string getSizedString(size_t length)
         {
             std::string str(length, '\0');
-            inp->read(str.data(), length);
+            mStream->read(str.data(), length);
-            if (inp->bad())
+            if (mStream->bad())
                 throw std::runtime_error("Failed to read sized string of " + std::to_string(length) + " chars");
             size_t end = str.find('\0');
             if (end != std::string::npos)
@@ -189,14 +187,14 @@ namespace Nif
         /// Read in a string of the length specified in the file
         std::string getSizedString()
         {
-            size_t size = readType<uint32_t>(inp);
+            size_t size = readType<uint32_t>(mStream);
             return getSizedString(size);
         }
 
         /// Specific to Bethesda headers, uses a byte for length
         std::string getExportString()
         {
-            size_t size = static_cast<size_t>(readType<uint8_t>(inp));
+            size_t size = static_cast<size_t>(readType<uint8_t>(mStream));
             return getSizedString(size);
         }
 
@@ -204,8 +202,8 @@ namespace Nif
         std::string getVersionString()
         {
             std::string result;
-            std::getline(*inp, result);
+            std::getline(*mStream, result);
-            if (inp->bad())
+            if (mStream->bad())
                 throw std::runtime_error("Failed to read version string");
             return result;
         }
@@ -213,10 +211,10 @@ namespace Nif
         /// Read a sequence of null-terminated strings
         std::string getStringPalette()
         {
-            size_t size = readType<uint32_t>(inp);
+            size_t size = readType<uint32_t>(mStream);
             std::string str(size, '\0');
-            inp->read(str.data(), size);
+            mStream->read(str.data(), size);
-            if (inp->bad())
+            if (mStream->bad())
                 throw std::runtime_error("Failed to read string palette of " + std::to_string(size) + " chars");
             return str;
         }
@@ -225,63 +223,63 @@ namespace Nif
         void getChars(std::vector<char>& vec, size_t size)
         {
             vec.resize(size);
-            readDynamicBufferOfType<char>(inp, vec.data(), size);
+            readDynamicBufferOfType<char>(mStream, vec.data(), size);
         }
 
         // DEPRECATED: Use readVector()
         void getUChars(std::vector<unsigned char>& vec, size_t size)
         {
             vec.resize(size);
-            readDynamicBufferOfType<unsigned char>(inp, vec.data(), size);
+            readDynamicBufferOfType<unsigned char>(mStream, vec.data(), size);
         }
 
         // DEPRECATED: Use readVector()
         void getUShorts(std::vector<unsigned short>& vec, size_t size)
         {
             vec.resize(size);
-            readDynamicBufferOfType<unsigned short>(inp, vec.data(), size);
+            readDynamicBufferOfType<unsigned short>(mStream, vec.data(), size);
         }
 
         // DEPRECATED: Use readVector()
         void getFloats(std::vector<float>& vec, size_t size)
         {
             vec.resize(size);
-            readDynamicBufferOfType<float>(inp, vec.data(), size);
+            readDynamicBufferOfType<float>(mStream, vec.data(), size);
         }
 
         // DEPRECATED: Use readVector()
         void getInts(std::vector<int>& vec, size_t size)
         {
             vec.resize(size);
-            readDynamicBufferOfType<int>(inp, vec.data(), size);
+            readDynamicBufferOfType<int>(mStream, vec.data(), size);
         }
 
         // DEPRECATED: Use readVector()
         void getUInts(std::vector<unsigned int>& vec, size_t size)
         {
             vec.resize(size);
-            readDynamicBufferOfType<unsigned int>(inp, vec.data(), size);
+            readDynamicBufferOfType<unsigned int>(mStream, vec.data(), size);
         }
 
         void getVector2s(std::vector<osg::Vec2f>& vec, size_t size)
         {
             vec.resize(size);
             /* The packed storage of each Vec2f is 2 floats exactly */
-            readDynamicBufferOfType<float>(inp, (float*)vec.data(), size * 2);
+            readDynamicBufferOfType<float>(mStream, (float*)vec.data(), size * 2);
         }
 
         void getVector3s(std::vector<osg::Vec3f>& vec, size_t size)
         {
             vec.resize(size);
             /* The packed storage of each Vec3f is 3 floats exactly */
-            readDynamicBufferOfType<float>(inp, (float*)vec.data(), size * 3);
+            readDynamicBufferOfType<float>(mStream, (float*)vec.data(), size * 3);
         }
 
         void getVector4s(std::vector<osg::Vec4f>& vec, size_t size)
         {
             vec.resize(size);
             /* The packed storage of each Vec4f is 4 floats exactly */
-            readDynamicBufferOfType<float>(inp, (float*)vec.data(), size * 4);
+            readDynamicBufferOfType<float>(mStream, (float*)vec.data(), size * 4);
         }
 
         void getQuaternions(std::vector<osg::Quat>& quat, size_t size)