Boost serialization выбрасывает «ошибку потока ввода» после определенного размера файла

Question

Я использую Boost :: serialization для чтения/записи в файл, содержащий 3d модели.

После определенного размера файла (около 8-12kb +) сериализация генерирует исключение «Ошибка входного потока» каждый раз, когда я пытаюсь прочитать файл. Он работает отлично каждый раз до этого - например, я могу читать/писать 1kb модель 12 раз успешно, а затем в 13-й раз и далее он будет бросать исключение!

Вот код для сериализации/десериализации:

JonsPackagePtr ReadJonsPkg(const std::string& jonsPkgName) 
    { 
     std::ifstream jonsPkgStream(jonsPkgName.c_str(), std::fstream::binary || std::fstream::in); 
     JonsPackagePtr pkg(new JonsPackage()); // "JonsPackagePtr" is a boost_shared_ptr typedef 

     if (jonsPkgStream && jonsPkgStream.good() && jonsPkgStream.is_open()) 
     { 
      boost::archive::binary_iarchive iar(jonsPkgStream); 

      iar >> (*pkg.get()); 
     } 

     return pkg; 
    } 

    bool WriteJonsPkg(const std::string& jonsPkgName, const JonsPackagePtr pkg) 
    { 
     std::ofstream outStream(jonsPkgName.c_str(), std::fstream::out | std::fstream::binary); 
     bool ret = false; 

     if (outStream.is_open()) 
     { 
      boost::archive::binary_oarchive oar(outStream); 
      oar << (*pkg.get()); 

      ret = true; 
     } 

     return ret; 
    } 

Вот содержимое, которое я в архив:

/* PackageHeader definition */ 
    struct PackageHeader 
    { 
     std::string mSignature; 
     uint8_t mMajorVersion; 
     uint8_t mMinorVersion; 


     PackageHeader(); 
    }; 

    /* PackageMesh definition */ 
    struct PackageMesh 
    { 
     std::vector<float> mVertexData; 
     std::vector<uint32_t> mIndiceData; 


     PackageMesh(); 
    }; 

    /* PackageModel definition */ 
    struct PackageModel 
    { 
     std::string mName; 
     std::vector<PackageModel> mChildren; 
     std::vector<PackageMesh> mMeshes; 
     Mat4 mTransform; 


     PackageModel(); 
    }; 

    /* JonsPackage definition */ 
    struct JonsPackage 
    { 
     PackageHeader mHeader; 
     std::vector<PackageModel> mModels; 


     JonsPackage(); 
    }; 


    typedef boost::shared_ptr<JonsPackage> JonsPackagePtr; 
    JonsPackagePtr ReadJonsPkg(const std::string& jonsPkgName); 
    bool WriteJonsPkg(const std::string& jonsPkgName, const JonsPackagePtr pkg); 


    /* PackageHeader inlines */ 
    inline PackageHeader::PackageHeader() : mSignature("jons"), mMajorVersion(LatestMajorVersion), mMinorVersion(LatestMinorVersion) 
    { 
    } 

    /* PackageModel inlines */ 
    inline PackageModel::PackageModel() : mName(""), mTransform(1.0f) 
    { 
    } 

    /* PackageMesh inlines */ 
    inline PackageMesh::PackageMesh() 
    { 
    } 

    /* JonsPackage inlines */ 
    inline JonsPackage::JonsPackage() 
    { 
    } 

Наконец вот мое неинтрузивное определение сериализации:

namespace boost 
{ 
    namespace serialization 
    { 
     template<class Archive> 
     void serialize(Archive & ar, JonsEngine::PackageHeader& header, const unsigned int version) 
     { 
      ar & header.mMajorVersion; 
      ar & header.mMinorVersion; 
      ar & header.mSignature; 
     } 

     template<class Archive> 
     void serialize(Archive & ar, JonsEngine::PackageModel& model, const unsigned int version) 
     { 
      ar & model.mName; 
      ar & model.mChildren; 
      ar & model.mMeshes; 
      ar & model.mTransform; 
     } 

     template<class Archive> 
     void serialize(Archive & ar, JonsEngine::PackageMesh& mesh, const unsigned int version) 
     { 
      ar & mesh.mVertexData; 
      ar & mesh.mIndiceData; 
     } 

     template<class Archive> 
     void serialize(Archive & ar, JonsEngine::JonsPackage& pkg, const unsigned int version) 
     { 
      ar & pkg.mHeader; 
      ar & pkg.mModels; 
     } 

     template<class Archive> 
     void serialize(Archive & ar, glm::detail::tmat4x4<glm::mediump_float> transform, const unsigned int version) 
     { 
      ar & transform[0]; 
      ar & transform[1]; 
      ar & transform[2]; 
      ar & transform[3]; 
     } 

     template<class Archive> 
     void serialize(Archive & ar, glm::detail::tvec4<glm::mediump_float> vec, const unsigned int version) 
     { 
      ar & vec.x; 
      ar & vec.y; 
      ar & vec.z; 
      ar & vec.w; 
     } 
    } // namespace serialization 
} // namespace boost 

Как Я упоминал выше, только после определенного размера файла (8-12kb +) что он начинает бросать исключения, когда я пытаюсь его прочитать. Почему это так и что может вызвать это? Он идет хорошо до до этого момента ...

Благодаря

Answer 1

в ReadJonsPkg вы должны использовать побитовое или: std::fstream::binary | std::fstream::in