Take SeekPos into account for read/write operations

Author: nextgeniuspro

include/vfspp/MemoryFile.hpp

@@ -273,11 +273,11 @@ class MemoryFile final : public IFile
         if (origin == Origin::Begin) {
             m_SeekPos = offset;
         } else if (origin == Origin::End) {
-            m_SeekPos = Size() - offset;
+            m_SeekPos = (offset <= SizeST()) ? SizeST() - offset : 0;
         } else if (origin == Origin::Set) {
             m_SeekPos += offset;
         }
-        m_SeekPos = std::min(m_SeekPos, Size() - 1);
+        m_SeekPos = std::min(m_SeekPos, SizeST());
 
         return TellST();
     }
@@ -301,7 +301,8 @@ class MemoryFile final : public IFile
         uint64_t leftSize = SizeST() - TellST();
         uint64_t maxSize = std::min(size, leftSize);
         if (maxSize > 0) {
-            memcpy(buffer, m_Data.data(), static_cast<size_t>(maxSize));
+            memcpy(buffer, m_Data.data() + m_SeekPos, static_cast<size_t>(maxSize));
+            m_SeekPos += maxSize;
             return maxSize;
         }
 
@@ -321,9 +322,14 @@ class MemoryFile final : public IFile
 
         uint64_t leftSize = SizeST() - TellST();
         if (size > leftSize) {
-            m_Data.resize((size_t)(m_Data.size() + (size - leftSize)));
+            uint64_t newSize = TellST() + size;
+            if (newSize > static_cast<uint64_t>(std::numeric_limits<size_t>::max())) {
+                return 0;
+            }
+            m_Data.resize(static_cast<size_t>(newSize));
         }
         memcpy(m_Data.data() + TellST(), buffer, static_cast<size_t>(size));
+        m_SeekPos += size; 
 
         return size;
     }

include/vfspp/NativeFile.hpp

@@ -290,8 +290,12 @@ class NativeFile final : public IFile
             dir = std::ios_base::cur;
         }
 
+        // Seek both read and write pointers to keep them synchronized
         m_Stream.seekg(offset, dir);
+        m_Stream.seekp(offset, dir);
+        
         if (m_Stream.fail()) {
+            m_Stream.clear();
             return 0;
         }
 
@@ -300,7 +304,19 @@ class NativeFile final : public IFile
 
     inline uint64_t TellST()
     {
-        return static_cast<uint64_t>(m_Stream.tellg());
+        if (!IsOpenedST()) {
+            return 0;
+        }
+        
+        if ((m_Mode & FileMode::Read) == FileMode::Read) {
+            auto pos = m_Stream.tellg();
+            return (pos != std::streampos(-1)) ? static_cast<uint64_t>(pos) : 0;
+        } else if ((m_Mode & FileMode::Write) == FileMode::Write) {
+            auto pos = m_Stream.tellp();
+            return (pos != std::streampos(-1)) ? static_cast<uint64_t>(pos) : 0;
+        }
+        
+        return 0;
     }
 
     inline uint64_t ReadST(uint8_t* buffer, uint64_t size)
@@ -313,13 +329,17 @@ class NativeFile final : public IFile
         if ((m_Mode & FileMode::Read) != FileMode::Read) {
             return 0;
         }
-        
-        
+                
         uint64_t leftSize = SizeST() - TellST();
         uint64_t maxSize = std::min(size, leftSize);
         if (maxSize > 0) {
             m_Stream.read(reinterpret_cast<char*>(buffer), maxSize);
-            return maxSize;
+            if (m_Stream.good() || m_Stream.eof()) {
+                return static_cast<uint64_t>(m_Stream.gcount());
+            }
+            // Clear error flags for failed read
+            m_Stream.clear();
+            return 0;
         }
 
         return 0;
@@ -337,7 +357,10 @@ class NativeFile final : public IFile
         }
 
         m_Stream.write(reinterpret_cast<const char*>(buffer), size);
-        return static_cast<uint64_t>(m_Stream.gcount());
+        if (m_Stream.good()) {
+            return size;
+        }
+        return 0;
     }
 
     inline uint64_t ReadST(std::vector<uint8_t>& buffer, uint64_t size)

include/vfspp/ZipFile.hpp

@@ -253,6 +253,10 @@ class ZipFile final : public IFile
 
         m_Data.resize(m_Size);
         m_IsOpened = mz_zip_reader_extract_to_mem_no_alloc(zipArchive.get(), m_EntryID, m_Data.data(), static_cast<size_t>(m_Size), 0, 0, 0);
+        
+        if (!m_IsOpened) {
+            m_Data.clear();
+        }
     }
 
     inline void CloseST()
@@ -277,11 +281,11 @@ class ZipFile final : public IFile
         if (origin == IFile::Origin::Begin) {
             m_SeekPos = offset;
         } else if (origin == IFile::Origin::End) {
-            m_SeekPos = SizeST() - offset;
+            m_SeekPos = (offset <= SizeST()) ? SizeST() - offset : 0;
         } else if (origin == IFile::Origin::Set) {
             m_SeekPos += offset;
         }
-        m_SeekPos = std::min(m_SeekPos, SizeST() - 1);
+        m_SeekPos = std::min(m_SeekPos, SizeST());
 
         return TellST();
     }
@@ -300,7 +304,8 @@ class ZipFile final : public IFile
         uint64_t leftSize = SizeST() - TellST();
         uint64_t maxSize = std::min(size, leftSize);
         if (maxSize > 0) {
-            memcpy(buffer, m_Data.data(), static_cast<size_t>(maxSize));
+            memcpy(buffer, m_Data.data() + m_SeekPos, static_cast<size_t>(maxSize));
+            m_SeekPos += maxSize;
             return maxSize;
         }