I have jar foo.jar which contains jar foo/config/baar-temp.jar.
What is the best method to rename baar-temp.jar to baar.jar?
Actually, jar format is based on zip and can be operated on as a file system using for example ZipFileSystemProvider available in Java7. That allows us to do a rather simple manipulation with the insides of one:
private void renameStuffInsideJar(String jarFilePath){
URI uri = URI.create("jar:file:"+jarFilePath);
try {
FileSystem jarFile = FileSystems.getFileSystem(uri)) {
Path pathInJarfile = jarFile.getPath("foo/config/baar-temp.jar");
Files.move(pathInZipfile,pathInZipfile.resolveSibling("baar.jar"));
} catch(IOException e){
//TODO
}
}
Alternatively, if it's not code you want, you could just open your jar file in your preferred archive manager like 7zip or WinRar and rename it using that.
I have to write the script in Gradle and I therefore have some questions.
The script must unpack the .ear file, and then included in the jar, then edit the content and save as ear (text file> jar> ear.)
1) Firstly, I would like to learn how to save a file to the current directory.
(The following code saves the file to another folder.)
task unzip(type: Copy) {
def zipFile = file('C:/Test/file.ear')
def outputDir = file('jar')
from zipTree(zipFile)
into getDestDir()
}
Phrases such as '.', '/' don't work.
2)Secondly, I would like to ask how to unpack the jar file because I can't unpack the above method. (It works only to the EAR)
3)At the end I would ask how you can convert the edited text file on the jar, and then on ear (without dependencies and manifest).
Because the resulting file do I have to file .ear
Thank you in advance for your answer.
You don't want to be writing files into your working directory. All the work should be done under the $buildDir.
A standard method is to set your into directory to a temporary location:
task myTask(type: Copy) {
from 'my/dir/'
into temporaryDir
}
You can unpack a JAR or ZIP file like so:
copy {
from zipTree('path/tozip.zip')
into temporaryDir
}
I made a pretty simple application with Qt Creator on Ubuntu 12.04. The application reads an xml-file and shows a couple of images. But when I try to start the application by double clicking the icon on a different machine (running Lubuntu), the images are not shown, and the xml-file is not read. The application does work properly when it is started from the command line by typing ./App.
Why does it behave like this and how do I fix it?
edit: The method that reads the xml:
QDomDocument doc("document");
QString path = "datastorage.xml"; // xml is in same directory as the executable
QFile xmlFile(path);
if (!xmlFile.open(QIODevice::ReadOnly))
throw QString("Error with XML: Could not open file " + path);
if (!doc.setContent(&xmlFile)) {
xmlFile.close();
throw QString("Error with XML: Could not set QDomDocument content from " + path);
}
xmlFile.close();
QDomElement root = doc.documentElement();
return root;
Simply you are using relative paths to read files and those paths are always relative to "working directory". If you're launching your app from console, and all required files are within app directory then everything works. When launching from desktop working directory may be different. Just prepend QCoreApplication::applicationDirPath() to all paths you're using.
I'm using QSettings to store some data as ini file in Windows.
I want to see the ini file, but I don't know what is the location of the ini file.
This is my code:
QSettings *set = new QSettings(QSettings::IniFormat, QSettings::UserScope, "bbb", "aaa");
set->setValue("size", size());
set->setValue("pos", pos());
Where do I have to look? Or may be I miss the code which write it to the file?
When does the QSettings write its values?
To print out the exact location of your settings file use method fileName method of QSettings class.
QSettings settings("folderName", "fileName");
qDebug() << settings.fileName();
Console output looks then like:
/home/user/.config/folderName/fileName.conf
I think you'll find everything you're looking for here : http://doc.qt.io/archives/qt-4.7/qsettings.html
It's plateform specific, see under :
Platform-Specific Notes
Locations Where Application Settings Are Stored
You can store Settings in files as well :
QSettings settings("/home/petra/misc/myapp.ini",
QSettings::IniFormat);
QSettings save location changes to the QSettings.Scope enum. QSettings save to the Local scope by default. On Linux, I found my local settings in:
~/.config/CompanyName/ApplicationName.conf
If you create a QSettings without giving any specific path, the ini file will be located in the application path.
QSettings Settings("myapp.ini", QSettings::IniFormat);
Settings.setValue("Test", "data");
//...
qDebug() << QApplication::applicationDirPath();
Be careful though : the application path might change : for instance, if you are developping your app with Qt Creator, in debug mode, the application path is in the /debug subfolder.
If you are running it in release mode, the application path is in the /release subfolder.
And when your application is deployed, by default, the application path is in the same folder as the executable (at least for Windows).
Check out the QStandardPaths class, it links to multiple standard paths including configuration on all supported platforms. https://doc.qt.io/qt-5/qstandardpaths.html
QT >= 5.5:
QString path = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);
QT < 5.5:
QString path = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation);
There are paths for config files in shared config directories, application data directories, and more.
In linux you can use this snippet or insert this lines into your main code for find location of your file with python.
from PyQt5.QtCore import QSettings
settings = QSettings("Organization Name", "App name")
print(QSettings.fileName(settings))
It should return an output like this.
/$HOME/.config/Organization Name/App name.conf
Source
in windows path is like below:
C:\Users\user_name\AppData\Roaming\bbb
On Mac OSX, I found the file under at ~/Library/Preferences
The QSettings class provides persistent platform-independent application settings.
Users normally expect an application to remember its settings (window sizes and positions, options, etc.) across sessions. This information is often stored in the system registry on Windows, and in XML preferences files on Mac OS X. On Unix systems, in the absence of a standard, many applications (including the KDE applications) use INI text files
http://doc.qt.io/archives/qt-4.7/qsettings.html
On Windows without providing an ini filename, you'll find the data in the registry.
Using this code snippet:
int red = color.red();
int green = color.green();
int blue = color.blue();
QSettings settings("Joe", "SettingsDemo");
qDebug() << settings.fileName();
settings.beginGroup("ButtonColor");
settings.setValue("button1r", red);
settings.setValue("button1g", green);
settings.setValue("button1b", blue);
settings.endGroup();
After running this code, you'll see the output:
"\\HKEY_CURRENT_USER\\Software\\Joe\\SettingsDemo"
Now, opening the regedit tool and following the path list you got: 1
I am a Qt beginner and just got stuck with the problem. I am looking for a file SomePath/NewDirectoryA/NewFile.kml (NewFile.kml will be the only file in NewDirectoryA, having this directory just to maintain semantics in the project).
If SomePath/NewDirectoryA/NewFile.kml exists then I will use it in my code and if it doesn't exist then I have to create it. If this File doesn't exist then this directory also doesn't exist in SomePath. So If only I have to create a file I can use QFile and open it in ReadWrite or WriteOnly mode.
But the problem is I have to create the file with the directory itself.
I tried with QFile with file name SomePath/NewDirectoryA/NewFile.kml but it didn't worked.
Please suggest me a way in which I can create a new file (NewFile.kml) in a new directory (NewDirectorA) at a given location (SomePath).
bool QFile::open ( OpenMode mode ) [virtual]
[...]
Note: In WriteOnly or ReadWrite mode,
if the relevant file does not already
exist, this function will try to
create a new file before opening it.
Qt's caveat for file creation
Platform Specific Issues
File permissions are handled differently on Unix-like systems and
Windows. In a non writable directory on Unix-like systems, files
cannot be created. This is not always the case on Windows, where, for
instance, the 'My Documents' directory usually is not writable, but it
is still possible to create files in it.
Directories are created with
bool
QDir::mkdir
( const QString & dirName ) const
Creates a sub-directory called
dirName.
and
bool QDir::mkpath
( const QString & dirPath ) const
Creates the directory path dirPath.
The function will create all parent
directories necessary to create the
directory.
AFAIK it is not possible to create the file and the directory directly with QFile. You have to first create the directory (QDir::mkpath will create the full path) and then the file (QFile::open).
QString path("SomePath/NewDirectoryA/");
QDir dir; // Initialize to the desired dir if 'path' is relative
// By default the program's working directory "." is used.
// We create the directory if needed
if (!dir.exists(path))
dir.mkpath(path); // You can check the success if needed
QFile file(path + "NewFile.kml");
file.open(QIODevice::WriteOnly); // Or QIODevice::ReadWrite