const QSet<Utf8String> Document::dependedFilePaths() const
{
checkIfNull();
checkIfFileExists();
return d->dependedFilePaths;
}
void SyncConnector::spawnSyncthingProcess(
const QString& filePath, const bool shouldSpawn, const bool onSetPath)
{
mSyncthingFilePath = filePath;
if (shouldSpawn)
{
if (!checkIfFileExists(filePath) && onSetPath)
{
QMessageBox msgBox;
msgBox.setText("Could not find Syncthing.");
msgBox.setInformativeText("Are you sure the path is correct?");
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.exec();
}
if (!systemUtil.isBinaryRunning(std::string("syncthing")))
{
mpSyncProcess = std::unique_ptr<QProcess>(new QProcess(this));
connect(mpSyncProcess.get(), SIGNAL(stateChanged(QProcess::ProcessState)),
this, SLOT(syncThingProcessSpawned(QProcess::ProcessState)));
QString processPath = QDir::toNativeSeparators(filePath);
QStringList launchArgs;
launchArgs << "-no-browser";
mpSyncProcess->start(processPath, launchArgs);
}
else
{
emit(onProcessSpawned({{kSyncthingIdentifier, ProcessState::ALREADY_RUNNING}}));
}
}
}
rapp_platform_ros_communications::ontologyLoadDumpSrv::Response KnowrobWrapper::dumpOntologyQuery(rapp_platform_ros_communications::ontologyLoadDumpSrv::Request req)
{
rapp_platform_ros_communications::ontologyLoadDumpSrv::Response res;
std::string path = getenv("HOME");
path=path+std::string("/rapp_platform_files/");
if(req.file_url.empty()) // || req.file_url==std::string("")
{
res.success=false;
res.trace.push_back(std::string("Empty file path"));
res.trace.push_back(req.file_url);
res.error=std::string("Empty file path");
return res;
}
size_t pathDepth = std::count(req.file_url.begin(), req.file_url.end(), '/');
std::string str2 ("/");
std::size_t found = req.file_url.find(str2);
if (found!=std::string::npos && pathDepth>1)
{
std::string folderFromPath=SplitFilename(req.file_url);
const char * c = folderFromPath.c_str();
if(!checkIfFileExists(c))
{
res.success=false;
res.trace.push_back(std::string("Path does not exist, invalid folder?"));
res.trace.push_back(req.file_url);
res.error=std::string("Path does not exist, invalid folder?");
return res;
}
}
req.file_url=path+req.file_url;
std::string query = std::string("rdf_save('") + req.file_url + std::string("')");
json_prolog::PrologQueryProxy results = pl.query(query.c_str());
char status = results.getStatus();
if(status==0)
{
res.success=false;
//std_msgs::String temp_std_msgs_string;
//temp_std_msgs_string.data=std::string("Ontology dump failed");
res.trace.push_back(std::string("Ontology dump failed"));
res.error=std::string("Ontology dump failed");
return res;
}
else if(status==3)
{
res.success=true;
}
return res;
}
TranslationUnit::TranslationUnit(const Utf8String &filePath,
const ProjectPart &projectPart,
TranslationUnits &translationUnits,
FileExistsCheck fileExistsCheck)
: d(std::make_shared<TranslationUnitData>(filePath, projectPart, translationUnits))
{
if (fileExistsCheck == CheckIfFileExists)
checkIfFileExists();
}
CXTranslationUnit TranslationUnit::cxTranslationUnitWithoutReparsing() const
{
checkIfNull();
checkIfFileExists();
removeTranslationUnitIfProjectPartWasChanged();
createTranslationUnitIfNeeded();
return d->translationUnit;
}
bool CommonFunctions::copyFile(QString file) {
QFileInfo fileInfo(file);
if (checkIfFileExists(fileInfo)) {
return true;
} else {
if (createDirectoryIfNotExists(fileInfo.dir())) {
return QFile::copy(":/App/assets/database/database.db", file);
} else {
return false;
}
}
}
Document::Document(const Utf8String &filePath,
const ProjectPart &projectPart,
const Utf8StringVector &fileArguments,
Documents &documents,
FileExistsCheck fileExistsCheck)
: d(std::make_shared<DocumentData>(filePath,
projectPart,
fileArguments,
documents))
{
if (fileExistsCheck == FileExistsCheck::Check)
checkIfFileExists();
}
rapp_platform_ros_communications::ontologyLoadDumpSrv::Response KnowrobWrapper::loadOntologyQuery(rapp_platform_ros_communications::ontologyLoadDumpSrv::Request req)
{
rapp_platform_ros_communications::ontologyLoadDumpSrv::Response res;
if(req.file_url.empty()) // || req.file_url==std::string("")
{
res.success=false;
res.trace.push_back(std::string("Empty file path"));
res.trace.push_back(req.file_url);
res.error=std::string("Empty file path");
return res;
}
//std::string path = ros::package::getPath("rapp_knowrob_wrapper");
std::string path = getenv("HOME");
path=path+std::string("/rapp_platform_files/");
req.file_url=path+req.file_url;
const char * c = req.file_url.c_str();
if(!checkIfFileExists(c))
{
res.success=false;
res.trace.push_back(std::string("File does not exist in provided file path: '")
+ std::string(req.file_url) + std::string("'"));
res.trace.push_back(req.file_url);
res.error=std::string("File does not exist in provided file path: '"
+ std::string(req.file_url) + std::string("'"));
return res;
}
std::string query = std::string("rdf_load('") + req.file_url + std::string("')");
json_prolog::PrologQueryProxy results = pl.query(query.c_str());
char status = results.getStatus();
if(status==0)
{
res.success=false;
//std_msgs::String temp_std_msgs_string;
//temp_std_msgs_string.data=std::string("Ontology dump failed");
res.trace.push_back(std::string("Ontology load failed"));
res.error=std::string("Ontology load failed");
return res;
}
else if(status==3)
{
res.success=true;
}
return res;
}
void SyncConnector::checkAndSpawnINotifyProcess(bool isRequestedExternal)
{
if (isRequestedExternal)
{
onSettingsChanged();
if (mpSyncthingNotifierProcess)
{
mpSyncthingNotifierProcess->terminate();
}
}
if (mShouldLaunchINotify)
{
if (!checkIfFileExists(mINotifyFilePath) && isRequestedExternal)
{
QMessageBox msgBox;
msgBox.setText("Could not find iNotify.");
msgBox.setInformativeText("Are you sure the path is correct?");
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.exec();
}
if (!systemUtil.isBinaryRunning(std::string("syncthing-inotify")))
{
mpSyncthingNotifierProcess = std::unique_ptr<QProcess>(new QProcess(this));
QString processPath = QDir::toNativeSeparators(mINotifyFilePath);
connect(mpSyncthingNotifierProcess.get(), SIGNAL(stateChanged(QProcess::ProcessState)),
this, SLOT(notifyProcessSpawned(QProcess::ProcessState)));
mpSyncthingNotifierProcess->start(processPath, QStringList(), QIODevice::Unbuffered);
}
else
{
emit(onProcessSpawned({{kNotifyIdentifier, ProcessState::ALREADY_RUNNING}}));
}
}
else
{
shutdownINotifyProcess();
}
}
int bandageImage(QStringList arguments)
{
QTextStream out(stdout);
QTextStream err(stderr);
if (checkForHelp(arguments))
{
printImageUsage(&out, false);
return 0;
}
if (checkForHelpAll(arguments))
{
printImageUsage(&out, true);
return 0;
}
if (arguments.size() < 2)
{
printImageUsage(&err, false);
return 1;
}
QString graphFilename = arguments.at(0);
arguments.pop_front();
if (!checkIfFileExists(graphFilename))
{
err << "Bandage error: " << graphFilename << " does not exist" << endl;
return 1;
}
QString imageSaveFilename = arguments.at(0);
arguments.pop_front();
QString imageFileExtension = imageSaveFilename.right(4);
bool pixelImage;
if (imageFileExtension == ".png" || imageFileExtension == ".jpg")
pixelImage = true;
else if (imageFileExtension == ".svg")
pixelImage = false;
else
{
err << "Bandage error: the output filename must end in .png, .jpg or .svg" << endl;
return 1;
}
QString error = checkForInvalidImageOptions(arguments);
if (error.length() > 0)
{
err << "Bandage error: " << error << endl;
return 1;
}
bool loadSuccess = g_assemblyGraph->loadGraphFromFile(graphFilename);
if (!loadSuccess)
{
err << "Bandage error: could not load " << graphFilename << endl;
return 1;
}
int width = 0;
int height = 0;
parseImageOptions(arguments, &width, &height);
//For Bandage image, it is necessary to position node labels at the
//centre of the node, not the visible centre(s). This is because there
//is no viewport.
g_settings->positionTextNodeCentre = true;
//Since frame rate performance doesn't matter for a fixed image, set the
//default node outline to a nonzero value.
g_settings->outlineThickness = 0.3;
bool blastUsed = isOptionPresent("--query", &arguments);
if (blastUsed)
{
if (!createBlastTempDirectory())
{
err << "Error creating temporary directory for BLAST files" << endl;
return 1;
}
QString blastError = g_blastSearch->doAutoBlastSearch();
if (blastError != "")
{
err << blastError << endl;
return 1;
}
}
QString errorTitle;
QString errorMessage;
std::vector<DeBruijnNode *> startingNodes = g_assemblyGraph->getStartingNodes(&errorTitle, &errorMessage,
g_settings->doubleMode,
g_settings->startingNodes,
"all");
if (errorMessage != "")
{
err << errorMessage << endl;
return 1;
}
g_assemblyGraph->buildOgdfGraphFromNodesAndEdges(startingNodes, g_settings->nodeDistance);
g_assemblyGraph->layoutGraph();
MyGraphicsScene scene;
g_assemblyGraph->addGraphicsItemsToScene(&scene);
scene.setSceneRectangle();
double sceneRectAspectRatio = scene.sceneRect().width() / scene.sceneRect().height();
//Determine image size
//If neither height nor width set, use a default of height = 1000.
if (height == 0 && width == 0)
height = 1000;
//If only height or width is set, scale the other to fit.
if (height > 0 && width == 0)
width = height * sceneRectAspectRatio;
else if (height == 0 && width > 0)
height = width / sceneRectAspectRatio;
bool success = true;
QPainter painter;
if (pixelImage)
{
QImage image(width, height, QImage::Format_ARGB32);
image.fill(Qt::white);
painter.begin(&image);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::TextAntialiasing);
scene.render(&painter);
success = image.save(imageSaveFilename);
painter.end();
}
else //SVG
{
QSvgGenerator generator;
generator.setFileName(imageSaveFilename);
generator.setSize(QSize(width, height));
generator.setViewBox(QRect(0, 0, width, height));
painter.begin(&generator);
painter.fillRect(0, 0, width, height, Qt::white);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::TextAntialiasing);
scene.render(&painter);
painter.end();
}
int returnCode;
if (!success)
{
out << "There was an error writing the image to file." << endl;
returnCode = 1;
}
else
returnCode = 0;
if (blastUsed)
deleteBlastTempDirectory();
return returnCode;
}
rapp_platform_ros_communications::createCognitiveExerciseTestSrv::Response KnowrobWrapper::create_cognitve_tests(rapp_platform_ros_communications::createCognitiveExerciseTestSrv::Request req)
{
rapp_platform_ros_communications::createCognitiveExerciseTestSrv::Response res;
if(req.test_type==std::string("") || req.test_difficulty<1 || req.test_path==std::string("") || req.test_subtype==std::string(""))
{
res.success=false;
res.trace.push_back("Error, one or more arguments not provided or out of range. Test variation and test difficulty are positive integers >0");
res.error=std::string("Error, one or more arguments not provided or out of range. Test variation and test difficulty are positive integers >0");
return res;
}
std::string path = ros::package::getPath("rapp_cognitive_exercise");
//res.trace.push_back(path);
//req.test_path=path+req.test_path;
std::string temp_check_path=path+req.test_path;
const char * c = temp_check_path.c_str();
if(!checkIfFileExists(c))
{
res.success=false;
res.trace.push_back(std::string("Test file does not exist in provided file path"));
res.trace.push_back(req.test_path);
res.error=std::string("Test file does not exist in provided file path");
return res;
}
//std::string variation = intToString(req.test_variation);
std::string difficulty = intToString(req.test_difficulty);
//res.trace.push_back(variation);
//res.trace.push_back(difficulty);
//return res;
std::string query = std::string("createCognitiveTest(knowrob:'")+req.test_type+std::string("',B,'")+difficulty+std::string("','")+req.test_path+std::string("',knowrob:'")+req.test_subtype+std::string("')");
json_prolog::PrologQueryProxy results = pl.query(query.c_str());
char status = results.getStatus();
if(status==0)
{
res.success=false;
//res.trace.push_back(std::string("Test type/subtype combination invalid. Either test type does not exist, or test sub type does not exist or if they exist the subtype does not correspond to the type"));
//res.error=std::string("Test type/subtype combination invalid. Either test type does not exist, or test sub type does not exist or if they exist the subtype does not correspond to the type");
res.trace.push_back(std::string("Test insertion into ontology FAILED, possible error is test type/subtype invalid"));
res.error=std::string("Test insertion into ontology FAILED, possible error is test type/subtype invalid");
return res;
}
else if(status==3)
{
res.success=true;
}
std::vector<std::string> query_ret_tests;
for(json_prolog::PrologQueryProxy::iterator it = results.begin() ;
it != results.end() ; it++)
{
json_prolog::PrologBindings bdg = *it;
std::string temp_query_tests=bdg["B"];
query_ret_tests.push_back(temp_query_tests);
}
for(unsigned int i = 0 ; i < query_ret_tests.size() ; i++)
{
res.test_name=(query_ret_tests[i]);
//tmp_test_name=(query_ret_tests[i]);
}
std::string tmp_test_name;
tmp_test_name.assign(res.test_name.c_str());
std::vector<std::string> test_created=split(tmp_test_name,std::string("#"));
if(test_created.size()==2)
{
for(unsigned int i=0 ; i < req.supported_languages.size(); i++)
{
query=std::string("rdf_assert(knowrob:'")+test_created[1]+std::string("',knowrob:supportedLanguages,knowrob:'")+req.supported_languages[i]+std::string("')");
results = pl.query(query.c_str());
}
}
rapp_platform_ros_communications::ontologyLoadDumpSrv::Request dmp;
dmp.file_url=std::string("currentOntologyVersion.owl");
KnowrobWrapper::dumpOntologyQuery(dmp);
return res;
}
