static MetaDataResult::Tag tryReadPluginMetaDataFromCacheFile(const QString& canonicalPluginPath, RawPluginMetaData& result)
{
QJsonDocument jsonDocument;
if (readMetaDataFromCacheFile(jsonDocument) != ReadResult::Success)
return MetaDataResult::NotAvailable;
QJsonArray array = jsonDocument.array();
QDateTime pluginLastModified = QFileInfo(canonicalPluginPath).lastModified();
for (QJsonArray::const_iterator i = array.constBegin(); i != array.constEnd(); ++i) {
QJsonValue item = *i;
if (!item.isObject()) {
cacheFile()->remove();
return MetaDataResult::NotAvailable;
}
QJsonObject object = item.toObject();
if (object.value(QStringLiteral("path")).toString() == canonicalPluginPath) {
QString timestampString = object.value(QStringLiteral("timestamp")).toString();
if (timestampString.isEmpty()) {
cacheFile()->remove();
return MetaDataResult::NotAvailable;
}
QDateTime timestamp = QDateTime::fromString(timestampString);
if (timestamp < pluginLastModified) {
// Out of date data for this plugin => remove it from the file.
array.removeAt(i.i);
writeToCacheFile(array);
return MetaDataResult::NotAvailable;
}
if (object.contains(QLatin1String("unloadable")))
return MetaDataResult::Unloadable;
// Match.
result.name = object.value(QStringLiteral("name")).toString();
result.description = object.value(QStringLiteral("description")).toString();
result.mimeDescription = object.value(QStringLiteral("mimeDescription")).toString();
if (result.mimeDescription.isEmpty()) {
// Only the mime description is mandatory.
// Don't trust in the cache file if it is empty.
cacheFile()->remove();
return MetaDataResult::NotAvailable;
}
return MetaDataResult::Available;
}
}
return MetaDataResult::NotAvailable;
}
void SloxFolderManager::readFolders()
{
kdDebug() << k_funcinfo << endl;
QFile f( cacheFile() );
if ( !f.open( IO_ReadOnly ) ) {
kdDebug() << "Unable to open '" << cacheFile() << "'" << endl;
requestFolders();
return;
}
QDomDocument doc;
doc.setContent( &f );
mFolders.clear();
QDomNodeList nodes = doc.elementsByTagName( "D:prop" );
for( uint i = 0; i < nodes.count(); ++i ) {
QDomElement element = nodes.item(i).toElement();
QString id = "-1", parentId = "-1"; // OX default folder
bool def = false;
QString name, type;
QDomNode n;
for( n = element.firstChild(); !n.isNull(); n = n.nextSibling() ) {
QDomElement e = n.toElement();
QString tag = e.tagName();
QString value = e.text();
if ( tag == "ox:object_id" ) id = value;
else if ( tag == "ox:folder_id" ) parentId = value;
else if ( tag == "ox:title" ) name = value;
else if ( tag == "ox:module" ) type = value;
else if ( tag == "ox:defaultfolder" ) def = (value == "true");
}
if ( id != "-1" && parentId != "-1" ) {
SloxFolder *folder = new SloxFolder( id, parentId, type, name, def );
mFolders[id] = folder;
kdDebug() << k_funcinfo << "Found folder: " << folder->name() << endl;
}
}
// add top-level system folders that are not contained in the folder listing
SloxFolder *folder = new SloxFolder( "1", "0", "unbound", i18n("Private Folder") );
mFolders[folder->id()] = folder;
folder = new SloxFolder( "2", "0", "unbound", i18n("Public Folder") );
mFolders[folder->id()] = folder;
folder = new SloxFolder( "3", "0", "unbound", i18n("Shared Folder") );
mFolders[folder->id()] = folder;
folder = new SloxFolder( "4", "0", "unbound", i18n("System Folder") );
mFolders[folder->id()] = folder;
}
void tst_qmldiskcache::fileSelectors()
{
QQmlEngine engine;
QTemporaryDir tempDir;
QVERIFY(tempDir.isValid());
const QString testFilePath = tempDir.path() + "/test.qml";
{
QFile f(testFilePath);
QVERIFY2(f.open(QIODevice::WriteOnly), qPrintable(f.errorString()));
f.write(QByteArrayLiteral("import QtQml 2.0\nQtObject { property int value: 42 }"));
}
const QString selector = QStringLiteral("testSelector");
const QString selectorPath = tempDir.path() + "/+" + selector;
const QString selectedTestFilePath = selectorPath + "/test.qml";
{
QVERIFY(QDir::root().mkpath(selectorPath));
QFile f(selectorPath + "/test.qml");
QVERIFY2(f.open(QIODevice::WriteOnly), qPrintable(f.errorString()));
f.write(QByteArrayLiteral("import QtQml 2.0\nQtObject { property int value: 100 }"));
}
{
QQmlComponent component(&engine, testFilePath);
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 42);
QFile cacheFile(testFilePath + "c");
QVERIFY2(cacheFile.exists(), qPrintable(cacheFile.fileName()));
}
QQmlFileSelector qmlSelector(&engine);
qmlSelector.setExtraSelectors(QStringList() << selector);
engine.clearComponentCache();
{
QQmlComponent component(&engine, testFilePath);
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 100);
QFile cacheFile(selectedTestFilePath + "c");
QVERIFY2(cacheFile.exists(), qPrintable(cacheFile.fileName()));
}
}
//-------------------------------------------------------------------------
nsresult
DataStruct::WriteCache(nsISupports* aData, uint32_t aDataLen)
{
// Get a new path and file to the temp directory
nsCOMPtr<nsIFile> cacheFile ( getter_AddRefs(GetFileSpec(mCacheFileName)) );
if (cacheFile) {
// remember the file name
if (!mCacheFileName) {
nsXPIDLCString fName;
cacheFile->GetNativeLeafName(fName);
mCacheFileName = nsCRT::strdup(fName);
}
// write out the contents of the clipboard
// to the file
//uint32_t bytes;
nsCOMPtr<nsIOutputStream> outStr;
NS_NewLocalFileOutputStream(getter_AddRefs(outStr),
cacheFile);
if (!outStr) return NS_ERROR_FAILURE;
void* buff = nullptr;
nsPrimitiveHelpers::CreateDataFromPrimitive ( mFlavor.get(), aData, &buff, aDataLen );
if ( buff ) {
uint32_t ignored;
outStr->Write(reinterpret_cast<char*>(buff), aDataLen, &ignored);
nsMemory::Free(buff);
return NS_OK;
}
}
return NS_ERROR_FAILURE;
}
void TestGeoDataPack::saveKMLToCache()
{
GeoDataParser parser( GeoData_KML );
QByteArray array( content.toUtf8() );
QBuffer buffer( &array );
buffer.open( QIODevice::ReadOnly );
if ( !parser.read( &buffer ) ) {
qWarning( "Could not parse data!" );
QFAIL( "Could not parse data!" );
return;
}
GeoDocument* document = parser.releaseDocument();
QVERIFY( document );
qDebug() << " parse Timer " << timer.elapsed();
GeoDataDocument *dataDocument = static_cast<GeoDataDocument*>( document );
QString path = QString( "%1/%2.cache" );
path = path.arg( QCoreApplication::applicationDirPath() );
path = path.arg( QString( "KMLTest" ) );
QFile cacheFile( path );
if ( cacheFile.open( QIODevice::WriteOnly ) ) {
QDataStream stream ( &cacheFile );
dataDocument->pack( stream );
cacheFile.close();
qDebug( "Saved kml document to cache: %s", path.toLatin1().data() );
}
qDebug() << "write Timer " << timer.elapsed();
delete document;
}
void *DDiskImageAbstract::Fopen(const char *filename,const char *mode)
{
diskError=false;
void *ret=NULL;
DEBUG_OUT<<"Fopen("<<filename<<")...\n";
if(!diskMounted) {
std::cerr<<"DDiskImageAbstract::load no disk in drive!\n";
diskError=true;
return NULL;
}
if(noFileSystem) {
std::cerr<<"DDiskImageAbstract::fopen Non-DOS Disk!\n";
return NULL;
}
const char *thename=SearchForFirst(filename);
if(!thename) {
std::cerr<<"DDiskImageAbstract::fopen SearchForFirst returned NULL!\n";
return NULL;
}
DDirEntry *aFile=SearchForFirstFile(thename);
if(!aFile) {
std::cerr<<"DDiskImageAbstract::fopen SearchForFirstFile returned NULL!\n";
return NULL;
}
cacheFile(aFile);
aFile->curSeek=0;
return (void *)aFile;
}
/** \fn OSDImageCache::SaveToDisk(const OSDImageCacheValue*)
* \brief Saves OSD image data to disk cache.
*
* Item is not written to the memory cache, i.e., it stays as
* property of the client.
*
* \param value The cached OSD image to save.
*/
void OSDImageCache::SaveToDisk(const OSDImageCacheValue *value)
{
if (InFileCache(value->GetKey()))
return;
QDir dir(MythContext::GetConfDir() + "/osdcache/");
if (!dir.exists() && !dir.mkdir(dir.path()))
{
VERBOSE(VB_IMPORTANT, LOC_ERR + "Creating osdcache directory failed.");
return;
}
QFile cacheFile(dir.path() + "/" + value->GetKey());
if (!cacheFile.open(IO_WriteOnly | IO_Truncate))
{
VERBOSE(VB_IMPORTANT, LOC_ERR + "Creating osdcache file failed.");
return;
}
uint32_t imwidth = value->m_imagesize.width();
uint32_t imheight = value->m_imagesize.height();
uint yuv_size = imwidth * imheight * 3 / 2;
QDataStream stream(&cacheFile);
stream << imwidth << imheight;
stream.writeRawBytes((const char*)value->m_yuv, yuv_size);
stream.writeRawBytes((const char*)value->m_alpha, imwidth * imheight);
cacheFile.close();
}
void GrooveRequest::post()
{
QString cacheKey = generateCacheKey();
if (cacheKey.length()) {
qDebug() << Q_FUNC_INFO << "Possibly cached request";
QString cachePath = QDesktopServices::storageLocation(QDesktopServices::CacheLocation) + "/libgroove/cache/api/" + cacheKey;
QFile cacheFile(cachePath);
if (cacheFile.open(QIODevice::ReadOnly)) {
qDebug() << Q_FUNC_INFO << "Definitely cached request";
QByteArray response = cacheFile.readAll();
processData(response);
return;
}
}
m_request.setHeader(m_request.ContentTypeHeader, "application/json");
QJson::Serializer serializer;
qDebug() << Q_FUNC_INFO << "Posting to: " << m_request.url();
qDebug() << Q_FUNC_INFO << serializer.serialize(buildRequest());
QNetworkReply *reply = m_client->networkManager()->post(m_request, serializer.serialize(buildRequest()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), SIGNAL(error(QNetworkReply::NetworkError)));
connect(reply, SIGNAL(finished()), SLOT(onFinished()));
}
int GccCommand::execute()
{
if (arguments().contains(QLatin1String("-dumpmachine")))
m_cacheFile = QLatin1String(Mer::Constants::GCC_DUMPMACHINE);
else if (arguments().contains(QLatin1String("-dumpversion")))
m_cacheFile = QLatin1String(Mer::Constants::GCC_DUMPVERSION);
if (!m_cacheFile.isEmpty())
m_cacheFile.prepend(sdkToolsPath() + QDir::separator());
if (QFile::exists(m_cacheFile)) {
QFile cacheFile(m_cacheFile);
if (!cacheFile.open(QIODevice::ReadOnly)) {
return 1;
}
fprintf(stdout, "%s", cacheFile.readAll().constData());
fflush(stdout);
return 0;
}
return 1;
//TODO: remote command to cache ?
/*
// hack for gcc when querying pre-defined macros and header paths
QRegExp rx(QLatin1String("\\bgcc\\b.*\\B-\\B"));
const bool queryPredefinedMacros = rx.indexIn(completeCommand) != -1;
if (queryPredefinedMacros)
completeCommand.append(QLatin1String(" < /dev/null"));
*/
}
void ObjectCache::notifyObjectCompiled(llvm::Module const* _module, llvm::MemoryBufferRef _object)
{
Guard g{x_cacheMutex};
// Only in "on" and "write" mode
if (g_mode != CacheMode::on && g_mode != CacheMode::write)
return;
// TODO: Disabled because is not thread-safe.
// if (g_listener)
// g_listener->stateChanged(ExecState::CacheWrite);
auto&& id = _module->getModuleIdentifier();
llvm::SmallString<256> cachePath{getVersionedCacheDir()};
if (auto err = llvm::sys::fs::create_directories(cachePath))
{
DLOG(cache) << "Cannot create cache dir " << cachePath.str().str() << " (error: " << err.message() << "\n";
return;
}
llvm::sys::path::append(cachePath, id);
DLOG(cache) << id << ": write\n";
std::error_code error;
llvm::raw_fd_ostream cacheFile(cachePath, error, llvm::sys::fs::F_None);
cacheFile << _object.getBuffer();
}
void CacheBasedLanguageModel::Load(const std::string file)
{
//file format
//age || n-gram
//age || n-gram || n-gram || n-gram || ...
//....
//each n-gram is a sequence of n words (no matter of n)
//
//there is no limit on the size of n
//
//entries can be repeated, but the last entry overwrites the previous
VERBOSE(2,"Loading data from the cache file " << file << std::endl);
InputFileStream cacheFile(file);
std::string line;
int age;
std::vector<std::string> words;
while (getline(cacheFile, line)) {
std::vector<std::string> vecStr = TokenizeMultiCharSeparator( line , "||" );
if (vecStr.size() >= 2) {
age = Scan<int>(vecStr[0]);
vecStr.erase(vecStr.begin());
Update(vecStr,age);
} else {
TRACE_ERR("ERROR: The format of the loaded file is wrong: " << line << std::endl);
CHECK(false);
}
}
IFVERBOSE(2) Print();
}
void TestGeoDataPack::saveCitiesToCache()
{
GeoDataParser parser( GeoData_KML );
QFile citiesFile( CITIES_PATH );
citiesFile.open( QIODevice::ReadOnly );
if ( !parser.read( &citiesFile ) ) {
qWarning( "Could not parse data!" );
QFAIL( "Could not parse data!" );
return;
}
GeoDocument* document = parser.releaseDocument();
QVERIFY( document );
qDebug() << "read Timer " << timer.elapsed();
GeoDataDocument *dataDocument = static_cast<GeoDataDocument*>( document );
QString path = QString( "%1/%2.cache" );
path = path.arg( QCoreApplication::applicationDirPath() );
path = path.arg( QString( "CitiesTest" ) );
QFile cacheFile( path );
if ( cacheFile.open( QIODevice::WriteOnly ) ) {
QDataStream stream ( &cacheFile );
dataDocument->pack( stream );
cacheFile.close();
qDebug( "Saved kml document to cache: %s", path.toLatin1().data() );
}
QVERIFY( cacheFile.size() > 0 );
qDebug() << "write Timer " << timer.elapsed();
delete document;
}
void tst_qmldiskcache::cacheResources()
{
const QString cacheDirectory = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
QVERIFY(QDir::root().mkpath(cacheDirectory));
const QString qmlCacheDirectory = cacheDirectory + QLatin1String("/qmlcache/");
QVERIFY(QDir(qmlCacheDirectory).removeRecursively());
QVERIFY(QDir::root().mkpath(qmlCacheDirectory));
QVERIFY(QDir(qmlCacheDirectory).entryList(QDir::NoDotAndDotDot).isEmpty());
QQmlEngine engine;
{
CleanlyLoadingComponent component(&engine, QUrl("qrc:/test.qml"));
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 20);
}
const QStringList entries = QDir(qmlCacheDirectory).entryList(QDir::NoDotAndDotDot | QDir::Files);
QCOMPARE(entries.count(), 1);
QDateTime cacheFileTimeStamp;
{
QFile cacheFile(qmlCacheDirectory + QLatin1Char('/') + entries.constFirst());
QVERIFY2(cacheFile.open(QIODevice::ReadOnly), qPrintable(cacheFile.errorString()));
QV4::CompiledData::Unit unit;
QVERIFY(cacheFile.read(reinterpret_cast<char *>(&unit), sizeof(unit)) == sizeof(unit));
cacheFileTimeStamp = QFileInfo(cacheFile.fileName()).lastModified();
QDateTime referenceTimeStamp = QFileInfo(":/test.qml").lastModified();
if (!referenceTimeStamp.isValid())
referenceTimeStamp = QFileInfo(QCoreApplication::applicationFilePath()).lastModified();
QCOMPARE(qint64(unit.sourceTimeStamp), referenceTimeStamp.toMSecsSinceEpoch());
}
waitForFileSystem();
{
CleanlyLoadingComponent component(&engine, QUrl("qrc:///test.qml"));
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 20);
}
{
const QStringList entries = QDir(qmlCacheDirectory).entryList(QDir::NoDotAndDotDot | QDir::Files);
QCOMPARE(entries.count(), 1);
QCOMPARE(QFileInfo(qmlCacheDirectory + QLatin1Char('/') + entries.constFirst()).lastModified().toMSecsSinceEpoch(), cacheFileTimeStamp.toMSecsSinceEpoch());
}
}
static void writeToCacheFile(const QJsonArray& array)
{
OwnPtr<QFile> file = cacheFile();
if (!file->open(QFile::WriteOnly | QFile::Truncate)) {
// It should never but let's be pessimistic, it is the file system after all.
qWarning("Cannot write into plugin meta data cache file: %s\n", qPrintable(file->fileName()));
return;
}
// Don't care about write error here. We will detect it later.
file->write(QJsonDocument(array).toJson());
}
/** \fn OSDImageCache::Get(const QString&,bool)
* \brief Returns OSD image data from cache.
*
* This also removes the image from the cache so it won't be deleted
* while in use. The deletion of the taken item becomes responsibility
* of the client. Returns NULL if item with the given key is not found.
*
* \param key The key for this image.
* \param useFile If true, also check the disk cache.
*/
OSDImageCacheValue *OSDImageCache::Get(const QString &key, bool useFile)
{
QMutexLocker locker(&m_cacheLock);
OSDImageCacheValue* item = m_imageCache.find(key);
if (item)
{
m_memHits++;
return m_imageCache.take(key);
}
if (!useFile || !InFileCache(key))
{
m_misses++;
return NULL;
}
QDir dir(MythContext::GetConfDir() + "/osdcache/");
QFile cacheFile(dir.path() + "/" + key);
cacheFile.open(IO_ReadOnly);
uint32_t imwidth = 0;
uint32_t imheight = 0;
QDataStream stream(&cacheFile);
stream >> imwidth >> imheight;
uint yuv_size = imwidth * imheight * 3 / 2;
uint tot_size = (sizeof(imwidth) * 2) + yuv_size + (imwidth * imheight);
if (cacheFile.size() != tot_size)
{
VERBOSE(VB_IMPORTANT, LOC_ERR + key + " wrong cache file size!"
<< cacheFile.size() << " != " << tot_size);
return NULL;
}
unsigned char *yuv = new unsigned char[yuv_size];
unsigned char *alpha = new unsigned char[imwidth * imheight];
stream.readRawBytes((char*)yuv, yuv_size);
stream.readRawBytes((char*)alpha, imwidth * imheight);
cacheFile.close();
OSDImageCacheValue* value =
new OSDImageCacheValue(
key,
yuv, yuv,
yuv + (imwidth * imheight),
yuv + (imwidth * imheight * 5 / 4),
alpha, QRect(0, 0, imwidth, imheight));
m_diskHits++;
return value;
}
void SloxFolderManager::slotResult( KJob *job )
{
kDebug() ;
if ( job->error() ) {
static_cast<KIO::Job*>(job)->ui()->showErrorMessage();
} else {
kDebug() <<" success, writing to" << cacheFile();
QFile f( cacheFile() );
if ( !f.open( QIODevice::WriteOnly ) ) {
kDebug() <<"Unable to open '" << cacheFile() <<"'";
return;
}
QTextStream stream ( &f );
stream << mDownloadJob->response();
f.close();
readFolders();
}
mDownloadJob = 0;
emit foldersUpdated();
}
void Document::cache()
{
if (m_cache_outdated) {
m_cache_outdated = false;
DocumentWriter* writer = new DocumentWriter;
writer->setFileName(g_cache_path + m_cache_filename);
writer->setType(m_filename.section(QLatin1Char('.'), -1));
writer->setRichText(m_rich_text);
writer->setCodePage(m_codepage);
writer->setDocument(m_text->document()->clone());
emit cacheFile(writer);
}
}
void SloxFolderManager::slotResult( KIO::Job *job )
{
kdDebug() << k_funcinfo << endl;
if ( job->error() ) {
job->showErrorDialog( 0 );
} else {
kdDebug() << k_funcinfo << " success, writing to " << cacheFile() << endl;
QFile f( cacheFile() );
if ( !f.open( IO_WriteOnly ) ) {
kdDebug() << "Unable to open '" << cacheFile() << "'" << endl;
return;
}
QTextStream stream ( &f );
stream << mDownloadJob->response();
f.close();
readFolders();
}
mDownloadJob = 0;
emit foldersUpdated();
}
/**
* Put the given file in a cache, so that subsequent reads becomes faster.
* There is no need to uncache files later, as this happens automatically.
*/
Datum cache_file(PG_FUNCTION_ARGS)
{
if ( PG_ARGISNULL(0) )
ereport(ERROR, (errcode( ERRCODE_RAISE_EXCEPTION ), errmsg("NULL argument not allowed")));
int64 id = PG_GETARG_INT64(0);
// WARNING:
// Do not use any postgres functionality within this macro
// It will cause a resource leak.
HANDLE_EXCEPTIONS(cacheFile(id));
PG_RETURN_NULL();
}
//-------------------------------------------------------------------------
nsresult
DataStruct::ReadCache(nsISupports** aData, uint32_t* aDataLen)
{
// if we don't have a cache filename we are out of luck
if (!mCacheFileName)
return NS_ERROR_FAILURE;
// get the path and file name
nsCOMPtr<nsIFile> cacheFile ( getter_AddRefs(GetFileSpec(mCacheFileName)) );
bool exists;
if ( cacheFile && NS_SUCCEEDED(cacheFile->Exists(&exists)) && exists ) {
// get the size of the file
int64_t fileSize;
int64_t max32 = 0xFFFFFFFF;
cacheFile->GetFileSize(&fileSize);
if (fileSize > max32)
return NS_ERROR_OUT_OF_MEMORY;
uint32_t size = uint32_t(fileSize);
// create new memory for the large clipboard data
nsAutoArrayPtr<char> data(new char[size]);
if ( !data )
return NS_ERROR_OUT_OF_MEMORY;
// now read it all in
nsCOMPtr<nsIInputStream> inStr;
NS_NewLocalFileInputStream( getter_AddRefs(inStr),
cacheFile);
if (!cacheFile) return NS_ERROR_FAILURE;
nsresult rv = inStr->Read(data, fileSize, aDataLen);
// make sure we got all the data ok
if (NS_SUCCEEDED(rv) && *aDataLen == size) {
nsPrimitiveHelpers::CreatePrimitiveForData ( mFlavor.get(), data, fileSize, aData );
return *aData ? NS_OK : NS_ERROR_FAILURE;
}
// zero the return params
*aData = nullptr;
*aDataLen = 0;
}
return NS_ERROR_FAILURE;
}
ULONG DDiskImageAbstract::Fread(void *ptr,ULONG sizelem,ULONG n,void *fp)
{
if(!fp) return 0;
if(!ptr) return 0;
DDirEntry *f=(DDirEntry *)fp;
if(!f->data) cacheFile(fp);
if(!f->data) return 0; // we tried...
BYTE *p=(BYTE *)ptr;
ULONG rsize=sizelem*n;
//if(w) *w<<"Going to fread "<<rsize<<"\n";
if(!rsize) return 0;
for(ULONG t=0;t<rsize;t++) {
p[t]=f->data[f->curSeek+t];
}
f->curSeek+=rsize;
return n;
// TODO: Check that we actually read that much and return accordingly
}
void GeoEngine::saveTileToDisk(QUrl url, QByteArray dat)
{
//ne sauve pas une image vide
if(dat.size()==0)
return;
TuileParams params = extractParamsFromUrl(url.toString());
QFileInfo fileinfo = convertTileToFileInfo(params);
QDir dir(fileinfo.absolutePath());
if(!dir.exists())
dir.mkpath(dir.path());
QFile cacheFile(fileinfo.filePath());
cacheFile.open(QIODevice::WriteOnly);
cacheFile.write(dat);
cacheFile.close();
}
static ReadResult::Tag readMetaDataFromCacheFile(QJsonDocument& result)
{
OwnPtr<QFile> file = cacheFile();
if (!file->open(QFile::ReadOnly))
return ReadResult::Empty;
QByteArray data = file->readAll();
if (data.isEmpty())
return ReadResult::Empty;
QJsonParseError error;
result = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError || !result.isArray()) {
// Corrupted file.
file->remove();
return ReadResult::Error;
}
return ReadResult::Success;
}
void SoupNetworkSession::clearCache(const String& cacheDirectory)
{
CString cachePath = fileSystemRepresentation(cacheDirectory);
GUniquePtr<char> cacheFile(g_build_filename(cachePath.data(), "soup.cache2", nullptr));
if (!g_file_test(cacheFile.get(), G_FILE_TEST_IS_REGULAR))
return;
GUniquePtr<GDir> dir(g_dir_open(cachePath.data(), 0, nullptr));
if (!dir)
return;
while (const char* name = g_dir_read_name(dir.get())) {
if (!g_str_has_prefix(name, "soup.cache") && !stringIsNumeric(name))
continue;
GUniquePtr<gchar> filename(g_build_filename(cachePath.data(), name, nullptr));
if (g_file_test(filename.get(), G_FILE_TEST_IS_REGULAR))
g_unlink(filename.get());
}
}
void tst_qmldiskcache::recompileAfterDirectoryChange()
{
QQmlEngine engine;
TestCompiler testCompiler(&engine);
QVERIFY(testCompiler.tempDir.isValid());
QVERIFY(QDir(testCompiler.tempDir.path()).mkdir("source1"));
testCompiler.init(testCompiler.tempDir.path() + QLatin1String("/source1"));
{
const QByteArray contents = QByteArrayLiteral("import QtQml 2.0\n"
"QtObject {\n"
" property int blah: 42;\n"
"}");
testCompiler.clearCache();
QVERIFY2(testCompiler.compile(contents), qPrintable(testCompiler.lastErrorString));
QVERIFY2(testCompiler.verify(), qPrintable(testCompiler.lastErrorString));
testCompiler.closeMapping();
}
const QDateTime initialCacheTimeStamp = QFileInfo(testCompiler.cacheFilePath).lastModified();
QDir(testCompiler.tempDir.path()).rename(QStringLiteral("source1"), QStringLiteral("source2"));
waitForFileSystem();
testCompiler.init(testCompiler.tempDir.path() + QLatin1String("/source2"));
{
CleanlyLoadingComponent component(&engine, testCompiler.testFilePath);
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("blah").toInt(), 42);
}
QFile cacheFile(testCompiler.cacheFilePath);
QVERIFY2(cacheFile.exists(), qPrintable(cacheFile.fileName()));
QVERIFY(QFileInfo(testCompiler.cacheFilePath).lastModified() > initialCacheTimeStamp);
}
QIcon SlothThumbnailCache::addToCache(const QString &path, const QPixmap &pixmap,
const QSize &size,
Qt::AspectRatioMode aspectRatio /* Qt::IgnoreAspectRatio */) {
QString randstr = Utils::randomString(20);
QString cacheFilePath = FileUtils::combine(this->cacheDir(size), randstr);
QFile indexFile(this->iconCacheIndexFile(size));
QFile cacheFile(cacheFilePath);
if(!indexFile.open(QIODevice::Append) || !cacheFile.open(QIODevice::WriteOnly))
return QIcon();
QTextStream appendIndexFile(&indexFile);
appendIndexFile << randstr + "=" + QDir::cleanPath(path) + "\n";
pixmap.scaled(size, aspectRatio).save(&cacheFile, "PNG");
indexFile.close();
cacheFile.close();
return QIcon(cacheFilePath);
}
void GrooveRequest::onFinished()
{
QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
if (GROOVE_VERIFY(reply, "search returned without a QNetworkReply")) return;
if (!reply->error()) {
QByteArray response = reply->readAll();
bool success = processData(response);
// don't cache if there was a fault code
if (success) {
QString cacheKey = generateCacheKey();
// TODO: codeshare with GrooveStream so we don't reinvent caching like this
if (cacheKey.length()) {
qDebug() << Q_FUNC_INFO << "Cached a " << response.size() << " byte response with cache key " << cacheKey;
QString cachePath = QDesktopServices::storageLocation(QDesktopServices::CacheLocation) + "/libgroove/cache/api/";
QDir dir;
if (!dir.mkpath(cachePath)) {
} else {
cachePath += cacheKey;
QFile cacheFile(cachePath);
if (!cacheFile.open(QIODevice::WriteOnly)) {
qDebug() << Q_FUNC_INFO << "Cannot open cache file! " << cacheFile.errorString();
} else {
cacheFile.write(response);
}
}
}
}
} else {
qDebug() << Q_FUNC_INFO << "Not emitting for failed RPC";
return;
}
qDebug() << Q_FUNC_INFO << "Destroying response";
deleteLater();
}
void TestGeoDataPack::loadCitiesFromCache()
{
GeoDataDocument *cacheDocument = new GeoDataDocument();
QString path = QString( "%1/%2.cache" );
path = path.arg( QCoreApplication::applicationDirPath() );
path = path.arg( QString( "CitiesTest" ) );
QFile cacheFile( path );
if ( cacheFile.open( QIODevice::ReadOnly ) ) {
QDataStream stream ( &cacheFile );
cacheDocument->unpack( stream );
cacheFile.close();
qDebug( "Loaded kml document from cache: %s", path.toLatin1().data() );
}
QVERIFY( cacheDocument );
qDebug() << "read Timer " << timer.elapsed();
GeoDataParser parser( GeoData_KML );
QFile citiesFile( CITIES_PATH );
citiesFile.open( QIODevice::ReadOnly );
if ( !parser.read( &citiesFile ) ) {
qWarning( "Could not parse data!" );
QFAIL( "Could not parse data!" );
return;
}
GeoDocument* document = parser.releaseDocument();
QVERIFY( document );
qDebug() << "parse Timer " << timer.elapsed();
// commented out as it timeouts the test on build.kde.org
// GeoDataDocument *dataDocument = static_cast<GeoDataDocument*>( document );
// QVERIFY( compareDocuments( cacheDocument, dataDocument ) );
// qDebug() << "compare Timer " << timer.elapsed();
delete cacheDocument;
// delete dataDocument;
}
bool DocumentationPlugin::loadCachedIndex(IndexBox *index, DocumentationCatalogItem *item)
{
QString cacheName = locateLocal("data", QString("kdevdocumentation/index/cache_") + item->cacheVersion() + item->text(0));
QFile cacheFile(cacheName);
if (!cacheFile.open(IO_ReadOnly))
return false;
kdDebug() << "Using cached index for item: " << item->text(0) << endl;
QTextStream str(&cacheFile);
str.setEncoding(QTextStream::Unicode);
QString cache = str.read();
QStringList cacheList = QStringList::split("\n", cache, true);
QString ver = cacheList.first();
if (ver != CACHE_VERSION)
{
kdDebug() << "Wrong cache version: " << ver << endl;
return false;
}
QStringList::const_iterator it = cacheList.begin();
it++;
QString s[3]; int c = 0;
for (; it != cacheList.end(); ++it)
{
s[c] = *it;
if (c == 2)
{
IndexItemProto *ii = new IndexItemProto(this, item, index, s[0], s[1]);
ii->addURL(KURL(s[2]));
c = 0;
}
else c++;
}
cacheFile.close();
return true;
}
void DocumentationPlugin::cacheIndex(DocumentationCatalogItem *item)
{
kdDebug() << "Creating index cache for " << item->text(0) << endl;
QString cacheName = locateLocal("data", QString("kdevdocumentation/index/cache_") + item->text(0));
QFile cacheFile(cacheName);
if (!cacheFile.open(IO_WriteOnly))
return;
QTextStream str(&cacheFile);
str.setEncoding(QTextStream::Unicode);
str << CACHE_VERSION << endl;
QValueList<IndexItemProto*> catalogIndexes = indexes[item];
for (QValueList<IndexItemProto*>::const_iterator it = catalogIndexes.constBegin();
it != catalogIndexes.constEnd(); ++it)
{
str << (*it)->text() << endl;
str << (*it)->description() << endl;
str << (*it)->url().url() << endl;
}
cacheFile.close();
}
