//----------------------------------------------------------------------------// void DefaultResourceProvider::unloadRawDataContainer(RawDataContainer& data) { uint8* const ptr = data.getDataPtr(); delete[] ptr; data.setData(0); data.setSize(0); }
void XercesParser::doParse(XERCES_CPP_NAMESPACE::SAX2XMLReader* parser, const String& xmlFilename, const String& resourceGroup) { XERCES_CPP_NAMESPACE_USE; // use resource provider to load file data RawDataContainer rawXMLData; System::getSingleton().getResourceProvider()->loadRawDataContainer(xmlFilename, rawXMLData, resourceGroup); MemBufInputSource fileData( rawXMLData.getDataPtr(), static_cast<const unsigned int>(rawXMLData.getSize()), xmlFilename.c_str(), false); // perform parse try { parser->parse(fileData); } catch(...) { // use resource provider to release loaded XML source (if it supports this) System::getSingleton().getResourceProvider()->unloadRawDataContainer(rawXMLData); throw; } // use resource provider to release loaded XML source (if it supports this) System::getSingleton().getResourceProvider()->unloadRawDataContainer(rawXMLData); }
void GUIRenderer::initialize() { // BOOTSTRAP MANUAL guiRenderer = &Direct3D11Renderer::create(renderContext.device, renderContext.context); System::performVersionTest(CEGUI_VERSION_ABI, 208, CEGUI_FUNCTION_NAME); if (System::getSingletonPtr()) CEGUI_THROW(InvalidRequestException("CEGUI::System object is already initialised.")); System::create(*guiRenderer, &ceguiResourceProvider); // BOOTSTRAP MANUAL WindowManager& windowManager = WindowManager::getSingleton(); CEGUI::Window* rootWindow = windowManager.createWindow( "DefaultWindow", "root" ); System::getSingleton().getDefaultGUIContext().setRootWindow( rootWindow ); ImageManager::setImagesetDefaultResourceGroup("imagesets"); Font::setDefaultResourceGroup("fonts"); Scheme::setDefaultResourceGroup("schemes"); WidgetLookManager::setDefaultResourceGroup("looknfeels"); WindowManager::setDefaultResourceGroup("layouts"); DataContainer dllData = DLLResourceLoader::loadCEGUI_scheme(resourcesHmodule); RawDataContainer cScheme; cScheme.setData((CEGUI::uint8*) dllData.dataBlob); cScheme.setSize((size_t) dllData.dataSize); SchemeManager::getSingleton().createFromContainer(cScheme); cScheme.setData(0); cScheme.setSize(0); }
/************************************************************************* Load texture from file. Texture is made to be same size as image in file. *************************************************************************/ void DirectX9Texture::loadFromFile(const String& filename, const String& resourceGroup) { freeD3DTexture(); // load the file via the resource provider RawDataContainer texFile; System::getSingleton().getResourceProvider()->loadRawDataContainer(filename, texFile, resourceGroup); D3DXIMAGE_INFO texInfo; HRESULT hr = D3DXCreateTextureFromFileInMemoryEx(((DirectX9Renderer*)getRenderer())->getDevice(), texFile.getDataPtr(), static_cast<UINT>(texFile.getSize()), D3DX_DEFAULT_NONPOW2, D3DX_DEFAULT_NONPOW2, 1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, &texInfo, NULL, &d_d3dtexture); System::getSingleton().getResourceProvider()->unloadRawDataContainer(texFile); if (SUCCEEDED(hr)) { d_width = (ushort)texInfo.Width; d_height = (ushort)texInfo.Height; d_filename = filename; d_resourceGroup = resourceGroup; d_isMemoryTexture = true; d_isRenderTarget = false; } else { throw RendererException((utf8*)"Failed to create Texture object from file '" + filename ); } }
//----------------------------------------------------------------------------// void LuaScriptModule::executeScriptFile_impl(const String& filename, const String& resourceGroup, const int err_idx, const int top) { // load file RawDataContainer raw; System::getSingleton().getResourceProvider()->loadRawDataContainer(filename, raw, resourceGroup.empty() ? d_defaultResourceGroup : resourceGroup); // load code into lua int loaderr = luaL_loadbuffer(d_state, reinterpret_cast<char*>(raw.getDataPtr()), raw.getSize(), filename.c_str()); System::getSingleton().getResourceProvider()->unloadRawDataContainer( raw ); if (loaderr) { String errMsg = lua_tostring(d_state,-1); lua_settop(d_state,top); CEGUI_THROW(ScriptException("Unable to execute Lua script file: '" + filename + "'\n\n" + errMsg + "\n")); } // call it if (lua_pcall(d_state, 0, 0, err_idx)) { String errMsg = lua_tostring(d_state,-1); lua_settop(d_state,top); CEGUI_THROW(ScriptException("Unable to execute Lua script file: '" + filename + "'\n\n" + errMsg + "\n")); } lua_settop(d_state,top); // just in case :P }
//----------------------------------------------------------------------------// void OgreResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { String orpGroup; if (resourceGroup.empty()) orpGroup = d_defaultResourceGroup.empty() ? Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str() : d_defaultResourceGroup; else orpGroup = resourceGroup; Ogre::DataStreamPtr input = Ogre::ResourceGroupManager::getSingleton(). openResource(filename.c_str(), orpGroup.c_str()); if (input.isNull()) CEGUI_THROW(InvalidRequestException( "Unable to open resource file '" + filename + "' in resource group '" + orpGroup + "'.")); Ogre::String buf = input->getAsString(); const size_t memBuffSize = buf.length(); unsigned char* mem = new unsigned char[memBuffSize]; memcpy(mem, buf.c_str(), memBuffSize); output.setData(mem); output.setSize(memBuffSize); }
void ExpatParser::parseXML(XMLHandler& handler, const RawDataContainer& source, const String& /*schemaName*/, bool /*allowXmlValidation*/) { // All stuff goes here XML_Parser parser = XML_ParserCreate(0); // Create a parser if (!parser) { CEGUI_THROW(GenericException("Unable to create a new Expat Parser")); } XML_SetUserData(parser, (void*)&handler); // Initialise user data XML_SetElementHandler(parser, startElement, endElement); // Register callback for elements XML_SetCharacterDataHandler(parser, characterData); // Register callback for character data // Parse the data (note that the last true parameter tels Expat that this is the last chunk of the document if (!XML_Parse(parser, reinterpret_cast<const char*>(source.getDataPtr()), source.getSize(), true)) { String exception (String((const encoded_char*)"XML Parsing error '") + String((const encoded_char*)XML_ErrorString(XML_GetErrorCode(parser))) + String((const encoded_char*)"' at line ") + PropertyHelper<uint>::toString(XML_GetCurrentLineNumber(parser))); // (We know it is a valid pointer, otherwise an exception would have been thrown above.) XML_ParserFree(parser); CEGUI_THROW(GenericException(exception)); } // (We know it is a valid pointer, otherwise an exception would have been thrown above.) XML_ParserFree(parser); }
void LibxmlParser::parseXML(XMLHandler& handler, const RawDataContainer& source, const String& /*schemaName*/, bool /*allowXmlValidation*/) { xmlDocPtr doc = xmlParseMemory( reinterpret_cast<const char*>(source.getDataPtr()), source.getSize()); if (!doc) { xmlError* err = xmlGetLastError(); CEGUI_THROW(GenericException( String("xmlParseMemory failed in file: '") + err->file + "' at line number" + PropertyHelper<uint>::toString(err->line) + ". Error is:" + err->message)); } // get root element xmlNode* root = xmlDocGetRootElement(doc); // process all elements from root to end of doc processXMLElement(handler, root); // release the xmlDoc xmlFreeDoc(doc); }
//----------------------------------------------------------------------------// void OgreResourceProvider::unloadRawDataContainer(RawDataContainer& data) { if (data.getDataPtr()) { delete[] data.getDataPtr(); data.setData(0); data.setSize(0); } }
void DefaultResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { if (filename.empty() || (filename == (utf8*)"")) { throw InvalidRequestException((utf8*) "DefaultResourceProvider::load - Filename supplied for data loading must be valid"); } std::wstring strFilename1 = filename.c_wstring (); std::wstring strFilename2 = System::getSingleton ().GetGuiWorkingDirectory().c_wstring () + strFilename1; // If supplied filename looks like it is absolute, try that first bool bIsAbsolutePath = false; { SString strTemp = PathConform ( filename.c_str () ); if ( strTemp.Contains ( ":" ) || strTemp.BeginsWith ( "\\" ) ) std::swap ( strFilename1, strFilename2 ); } std::ifstream dataFile; dataFile.open(strFilename2.c_str (), std::ios::binary|std::ios::ate); if( dataFile.fail()) { dataFile.clear(); dataFile.open(strFilename1.c_str (), std::ios::binary|std::ios::ate); if( dataFile.fail()) { throw InvalidRequestException((utf8*) "DefaultResourceProvider::load - " + filename + " does not exist"); } } std::streampos size = dataFile.tellg(); dataFile.seekg (0, std::ios::beg); unsigned char* buffer = new unsigned char [(uint)size]; try { dataFile.read(reinterpret_cast<char*>(buffer), size); } catch(std::ifstream::failure e) { delete [] buffer; throw GenericException((utf8*) "DefaultResourceProvider::loadRawDataContainer - Problem reading " + filename); } dataFile.close(); //memcpy(container->getDataPtr(), buffer, size); output.setData(buffer); output.setSize((size_t)size); //delete [] buffer; }
TinyXMLDocument::TinyXMLDocument(XMLHandler& handler, const String& filename, const String& schemaName, const String& resourceGroup) { d_handler = &handler; // use resource provider to load file data // Fixed using patch from tracker item #000057 // cegui_mk2-0.4.1-fixtinyxml.patch RawDataContainer rawXMLData; System::getSingleton().getResourceProvider()->loadRawDataContainer(filename, rawXMLData, resourceGroup); // Create a buffer with extra bytes for a newline and a terminating null size_t size = rawXMLData.getSize(); char* buf = new char[size + 2]; memcpy(buf, rawXMLData.getDataPtr(), size); // PDT: The addition of the newline is a kludge to resolve an issue // whereby parse returns 0 if the xml file has no newline at the end but // is otherwise well formed. buf[size] = '\n'; buf[size+1] = 0; // Parse the document CEGUI_TINYXML_NAMESPACE::TiXmlDocument doc; if (!doc.Parse((const char*)buf)) { // error detected, cleanup out buffers delete[] buf; System::getSingleton().getResourceProvider()-> unloadRawDataContainer(rawXMLData); // throw exception throw FileIOException("TinyXMLParser: an error occurred while " "parsing the XML document '" + filename + "' - check it for potential errors!."); } const CEGUI_TINYXML_NAMESPACE::TiXmlElement* currElement = doc.RootElement(); if (currElement) { try { // function called recursively to parse xml data processElement(currElement); } catch(...) { delete [] buf; System::getSingleton().getResourceProvider()->unloadRawDataContainer(rawXMLData); throw; } } // if (currElement) // Free memory delete [] buf; System::getSingleton().getResourceProvider()->unloadRawDataContainer(rawXMLData); }
void XercesParser::initialiseSchema(XERCES_CPP_NAMESPACE::SAX2XMLReader* reader, const String& schemaName, const String& xmlFilename, const String& resourceGroup) { XERCES_CPP_NAMESPACE_USE; // enable schema use and set validation options reader->setFeature(XMLUni::fgXercesSchema, true); reader->setFeature(XMLUni::fgSAX2CoreValidation, true); reader->setFeature(XMLUni::fgXercesValidationErrorAsFatal, true); // load in the raw schema data RawDataContainer rawSchemaData; // try base filename first, from default resource group try { Logger::getSingleton().logEvent("XercesParser::initialiseSchema - Attempting to load schema from file '" + schemaName + "'."); System::getSingleton().getResourceProvider()->loadRawDataContainer(schemaName, rawSchemaData, d_defaultSchemaResourceGroup); } // oops, no file. Try an alternative instead, using base path and // resource group from the XML file we're going to be processing. catch(InvalidRequestException) { // get path from filename String schemaFilename; size_t pos = xmlFilename.rfind("/"); if (pos == String::npos) pos = xmlFilename.rfind("\\"); if (pos != String::npos) schemaFilename.assign(xmlFilename, 0, pos + 1); // append schema filename schemaFilename += schemaName; // re-try the load operation. Logger::getSingleton().logEvent("XercesParser::initialiseSchema - Attempting to load schema from file '" + schemaFilename + "'."); System::getSingleton().getResourceProvider()->loadRawDataContainer(schemaFilename, rawSchemaData, resourceGroup); } // wrap schema data in a xerces MemBufInputSource object MemBufInputSource schemaData( rawSchemaData.getDataPtr(), static_cast<const unsigned int>(rawSchemaData.getSize()), schemaName.c_str(), false); reader->loadGrammar(schemaData, Grammar::SchemaGrammarType, true); // enable grammar reuse reader->setFeature(XMLUni::fgXercesUseCachedGrammarInParse, true); // set schema for usage XMLCh* pval = XMLString::transcode(schemaName.c_str()); reader->setProperty(XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation, pval); XMLString::release(&pval); Logger::getSingleton().logEvent("XercesParser::initialiseSchema - XML schema file '" + schemaName + "' has been initialised."); // use resource provider to release loaded schema data (if it supports this) System::getSingleton().getResourceProvider()->unloadRawDataContainer(rawSchemaData); }
void StdDataLoop::execPart2() { if (verbose) std::cout << __PRETTY_FUNCTION__ << std::endl; unsigned count = 0; uint32_t done = 0; //uint32_t rate = 0; //uint32_t curCnt = 0; unsigned iterations = 0; //uint32_t startAddr = 0; std::vector<RawData*> tmp_storage; RawData *newData = NULL; RawDataContainer *rdc = new RawDataContainer(); while (done == 0) { //rate = g_rx->getDataRate(); //curCnt = g_rx->getCurCount(); done = g_tx->isTrigDone(); do { newData = g_rx->readData(); iterations++; if (newData != NULL) { rdc->add(newData); count += newData->words; } } while (newData != NULL); delete newData; } // Gather rest of data after timeout (~0.1ms) std::this_thread::sleep_for(std::chrono::microseconds(500)); do { //curCnt = g_rx->getCurCount(); newData = g_rx->readData(); iterations++; if (newData != NULL) { rdc->add(newData); count += newData->words; } } while (newData != NULL); delete newData; rdc->stat = *g_stat; storage->pushData(rdc); if (verbose) std::cout << " --> Received " << count << " words! " << iterations << std::endl; m_done = true; counter++; }
void IrrlichtTexture::loadFromFile(const String& filename, const String& resourceGroup) { freeTexture(); RawDataContainer texFile; System::getSingleton().getResourceProvider()->loadRawDataContainer(filename, texFile, resourceGroup); IrrlichtMemoryFile imf(filename, texFile.getDataPtr(), texFile.getSize()); driver->setTextureCreationFlag(irr::video::ETCF_CREATE_MIP_MAPS,true); tex=driver->getTexture(&imf); tex->grab(); // unload file data buffer System::getSingleton().getResourceProvider()->unloadRawDataContainer(texFile); updateCachedScaleValues(); }
TinyXMLDocument::TinyXMLDocument(XMLHandler& handler, const RawDataContainer& source, const String& /*schemaName*/) { d_handler = &handler; // Create a buffer with extra bytes for a newline and a terminating null size_t size = source.getSize(); char* buf = new char[size + 2]; memcpy(buf, source.getDataPtr(), size); // PDT: The addition of the newline is a kludge to resolve an issue // whereby parse returns 0 if the xml file has no newline at the end but // is otherwise well formed. buf[size] = '\n'; buf[size+1] = 0; // Parse the document TiXmlDocument doc; if (!doc.Parse((const char*)buf)) { // error detected, cleanup out buffers delete[] buf; // throw exception throw FileIOException("an error occurred while " "parsing the XML document - check it for potential errors!."); } const TiXmlElement* currElement = doc.RootElement(); if (currElement) { try { // function called recursively to parse xml data processElement(currElement); } catch (...) { delete [] buf; throw; } } // if (currElement) // Free memory delete [] buf; }
void XMLParser::parseXMLString(XMLHandler& handler, const String& source, const String& schemaName) { // Put the source string into a RawDataContainer RawDataContainer rawXMLData; const char* c_str = source.c_str(); rawXMLData.setData((uint8*)c_str); rawXMLData.setSize(strlen(c_str)); try { // The actual parsing action (this is overridden and depends on the specific parser) parseXML(handler, rawXMLData, schemaName); } catch(...) { // make sure we don't allow rawXMLData to release String owned data no matter what! rawXMLData.setData(0); rawXMLData.setSize(0); CEGUI_RETHROW; } // !!! We must not allow DataContainer to delete String owned data, // therefore, we set it's data to 0 to avoid double-deletion rawXMLData.setData(0); rawXMLData.setSize(0); }
void StdDataGatherer::execPart2() { if (verbose) std::cout << __PRETTY_FUNCTION__ << std::endl; unsigned count = 0; uint32_t done = 0; uint32_t rate = 0; signaled = 0; signal(SIGINT, [](int signum){signaled = 1;}); std::cout << "### IMPORTANT ### Going into endless loop, interrupt with ^c (SIGINT)!" << std::endl; std::vector<RawData*> tmp_storage; RawData *newData = NULL; while (done == 0) { RawDataContainer *rdc = new RawDataContainer(); rate = g_rx->getDataRate(); if (verbose) std::cout << " --> Data Rate: " << rate/256.0/1024.0 << " MB/s" << std::endl; done = g_tx->isTrigDone(); do { newData = g_rx->readData(); if (newData != NULL) { rdc->add(newData); count += newData->words; } } while (newData != NULL); delete newData; rdc->stat = *g_stat; storage->pushData(rdc); if (signaled == 1) { std::cout << "Caught interrupt, stopping data taking!" << std::endl; std::cout << "Abort will leave buffers full of data!" << std::endl; g_tx->toggleTrigAbort(); } std::this_thread::sleep_for(std::chrono::microseconds(500)); } m_done = true; counter++; }
void IrrlichtResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { if(!fsys->existFile(filename.c_str())) { String sMsg=(utf8*)"IrrlichtResourceProvider::loadRawDataContainer - Filename supplied for loading must be valid"; sMsg+=(utf8*)" ["+filename+(utf8*)"]"; throw InvalidRequestException(sMsg); } else { irr::u8* input; irr::u32 input_size; irr::io::IReadFile* f=fsys->createAndOpenFile(filename.c_str()); input_size=f->getSize(); input= new irr::u8[input_size]; f->read(input,input_size); output.setData(input); output.setSize(input_size); } }
//----------------------------------------------------------------------------// void DefaultResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { if (filename.empty()) CEGUI_THROW(InvalidRequestException("DefaultResourceProvider::load: " "Filename supplied for data loading must be valid")); const String final_filename(getFinalFilename(filename, resourceGroup)); #if defined(__WIN32__) || defined(_WIN32) FILE* file = _wfopen(Utf8ToUtf16(final_filename.c_str()).c_str(), L"rb"); #else FILE* file = fopen(final_filename.c_str(), "rb"); #endif if (file == 0) CEGUI_THROW(InvalidRequestException("DefaultResourceProvider::load: " + final_filename + " does not exist")); fseek(file, 0, SEEK_END); const long size = ftell(file); fseek(file, 0, SEEK_SET); unsigned char* const buffer = new unsigned char[size]; const size_t size_read = fread(buffer, sizeof(char), size, file); fclose(file); if (size_read != size) { delete[] buffer; CEGUI_THROW(GenericException( "DefaultResourceProvider::loadRawDataContainer: " "A problem occurred while reading file: " + final_filename)); } output.setData(buffer); output.setSize(size); }
TinyXMLDocument::TinyXMLDocument(XMLHandler& handler, const String& filename, const String& schemaName, const String& resourceGroup) { d_handler = &handler; // use resource provider to load file data // Fixed using patch from tracker item #000057 // cegui_mk2-0.4.1-fixtinyxml.patch RawDataContainer rawXMLData; System::getSingleton().getResourceProvider()->loadRawDataContainer(filename, rawXMLData, resourceGroup); // Create a buffer with the missing extra byte size_t size = rawXMLData.getSize(); char* buf = new char[size + 1]; memcpy(buf, rawXMLData.getDataPtr(), size); buf[size] = 0; try { // Parse the document CEGUITinyXML::TiXmlDocument doc; doc.Parse((const char*)buf); const CEGUITinyXML::TiXmlElement* currElement = doc.RootElement(); if (currElement) { // function called recursively to parse xml data processElement(currElement); } // if (currElement) } catch(...) { delete [] buf; System::getSingleton().getResourceProvider()->unloadRawDataContainer(rawXMLData); throw; } // Free memory delete [] buf; System::getSingleton().getResourceProvider()->unloadRawDataContainer(rawXMLData); }
void NeLResourceProvider::loadRawDataContainer(const String &filename, RawDataContainer &output, const String& resourceGroup) { if(!NLMISC::CPath::exists(filename.c_str())) { nlinfo("Scheme::Scheme - Filename supplied for Scheme loading must be valid [%s]",filename.c_str()); String sMsg=(utf8*)"Scheme::Scheme - Filename supplied for Scheme loading must be valid"; sMsg+=(utf8*)" ["+filename+(utf8*)"]"; throw InvalidRequestException(sMsg); } uint32 input_size; std::string fname=NLMISC::CPath::lookup(filename.c_str()); NLMISC::CIFile f(NLMISC::CPath::lookup(filename.c_str())); // get the size of the file and create a temp container. input_size=f.getFileSize(); uint8 *input=new uint8[input_size+1]; input[input_size]=0; f.serialBuffer(input,input_size); f.close(); output.setData(input); output.setSize(input_size); }
//----------------------------------------------------------------------------// RapidXMLDocument::RapidXMLDocument(XMLHandler& handler, const String& filename, const String& /*schemaName*/, const String& resourceGroup) { d_handler = &handler; // use resource provider to load file data RawDataContainer rawXMLData; System::getSingleton().getResourceProvider()-> loadRawDataContainer(filename, rawXMLData, resourceGroup); // Create a buffer with extra bytes for a newline and a terminating null size_t size = rawXMLData.getSize(); char* buf = new char[size + 2]; memcpy(buf, rawXMLData.getDataPtr(), size); // PDT: The addition of the newline is a kludge to resolve an issue // whereby parse returns 0 if the xml file has no newline at the end but // is otherwise well formed. buf[size] = '\n'; buf[size + 1] = 0; // Parse the document rapidxml::xml_document<> doc; // character type defaults to char try { doc.parse<0>(buf); // 0 means default parse flags } catch (...) { // error detected, cleanup out buffers delete[] buf; System::getSingleton().getResourceProvider()-> unloadRawDataContainer(rawXMLData); // throw exception throw FileIOException("RapidXMLParser: an error occurred while " "parsing the XML document '" + filename + "' - check it for potential errors!."); } rapidxml::xml_node<>* currElement = doc.first_node(); if (currElement) { try { // function called recursively to parse xml data processElement(currElement); } catch (...) { delete[] buf; System::getSingleton().getResourceProvider()-> unloadRawDataContainer(rawXMLData); throw; } } // Free memory delete[] buf; System::getSingleton().getResourceProvider()-> unloadRawDataContainer(rawXMLData); }
//----------------------------------------------------------------------------// void MinizipResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { const String final_filename = getFinalFilename(filename, resourceGroup); if (d_pimpl->d_loadLocal && doesFileExist(final_filename)) { DefaultResourceProvider::loadRawDataContainer(filename, output, resourceGroup); return; } if (d_pimpl->d_zfile == 0) { throw InvalidRequestException( "'" + final_filename + "' cannot be " "loaded because the archive has not been set"); } #if CEGUI_STRING_CLASS == CEGUI_STRING_CLASS_STD if (unzLocateFile(d_pimpl->d_zfile, final_filename.c_str(), 0) != UNZ_OK) #elif CEGUI_STRING_CLASS == CEGUI_STRING_CLASS_UNICODE if (unzLocateFile(d_pimpl->d_zfile, final_filename.toUtf8String().c_str(), 0) != UNZ_OK) #endif { throw InvalidRequestException("'" + final_filename + "' does not exist"); } unz_file_info file_info; if (unzGetCurrentFileInfo(d_pimpl->d_zfile, &file_info, 0, 0, 0, 0, 0, 0) != UNZ_OK) { throw FileIOException("'" + final_filename + "' error reading file header"); } if (unzOpenCurrentFile(d_pimpl->d_zfile) != Z_OK) { throw FileIOException("'" + final_filename + "' error opening file"); } std::uint64_t size = file_info.uncompressed_size; std::uint8_t* buffer = new std::uint8_t[size]; if (unzReadCurrentFile(d_pimpl->d_zfile, buffer, size) < 0) { throw FileIOException("'" + final_filename + "' error reading file"); } if (unzCloseCurrentFile(d_pimpl->d_zfile) != UNZ_OK) { throw GenericException("'" + final_filename + "' error validating file"); } output.setData(buffer); output.setSize(size); }