void KArchiveTest::testZipAddLocalDirectory()
{
// Prepare local dir
KTempDir tmpDir;
const QString dirName = tmpDir.name();
const QByteArray file1Data = "Hello Shantanu";
const QString file1 = QLatin1String("file1");
QVERIFY(writeFile(dirName, file1, file1Data));
{
KZip zip(s_zipFileName);
QVERIFY(zip.open(QIODevice::WriteOnly));
QVERIFY(zip.addLocalDirectory(dirName, "."));
QVERIFY(zip.close());
}
{
KZip zip(s_zipFileName);
QVERIFY(zip.open(QIODevice::ReadOnly));
const KArchiveDirectory* dir = zip.directory();
QVERIFY(dir != 0);
const KArchiveEntry* e = dir->entry(file1);
QVERIFY(e && e->isFile());
const KArchiveFile* f = (KArchiveFile*)e;
QCOMPARE(f->data(), file1Data);
}
}
void FormulaDialog::accept()
{
extern Calculator calculator;
QString formula = ui.formulaComboBox->currentText();
if (calculator.setFormula(formula)) {
QDialog::accept();
EigenbroetlerWindow *eb = EigenbroetlerWindow::instance();
QSettings settings(eb->app_owner, eb->app_name);
settings.setValue(sq_name, ui.squareCheckBox->checkState() ? true : false);
settings.setValue(dim_name, ui.twoDRadioButton->isChecked());
settings.setValue(width_name, ui.widthSpinBox->value());
settings.setValue(height_name, ui.heightSpinBox->value());
settings.setValue(start_name, ui.firstNSpinBox->value());
settings.setValue(stop_name, ui.finalNSpinBox->value());
settings.setValue(incr_name, ui.incrNSpinBox->value());
settings.setValue(multi_name, ui.multiviewCheckBox->checkState() ? true : false);
std::map<QString, QString> frms;
frms[zip(formula)] = formula;
int item = 0;
settings.setValue(form_name.arg(item++), formula);
for (int i = 0; i < num_formulae && i < ui.formulaComboBox->count(); ++i) {
QString const key = zip(ui.formulaComboBox->itemText(i));
if (frms.find(key) == frms.end()) {
frms[key] = ui.formulaComboBox->itemText(i);
settings.setValue(form_name.arg(item++), ui.formulaComboBox->itemText(i));
}
}
}
}
Foam::tmp<Foam::vectorField> Foam::waveSuperposition::velocity
(
const scalar t,
const vectorField& xyz
) const
{
vectorField result(xyz.size(), vector::zero);
forAll(waveModels_, wavei)
{
const vector2D d(cos(waveAngles_[wavei]), sin(waveAngles_[wavei]));
const vector2DField xz
(
zip
(
d & zip(xyz.component(0), xyz.component(1)),
tmp<scalarField>(xyz.component(2))
)
);
const vector2DField uw
(
waveModels_[wavei].velocity(t, xz)
);
result += zip
(
d.x()*uw.component(0),
d.y()*uw.component(0),
uw.component(1)
);
}
tmp<scalarField> s = scale(zip(xyz.component(0), xyz.component(1)));
return s*result;
}
int main(){
int a[] = {1,7,9,4};
int b[] = {4,5,6,9};
int sizenuova = 100;
int testpari[sizenuova];
int testdispari[sizenuova];
int lunghezza1,lunghezza2;
int ris1;
lunghezza1 = sizeof(a)/sizeof(int);
lunghezza2 = sizeof(b)/sizeof(int);
int size = lunghezza1 *2;
int c[size];
if(lunghezza1!=lunghezza2){
return EXIT_FAILURE;
}
int j = 0;
for(int i = 0; i < (sizenuova*2); i++){
if(i % 2 == 0){
testpari[j] = i;
j++;
}
}
j = 0;
for(int i = 0; i < (sizenuova*2); i++){
if(i % 2 != 0){
testdispari[j] = i;
j++;
}
}
zip(testpari,testdispari,c,sizenuova*+1);
zip(a,b,c,lunghezza1);
ris1 = somma(c,size);
printf("La somma è: %d\n", ris1);
return EXIT_SUCCESS;
}
void Resources::load_resources(bool home_paks_only) throw (ResourcesException) {
try {
if (!home_paks_only) {
/* scan main directories */
subsystem << "scanning main directories" << std::endl;
read_all(resource_directory + dir_separator, 0, true);
/* read main paks */
Directory dir(resource_directory, ".pak");
const char *entry = 0;
while ((entry = dir.get_entry())) {
subsystem << "scanning " << entry << ".pak" << std::endl;
try {
ZipReader zip(resource_directory + dir_separator + entry + ".pak");
read_all("", &zip, true);
loaded_paks.push_back(LoadedPak(zip.get_zip_filename(), zip.get_zip_short_filename(), zip.get_hash(), false));
} catch (const ZipException& e) {
subsystem << e.what() << std::endl;
}
}
}
/* scan user directories */
subsystem << "scanning user directories" << std::endl;
read_all(get_home_directory() + dir_separator + UserDirectory + dir_separator, 0, false);
/* read home directory */
std::string hdir = get_home_directory() + dir_separator + UserDirectory;
Directory dir(hdir, ".pak");
const char *entry = 0;
while ((entry = dir.get_entry())) {
subsystem << "scanning " << entry << ".pak" << std::endl;
try {
ZipReader zip(hdir + dir_separator + entry + ".pak");
read_all("", &zip, false);
loaded_paks.push_back(LoadedPak(zip.get_zip_filename(), zip.get_zip_short_filename(), zip.get_hash(), true));
} catch (const ZipException& e) {
subsystem << e.what() << std::endl;
}
}
/* prepare all resources for quick accesses */
subsystem.set_scanlines_icon(get_icon("scanlines"));
prepare_resources();
} catch (const Exception& e) {
destroy_resources(false);
throw ResourcesException(e.what());
}
}
int
GGI_vnc_zlib(ggi_vnc_client *client, ggi_rect *update)
{
struct zlib_ctx_t *ctx = client->zlib_ctx;
ggi_vnc_buf tmp_buf;
/* fake it for the raw encoder so that it renders the update
* in an intermediate buffer
*/
tmp_buf = client->wbuf;
client->wbuf = ctx->wbuf;
client->wbuf.pos = client->wbuf.size = 0;
GGI_vnc_raw(client, update);
/* swap the buffers back */
ctx->wbuf = client->wbuf;
client->wbuf = tmp_buf;
/* change header to Zlib encoding */
ctx->wbuf.buf[11] = 6; /* Zlib */
/* copy the revised header to the real buffer */
GGI_vnc_buf_reserve(&client->wbuf, client->wbuf.size + 16);
memcpy(&client->wbuf.buf[client->wbuf.size], ctx->wbuf.buf, 12);
client->wbuf.size += 12;
/* zip up the intermediate buffer */
zip(client, &ctx->wbuf.buf[12], ctx->wbuf.size - 12);
return 1;
}
static int doSave(const QString &fileName)
{
KZip zip(fileName);
if (!zip.open(QIODevice::WriteOnly)) {
qWarning() << "Could not open" << fileName << "for writing";
return 1;
}
const QByteArray data = "This is the data for the main file";
bool writeOk = zip.writeFile(QStringLiteral("maindoc.txt"), data);
if (!writeOk) {
qWarning() << "Write error (main file)";
return 1;
}
const QByteArray data2 = "This is the data for the other file";
writeOk = zip.writeFile(QStringLiteral("subdir/other.txt"), data2);
if (!writeOk) {
qWarning() << "Write error (other file)";
return 1;
}
//writeOk = zip.addLocalFile("David.jpg", "picture.jpg");
//if (!writeOk) {
// qWarning() << "Write error (picture)";
// return 1;
//}
return 0;
}
void GEUIDialog::SaveViewAsKmz( wxString filename, wxString viewname )
{
//TODO: - kml, jpg, zip it
wxFileName fn(filename);
wxFFileOutputStream out(filename);
wxZipOutputStream zip(out);
double west, east, north, south, lat, lon, alt;
bool proj, exa;
GEGetPointOnTerrain(GE_SCR_UPCENTER, north, lon, alt, proj, exa);
GEGetPointOnTerrain(GE_SCR_LOWCENTER, south, lon, alt, proj, exa);
GEGetPointOnTerrain(GE_SCR_LEFTCENTER, lat, west, alt, proj, exa);
GEGetPointOnTerrain(GE_SCR_RIGHTCENTER, lat, east, alt, proj, exa);
wxString tempimg = wxFileName::CreateTempFileName(_T("gecomapi"));
SaveViewAsJPG(tempimg);
zip.PutNextEntry(wxString::Format(_T("files/%s.jpg"), fn.GetName()));
wxFileInputStream stream(tempimg);
zip.Write(stream);
zip.PutNextEntry(_T("doc.kml"));
wxCharBuffer buffer;
buffer = wxConvertWX2MB(wxString::Format(_T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><kml xmlns=\"http://www.opengis.net/kml/2.2\"><GroundOverlay><name>%s</name><Icon><href>files/%s.jpg</href><drawOrder>0</drawOrder></Icon><LatLonBox><north>%f</north><south>%f</south><east>%f</east><west>%f</west><rotation>%f</rotation></LatLonBox></GroundOverlay></kml>"), encodeXMLEntities(viewname), fn.GetName(), north, south, east, west, 0.0));
zip.Write(buffer.data(), strlen(buffer.data()));
wxRemoveFile(tempimg);
}
void KArchiveTest::testReadZipError()
{
QFile brokenZip(QStringLiteral("broken.zip"));
QVERIFY(brokenZip.open(QIODevice::WriteOnly));
// incomplete magic
brokenZip.write(QByteArray("PK\003"));
brokenZip.close();
{
KZip zip(QStringLiteral("broken.zip"));
QVERIFY(!zip.open(QIODevice::ReadOnly));
QCOMPARE(
zip.errorString(),
tr("Invalid ZIP file. Unexpected end of file. (Error code: %1)").arg(1));
QVERIFY(brokenZip.open(QIODevice::WriteOnly | QIODevice::Append));
// add rest of magic, but still incomplete header
brokenZip.write(QByteArray("\004\000\000\000\000"));
brokenZip.close();
QVERIFY(!zip.open(QIODevice::ReadOnly));
QCOMPARE(
zip.errorString(),
tr("Invalid ZIP file. Unexpected end of file. (Error code: %1)").arg(4));
}
QVERIFY(brokenZip.remove());
}
/**
* @brief Exports the portfolios to the archive.
* The portfolios must have been sets before with addPortfolios.
*/
void ExportManager::exportArchive() {
QuaZip zip(this->archivePath);
if(!zip.open(QuaZip::mdCreate)) {
throw ExportException("Cannot create archive "+this->archivePath+".");
}
QuaZipFile archivedFile(&zip);
// Adds the descriptor file in the archive:
QByteArray data = writeDescriptor();
if(!archivedFile.open(QIODevice::WriteOnly, QuaZipNewInfo("portfolios.json"))) {
throw ExportException("Cannot create descriptor file in archive.");
}
archivedFile.write(data);
archivedFile.close();
// Adds the reports and assets' files to the archive:
QDir resourcesFolder(SQLiteManager::getSessionFolder() + QDir::separator() + "Resources");
addToArchive(resourcesFolder, "Reports", archivedFile);
addToArchive(resourcesFolder, "Assets", archivedFile);
zip.close();
if(zip.getZipError() != 0) {
throw ExportException("Error while archiving ("+QString::number(zip.getZipError())+").");
}
}
void KArchiveTest::testZipMaxLength()
{
KZip zip( s_zipMaxLengthFileName );
QVERIFY( zip.open( QIODevice::WriteOnly ) );
// Similar to testTarMaxLength just to make sure, but of course zip doesn't have
// those limitations in the first place.
for (int i = 98; i < 514 ; i++ )
{
QString str, num;
str.fill( 'a', i-10 );
num.setNum( i );
num = num.rightJustified( 10, '0' );
zip.writeFile( str+num, "testu", "testg", "hum", 3 );
}
QVERIFY( zip.close() );
QVERIFY( zip.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = zip.directory();
QVERIFY( dir != 0 );
const QStringList listing = recursiveListEntries( dir, "", 0 );
QCOMPARE( listing[ 0], QString("mode=100644 path=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000098 type=file size=3") );
QCOMPARE( listing[ 3], QString("mode=100644 path=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000101 type=file size=3") );
QCOMPARE( listing[ 4], QString("mode=100644 path=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000102 type=file size=3") );
QCOMPARE( listing.count(), 514 - 98 );
QVERIFY( zip.close() );
}
void
FileStore::compressRide(RideFile*ride, QByteArray &data, QString name)
{
// compress via a temporary file
QTemporaryFile tempfile;
tempfile.open();
tempfile.close();
// write as json
QFile jsonFile(tempfile.fileName());
if (RideFileFactory::instance().writeRideFile(NULL, ride, jsonFile, "json") == true) {
// create a temp zip file
QTemporaryFile zipFile;
zipFile.open();
zipFile.close();
// add files using zip writer
QString zipname = zipFile.fileName();
ZipWriter writer(zipname);
// read the ride file back and add to zip file
jsonFile.open(QFile::ReadOnly);
writer.addFile(name, jsonFile.readAll());
jsonFile.close();
writer.close();
// now read in the zipfile
QFile zip(zipname);
zip.open(QFile::ReadOnly);
data = zip.readAll();
zip.close();
}
}
/// @brief Replaces good byte(s) with bad one(s), then implements ZIP
/// @return False on failure
bool Unzip() {
std::vector<unsigned char> bad_bytes = good_bytes;
std::fill_n(bad_bytes.begin() + offset, amount, byte);
std::string str(bad_bytes.begin(), bad_bytes.end());
i2p::util::ZIP zip(str, str.size());
return zip.Unzip();
}
/**OK
* Comprime il file fileName nel file fileCompressed.
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
* di creare.
*
* La funzione fallisce se:
* * non si riesce ad aprire l'oggetto zip;
* * la compressione del file fallisce;
* * non si riesce a chiudere l'oggetto zip;
*/
bool JlCompress::compressFile(QString fileCompressed, QString file)
{
// Creo lo zip
QuaZip zip(fileCompressed);
QDir().mkpath(QFileInfo(fileCompressed).absolutePath());
if(!zip.open(QuaZip::mdCreate))
{
QFile::remove(fileCompressed);
return false;
}
// Aggiungo il file
if(!compressFile(&zip, file, QFileInfo(file).fileName()))
{
QFile::remove(fileCompressed);
return false;
}
// Chiudo il file zip
zip.close();
if(zip.getZipError() != 0)
{
QFile::remove(fileCompressed);
return false;
}
return true;
}
void TestQuaZipDir::entryList()
{
QFETCH(QString, zipName);
QFETCH(QStringList, fileNames);
QFETCH(QString, dirName);
QFETCH(int, filter);
QFETCH(int, sort);
QDir::Filters filters = static_cast<QDir::Filters>(filter);
QDir::SortFlags sorting = static_cast<QDir::SortFlags>(sort);
QFETCH(QStringList, entries);
QDir curDir;
if (!createTestFiles(fileNames)) {
QFAIL("Couldn't create test files");
}
if (!createTestArchive(zipName, fileNames)) {
QFAIL("Couldn't create test archive");
}
removeTestFiles(fileNames);
QuaZip zip(zipName);
QVERIFY(zip.open(QuaZip::mdUnzip));
QuaZipDir dir(&zip, dirName);
QCOMPARE(dir.entryList(filters, sorting), entries);
zip.close();
curDir.remove(zipName);
}
void main()
{
int l1l2=100;
int array1[l1l2];
int array2[l1l2];
for (int i=0;i<l1l2;++i)
{
array1[i]=i*2;
//printf("a1=%d\n",array1[i]);testo il ciclo
}
int dispari=1;
for(int i=0;i<l1l2;++i)
{
array2[i]=dispari;
dispari +=2;
//printf("a2=%d\n",array2[i]);testo ilciclo
}
int lena1 = sizeof(array1)/sizeof(int);
int len=lena1*2;
int arraymix[len];
zip(array1,array2,arraymix,lena1);
for(int i=0;i<len;++i)
{
printf("[%d] arraymix=%d\n",i,arraymix[i]);
}
}
void tst_QZip::basicUnpack()
{
QZipReader zip(QString(SRCDIR) + "/testdata/test.zip", QIODevice::ReadOnly);
QList<QZipReader::FileInfo> files = zip.fileInfoList();
QCOMPARE(files.count(), 2);
QZipReader::FileInfo fi = files.at(0);
QVERIFY(fi.isValid());
QCOMPARE(fi.filePath, QString("test/"));
QCOMPARE(uint(fi.isDir), (uint) 1);
QCOMPARE(uint(fi.isFile), (uint) 0);
QCOMPARE(uint(fi.isSymLink), (uint) 0);
QCOMPARE(fi.permissions,QFile::Permissions( QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner
| QFile::ReadUser | QFile::WriteUser | QFile::ExeUser ));
QCOMPARE(fi.lastModified, QDateTime::fromString("2005.11.11 13:08:02", "yyyy.MM.dd HH:mm:ss"));
fi = files.at(1);
QVERIFY(fi.isValid());
QCOMPARE(fi.filePath, QString("test/test.txt"));
QCOMPARE(uint(fi.isDir), (uint) 0);
QCOMPARE(uint(fi.isFile), (uint) 1);
QCOMPARE(uint(fi.isSymLink), (uint) 0);
QVERIFY(fi.permissions == QFile::Permissions( QFile::ReadOwner | QFile::WriteOwner
| QFile::ReadUser | QFile::WriteUser ));
QCOMPARE(fi.lastModified, QDateTime::fromString("2005.11.11 13:08:02", "yyyy.MM.dd HH:mm:ss"));
QCOMPARE(zip.fileData("test/test.txt"), QByteArray("content\n"));
fi = files.at(-1);
QVERIFY(!fi.isValid());
}
void CamuleDlg::Add_Skin_Icon(
const wxString &iconName,
const wxBitmap &stdIcon,
bool useSkins)
{
wxImage new_image;
if (useSkins) {
wxFFileInputStream in(m_skinFileName.GetFullPath());
wxZipInputStream zip(in);
ZipCatalog::iterator it = cat.find(wxZipEntry::GetInternalName(iconName + wxT(".png")));
if ( it != cat.end() ) {
zip.OpenEntry(*it->second);
if ( !new_image.LoadFile(zip,wxBITMAP_TYPE_PNG) ) {
AddLogLineN(wxT("Warning: Error loading icon for ") +
iconName);
useSkins = false;
}
}else {
AddLogLineN(wxT("Warning: Can't load icon for ") +
iconName);
useSkins = false;
}
}
wxBitmap bmp(useSkins ? new_image : stdIcon);
if (iconName.StartsWith(wxT("Client_"))) {
m_imagelist.Add(bmp);
} else if (iconName.StartsWith(wxT("Toolbar_"))) {
m_tblist.Add(bmp);
}
}
QByteArray Expansions::open(QString path)
{
bool found = false;
QByteArray arr;
foreach(auto &zipFile, zips)
{
if(found)
{
break;
}
QuaZip zip(zipFile);
if(zip.open(QuaZip::mdUnzip))
{
if(zip.setCurrentFile(path))
{
QuaZipFile file(&zip);
if(file.open(QIODevice::ReadOnly))
{
found = true;
arr = file.readAll();
}
file.close();
}
zip.close();
}
}
return arr;
}
bool wxcHelper::ExtractFileFromZip(const wxString& zipPath, const wxString& filename, const wxString& targetDir, wxString &targetFileName)
{
wxZipEntry * entry(NULL);
wxFFileInputStream in(zipPath);
wxZipInputStream zip(in);
// Make sure the target directory exists...
wxFileName::Mkdir(targetDir, 0777, wxPATH_MKDIR_FULL);
entry = zip.GetNextEntry();
while ( entry ) {
wxString name = entry->GetName();
if (name == filename) {
targetFileName = wxFileName(targetDir, filename).GetFullPath();
wxFFileOutputStream out( targetFileName );
zip.Read(out);
out.Close();
delete entry;
return true;
}
wxDELETE(entry);
entry = zip.GetNextEntry();
}
return false;
}
void UBExportDocument::persistsDocument(UBDocumentProxy* pDocumentProxy, QString filename)
{
UniboardSankoreTransition document;
QString documentPath(pDocumentProxy->persistencePath());
document.checkDocumentDirectory(documentPath);
QuaZip zip(filename);
zip.setFileNameCodec("UTF-8");
if(!zip.open(QuaZip::mdCreate))
{
qWarning("Export failed. Cause: zip.open(): %d", zip.getZipError());
return;
}
QDir documentDir = QDir(pDocumentProxy->persistencePath());
QuaZipFile outFile(&zip);
UBFileSystemUtils::compressDirInZip(documentDir, "", &outFile, true, this);
if(zip.getZipError() != 0)
{
qWarning("Export failed. Cause: zip.close(): %d", zip.getZipError());
}
zip.close();
UBPlatformUtils::setFileType(filename, 0x5542647A /* UBdz */);
}
static int doPrintAll(const QString &fileName)
{
KZip zip(fileName);
qDebug() << "Opening zip file";
if (!zip.open(QIODevice::ReadOnly)) {
qWarning() << "Could not open" << fileName << "for reading. ZIP file doesn't exist or is invalid.";
return 1;
}
const KArchiveDirectory *dir = zip.directory();
qDebug() << "Listing toplevel of zip file";
foreach (const QString &it, dir->entries()) {
const KArchiveEntry *e = dir->entry(it);
qDebug() << "Printing" << it;
if (e->isFile()) {
Q_ASSERT(e && e->isFile());
const KArchiveFile *f = static_cast<const KArchiveFile *>(e);
const QByteArray data(f->data());
printf("SIZE=%i\n", data.size());
QString str = QString::fromUtf8(data);
printf("DATA=%s\n", qPrintable(str));
}
}
zip.close();
return 0;
}
void KArchiveTest::testCreateZip()
{
KZip zip( s_zipFileName );
QVERIFY( zip.open( QIODevice::WriteOnly ) );
zip.setExtraField( KZip::NoExtraField );
zip.setCompression( KZip::NoCompression );
QByteArray zipMimeType( s_zipMimeType );
zip.writeFile( "mimetype", "", "", zipMimeType.data(), zipMimeType.size() );
zip.setCompression( KZip::DeflateCompression );
writeTestFilesToArchive( &zip );
QVERIFY( zip.close() );
QFile zipFile( QFile::encodeName( s_zipFileName ) );
QFileInfo fileInfo( zipFile );
QVERIFY( fileInfo.exists() );
QVERIFY( fileInfo.size() > 300 );
// Check that the header with no-compression and no-extrafield worked.
// (This is for the "magic" for koffice documents)
QVERIFY( zipFile.open( QIODevice::ReadOnly ) );
QByteArray arr = zipFile.read( 4 );
QCOMPARE( arr, QByteArray( "PK\003\004" ) );
QVERIFY( zipFile.seek( 30 ) );
arr = zipFile.read( 8 );
QCOMPARE( arr, QByteArray( "mimetype" ) );
arr = zipFile.read( zipMimeType.size() );
QCOMPARE( arr, zipMimeType );
}
void SaveDialog::OnBotonGuardarCopy(wxCommandEvent& event)
{
wxFileDialog* openfile = new wxFileDialog(this,wxT("Guardar partida"),wxT(""),wxT(""),wxT("Azpazeta Save Files|*.azp"),wxFD_SAVE);
openfile->ShowModal();
// the user changed idea...
// save the current contents in the file;
// this can be done with e.g. wxWidgets output streams:
/*FILE* partida_guardar;
partida_guardar=fopen(openfile->GetPath().c_str(),"w");
fprintf(partida_guardar,"Azpazeta_Save_File_v.1.0:MONEY=%d:CITY=%d:MISION=%d:AUX=%d:DROGA=%d:SOBORNO=%d:BLACKLIST=%d:\n",money, city, mision, aux, droga, sobornos, blacklist);
fclose(partida_guardar);*/
//wxFileSystem::AddHandler(new wxZipFSHandler);
wxFFileOutputStream out(openfile->GetPath()+".azp");
wxZipOutputStream zip(out);
wxTextOutputStream txt(zip);
wxString sep(wxFileName::GetPathSeparator());
char datosparaguardar[2048];
zip.PutNextEntry(wxT("AZPGeneral.txt"));
sprintf(datosparaguardar,"Azpazeta_Save_File_v.1.0:MONEY=%d:CITY=%d:MISION=%d:AUX=%d:DROGA=%d:SOBORNO=%d:BLACKLIST=%d:SOCIO=%d:ELECTRO=%d:FOOD=%d:TEXTIL=%d:RICH=%d:PRIMA=%d:\n",money, city, mision, aux, droga, sobornos, blacklist, socio, electro, food, textil,rich,prima);
txt << datosparaguardar;
zip.PutNextEntry(wxT("SERVER-DATA")+ sep+ wxT("lastservers.txt"));
zip.PutNextEntry(wxT("META-DATA") + sep + wxT("INFO.txt"));
txt << wxT("Hi, this is the user information\n");
this->Destroy();
}
void KArchiveTest::testZipWithNonLatinFileNames()
{
KZip zip( s_zipLocaleFileName );
QVERIFY( zip.open( QIODevice::WriteOnly ) );
const QByteArray fileData("Test of data with a russian file name");
const QString fileName = QString::fromUtf8( "Архитектура.okular" );
const QString recodedFileName = QFile::decodeName( QFile::encodeName( fileName ) );
QVERIFY( zip.writeFile( fileName, "pino", "users", fileData.constData(), fileData.size() ) );
QVERIFY( zip.close() );
QVERIFY( zip.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = zip.directory();
QVERIFY( dir != 0 );
const QStringList listing = recursiveListEntries( dir, "", 0 );
QCOMPARE( listing.count(), 1 );
QCOMPARE( listing[0], QString::fromUtf8("mode=100644 path=%1 type=file size=%2").arg(recodedFileName).arg(fileData.size()) );
const KArchiveFile* fileEntry = static_cast< const KArchiveFile* >( dir->entry( dir->entries()[0] ) );
QCOMPARE( fileEntry->data(), fileData );
}
void run_stream()
{
std::vector<int> a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
auto m = make_stream(a);
float total = m.reduce(0.f, [](float acc, const int x) {
return acc + x;
});
std::cout << total << "\n";
auto filtered = m.filter([](int i) { return i >= 5; });
filtered.for_each([](int i) { std::cout << i << " "; });
std::cout << "\n";
std::vector<char> b = { 'a', 'b', 'c', 'd', 'e', 'f' };
auto result1 = m.zip(b);
auto result2 = make_stream(b).zip(a);
auto result3 = m.to_container();
auto result4 = m.to_container<std::list>();
auto result5 = make_stream(b)
.sorted([](int i, int j) { return j < i; })
.to_container();
}
void SaveDialog::OnBotonGuardarStd(wxCommandEvent& event)
{
//FILE* partida_guardar;
//partida_guardar=fopen("/usr/share/Azpazeta/save/save.azp","w");
/*fprintf(partida_guardar,"Azpazeta_Save_File_v.1.0:MONEY=%d:CITY=%d:MISION=%d:AUX=%d:DROGA=%d:SOBORNO=%d:BLACKLIST=%d:\n",money, city, mision, aux, droga, sobornos, blacklist);
fclose(partida_guardar);*/
//Nuevo sistema de partidas
char *home;
home=getenv("HOME");
wxString pathgeneral=wxString::Format("mkdir -p %s/.azpazeta",home);
system(pathgeneral.c_str());
wxString pathguardar=wxString::Format("%s/.azpazeta/save.azp",home);
wxFFileOutputStream out(pathguardar);
wxZipOutputStream zip(out);
wxTextOutputStream txt(zip);
wxString sep(wxFileName::GetPathSeparator());
char datosparaguardar[2048];
zip.PutNextEntry(wxT("AZPGeneral.txt"));
sprintf(datosparaguardar,"Azpazeta_Save_File_v.1.0:MONEY=%d:CITY=%d:MISION=%d:AUX=%d:DROGA=%d:SOBORNO=%d:BLACKLIST=%d:SOCIO=%d:ELECTRO=%d:FOOD=%d:TEXTIL=%d:RICH=%d:PRIMA=%d:\n",money, city, mision, aux, droga, sobornos, blacklist, socio, electro, food, textil,rich,prima);
txt << datosparaguardar;
zip.PutNextEntry(wxT("SERVER-DATA")+ sep+ wxT("lastservers.txt"));
zip.PutNextEntry(wxT("META-DATA") + sep + wxT("INFO.txt"));
txt << wxT("Hi, this is the user information\n");
this->Destroy();
}
void KArchiveTest::testZipWithOverwrittenFileName()
{
KZip zip(s_zipFileName);
QVERIFY(zip.open(QIODevice::WriteOnly));
const QByteArray fileData1("There could be a fire, if there is smoke.");
const QString fileName = QStringLiteral("wisdom");
QVERIFY(zip.writeFile(fileName, fileData1, 0100644, "konqi", "dragons"));
// now overwrite it
const QByteArray fileData2("If there is smoke, there could be a fire.");
QVERIFY(zip.writeFile(fileName, fileData2, 0100644, "konqi", "dragons"));
QVERIFY(zip.close());
QVERIFY(zip.open(QIODevice::ReadOnly));
const KArchiveDirectory *dir = zip.directory();
QVERIFY(dir != nullptr);
const QStringList listing = recursiveListEntries(dir, QLatin1String(""), 0);
QCOMPARE(listing.count(), 1);
QCOMPARE(listing[0], QString::fromUtf8("mode=100644 path=%1 type=file size=%2").arg(fileName).arg(fileData2.size()));
const KArchiveFile *fileEntry = static_cast< const KArchiveFile *>(dir->entry(dir->entries()[0]));
QCOMPARE(fileEntry->data(), fileData2);
}
bool UBExportDocumentSetAdaptor::persistData(const QModelIndex &pRootIndex, QString filename)
{
UBPersistenceManager *persistenceManager = UBPersistenceManager::persistenceManager();
UBDocumentTreeModel *treeModel = persistenceManager->mDocumentTreeStructureModel;
QModelIndex index = pRootIndex;
if (!index.isValid()) {
return false;
}
QuaZip zip(filename);
zip.setFileNameCodec("UTF-8");
if(!zip.open(QuaZip::mdCreate))
{
qWarning("Export failed. Cause: zip.open(): %d", zip.getZipError());
return false;
}
if (!addDocumentToZip(pRootIndex, treeModel, zip)) {
zip.close();
return false;
}
zip.close();
UBPlatformUtils::setFileType(filename, 0x5542647A /* UBdz */);
return true;
}
/**
* @dataProvider testZipReadRedundantDataDescriptor_data
*/
void KArchiveTest::testZipReadRedundantDataDescriptor()
{
QFETCH(QString, fileName);
const QString redundantDataDescriptorZipFileName = QFINDTESTDATA(fileName);
QVERIFY(!redundantDataDescriptorZipFileName.isEmpty());
KZip zip(redundantDataDescriptorZipFileName);
QVERIFY(zip.open(QIODevice::ReadOnly));
const KArchiveDirectory *dir = zip.directory();
QVERIFY(dir != nullptr);
const QByteArray fileData("aaaaaaaaaaaaaaa");
// ZIP has no support for per-file user/group, so omit them from the listing
const QStringList listing = recursiveListEntries(dir, QLatin1String(""), 0);
QCOMPARE(listing.count(), 2);
QCOMPARE(listing[0], QString::fromUtf8("mode=100644 path=compressed type=file size=%2").arg(fileData.size()));
QCOMPARE(listing[1], QString::fromUtf8("mode=100644 path=uncompressed type=file size=%2").arg(fileData.size()));
const KArchiveFile *fileEntry = static_cast< const KArchiveFile *>(dir->entry(dir->entries()[0]));
QCOMPARE(fileEntry->data(), fileData);
fileEntry = static_cast< const KArchiveFile *>(dir->entry(dir->entries()[1]));
QCOMPARE(fileEntry->data(), fileData);
}
