AbcObjectCache* getObjectCacheFromArchive(std::string const& path, std::string const& identifier)
{
AbcArchiveCache* abcArchiveCache = getArchiveCache( resolvePath( path ) );
if( abcArchiveCache == NULL ) {
return NULL;
}
AbcArchiveCache::iterator it = abcArchiveCache->find( identifier );
if( it == abcArchiveCache->end() ) {
return NULL;
}
return &(it->second);
}
bool Info::isImage(const String &path, size_t &width, size_t &height, const String &root) const {
auto str = resolvePath(path, root);
auto it = _manifest.find(str);
if (it != _manifest.end()) {
if (it->second.type == ManifestFile::Type::Image) {
width = it->second.width;
height = it->second.height;
return true;
}
}
return false;
}
void fn_cat (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
string filename = *(words.end()-1);
inode_ptr ogcwd = state.getCwd();
inode_ptr res = resolvePath(words[1], state.getCwd());
if (res == nullptr){
throw command_error ("cat: " + filename + ": file does not exist");
return; }
if (res->isDirectory()) return; //error here
cout << res->getContents()->readfile() << endl;
}
void KukieControlQueue::computeCurrentCartPose() {
if(!kinematicsInitialized) {
kin = KUKADU_SHARED_PTR<Kinematics>(new KomoPlanner(shared_from_this(),
resolvePath("$KUKADU_HOME/external/komo/share/data/kuka/data/iis_robot.kvg"),
resolvePath("$KUKADU_HOME/external/komo/share/data/kuka/config/MT.cfg"),
getRobotSidePrefix(), acceptCollisions));
kinematicsInitialized = true;
}
while(getQueueRunning()) {
forwadKinMutex.lock();
currCarts = kin->computeFk(armadilloToStdVec(getCurrentJoints().joints));
forwadKinMutex.unlock();
}
}
int FilesystemManager::unlinkHelper(string& path)
{
//Do everything while keeping the mutex locked to prevent someone to
//concurrently mount a filesystem on the directory we're unlinking
Lock<FastMutex> l(mutex);
ResolvedPath openData=resolvePath(path,true);
if(openData.result<0) return openData.result;
//After resolvePath() so path is in canonical form and symlinks are followed
if(filesystems.find(StringPart(path))!=filesystems.end()) return -EBUSY;
StringPart sp(path,string::npos,openData.off);
return openData.fs->unlink(sp);
}
void KukieControlQueue::cartPtpInternal(geometry_msgs::Pose pos, double maxForce) {
cartesianPtpReached = false;
komoMutex.lock();
if(!plannerInitialized) {
planner = KUKADU_SHARED_PTR<PathPlanner>(new KomoPlanner(shared_from_this(),
resolvePath("$KUKADU_HOME/external/komo/share/data/kuka/data/iis_robot.kvg"),
resolvePath("$KUKADU_HOME/external/komo/share/data/kuka/config/MT.cfg"),
getRobotSidePrefix(), acceptCollisions));
plannerInitialized = true;
}
vector<geometry_msgs::Pose> desiredPlan;
desiredPlan.push_back(getCurrentCartesianPose());
desiredPlan.push_back(pos);
vector<vec> desiredJointPlan = planner->planCartesianTrajectory(desiredPlan, false, true);
komoMutex.unlock();
bool maxForceExceeded = false;
if(desiredJointPlan.size() > 0) {
for(int i = 0; i < desiredJointPlan.size() && !maxForceExceeded; ++i) {
if(getAbsoluteCartForce() > maxForce)
maxForceExceeded = true;
else
addJointsPosToQueue(desiredJointPlan.at(i));
synchronizeToControlQueue(1);
}
} else {
ROS_ERROR("(KukieControlQueue) Cartesian position not reachable");
}
}
void deleteArchive(std::string const& path)
{
ESS_PROFILE_SCOPE("deleteArchive");
std::string resolvedPath = resolvePath(path);
std::map<std::string, AlembicArchiveInfo>::iterator it;
it = gArchives.find(resolvedPath);
if (it == gArchives.end()) return;
EC_LOG_INFO("Closing Abc Archive: " << it->second.archive->getName());
it->second.archive->reset();
delete (it->second.archive);
gArchives.erase(it);
}
int decRefArchive(std::string const& path)
{
ESS_PROFILE_SCOPE("decRefArchive");
std::string resolvedPath = resolvePath(path);
std::map<std::string, AlembicArchiveInfo>::iterator it;
it = gArchives.find(resolvedPath);
if (it == gArchives.end()) return -1;
it->second.refCount--;
#ifdef _DEBUG
EC_LOG_INFO("ref count (d): " << it->second.refCount);
#endif
return it->second.refCount;
}
int FilesystemManager::renameHelper(string& oldPath, string& newPath)
{
//Do everything while keeping the mutex locked to prevent someone to
//concurrently mount a filesystem on the directory we're renaming
Lock<FastMutex> l(mutex);
ResolvedPath oldOpenData=resolvePath(oldPath,true);
if(oldOpenData.result<0) return oldOpenData.result;
ResolvedPath newOpenData=resolvePath(newPath,true);
if(newOpenData.result<0) return newOpenData.result;
if(oldOpenData.fs!=newOpenData.fs) return -EXDEV; //Can't rename across fs
//After resolvePath() so path is in canonical form and symlinks are followed
if(filesystems.find(StringPart(oldPath))!=filesystems.end()) return -EBUSY;
if(filesystems.find(StringPart(newPath))!=filesystems.end()) return -EBUSY;
StringPart oldSp(oldPath,string::npos,oldOpenData.off);
StringPart newSp(newPath,string::npos,newOpenData.off);
//Can't rename a directory into a subdirectory of itself
if(newSp.startsWith(oldSp)) return -EINVAL;
return oldOpenData.fs->rename(oldSp,newSp);
}
bool MpqArchive::writeFile(const QString &name, const QString &user, const QString &group, const char *data, qint64 size, mode_t perm, time_t atime, time_t mtime, time_t ctime)
{
iarraystream stream(data, size);
BOOST_SCOPED_ENUM(mpq::MpqFile::Locale) locale;
BOOST_SCOPED_ENUM(mpq::MpqFile::Platform) platform;
QString path(resolvePath(name, locale, platform));
// TODO Change!
//mpq::MpqFile *file = m_mpq->addFile(path.toUtf8().constData(), locale, platform, &stream);
//if (file == 0)
//return false;
return true;
}
bool MpqArchive::doWriteSymLink(const QString &name, const QString &target, const QString &user, const QString &group, mode_t perm, time_t atime, time_t mtime, time_t ctime)
{
iarraystream stream(target.toUtf8().constData(), target.toUtf8().size());
BOOST_SCOPED_ENUM(mpq::MpqFile::Locale) locale;
BOOST_SCOPED_ENUM(mpq::MpqFile::Platform) platform;
QString path(resolvePath(name, locale, platform));
// TODO FIXME
//mpq::MpqFile *file = m_mpq->addFile(path.toUtf8().constData(), locale, platform, &stream);
//if (file == 0)
//return false;
return true;
}
bool MpqArchive::doPrepareWriting(const QString &name, const QString &user, const QString &group, qint64 size, mode_t perm, time_t atime, time_t mtime, time_t ctime)
{
BOOST_SCOPED_ENUM(mpq::MpqFile::Locale) locale;
BOOST_SCOPED_ENUM(mpq::MpqFile::Platform) platform;
QString path(resolvePath(name, locale, platform));
mpq::MpqFile *file = this->m_mpq->findFile(path.toUtf8().constData(), locale, platform);
if (file == 0 || file->size() < size)
return false;
m_mpqFile = file;
return true;
}
void fn_cd (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
inode_ptr ogcwd = state.getCwd();
if (words.size() == 1){
state.setCwd(state.getRoot()->getContents()->getNode("/"));
return;
}
if (words.size() > 2) return;
if (ogcwd == state.getRoot()->getContents()->getNode("/") && words[1] == "..") return;
inode_ptr res = resolvePath(words[1], state.getCwd());
if (res == nullptr) return;
if (!res->isDirectory()) return;
state.setCwd(res);
}
// NOTE: The load() command is similar to the include() command except that it loads the script
// as a stand-alone script. To accomplish this, the ScriptEngine class just emits a signal which
// the Application or other context will connect to in order to know to actually load the script
void ScriptEngine::load(const QString& loadFile) {
if (_stoppingAllScripts) {
qCDebug(scriptengine) << "Script.load() while shutting down is ignored... "
<< "loadFile:" << loadFile << "parent script:" << getFilename();
return; // bail early
}
QUrl url = resolvePath(loadFile);
if (_isReloading) {
auto scriptCache = DependencyManager::get<ScriptCache>();
scriptCache->deleteScript(url.toString());
emit reloadScript(url.toString(), false);
} else {
emit loadScript(url.toString(), false);
}
}
void fn_ls (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
inode_ptr ogcwd = state.getCwd();
inode_ptr res = ogcwd;
if(words.size() > 1)
res = resolvePath(words[1], state.getCwd());
if (res == nullptr) return;
auto pathList = res->getContents()->getAllPaths();
state.setCwd(res);
fn_pwd(state, words);
for (size_t i = 0; i < pathList.size(); i++){
cout << pathList[i] << endl;
}
state.setCwd(ogcwd);
}
void searchJavaSystemLocations(LauncherProperties * props) {
if ( props->jvms->size > 0 ) {
DWORD i=0;
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "Search jvm using some predefined locations", 1);
for(i=0;i<props->jvms->size && !isTerminated(props);i++) {
resolvePath(props, props->jvms->items[i]);
if(props->jvms->items[i]->type!=0) { // bundled JVMs are already checked
trySetCompatibleJava(props->jvms->items[i]->resolved, props);
if(props->java!=NULL) {
break;
}
}
}
}
}
result_t SandBox::require(const char *id, v8::Local<v8::Value> &retVal)
{
std::string fname = resolvePath(id);
std::map<std::string, VariantEx >::iterator it;
// remove .js ext name if exists
if (fname.length() > 3 && !qstrcmp(&fname[fname.length() - 3], ".js"))
fname.resize(fname.length() - 3);
it = m_mods.find(fname);
if (it != m_mods.end())
{
retVal = it->second;
return 1;
}
if (!m_require.IsEmpty())
{
v8::Local<v8::Value> arg = v8::String::NewFromUtf8(isolate, fname.c_str());
retVal = v8::Local<v8::Function>::New(isolate, m_require)->Call(wrap(), 1, &arg);
if (retVal.IsEmpty())
return CALL_E_JAVASCRIPT;
if (!IsEmpty(retVal))
{
if (retVal->IsObject() && !object_base::getInstance(retVal))
retVal = retVal->ToObject()->Clone();
InstallModule(fname, retVal);
return 0;
}
}
// append .js ext name
fname += ".js";
result_t hr;
const char *pname = fname.c_str();
std::string buf;
hr = fs_base::ac_readFile(pname, buf);
if (hr < 0)
return hr;
return addScript(pname, buf.c_str(), retVal);
}
int addRefArchive(std::string const& path)
{
ESS_PROFILE_SCOPE("addRefArchive");
if (path.empty()) return -1;
std::string resolvedPath = resolvePath(path);
// call get archive to ensure to create it!
getArchiveFromID(path);
std::map<std::string, AlembicArchiveInfo>::iterator it;
it = gArchives.find(resolvedPath);
if (it == gArchives.end()) return -1;
it->second.refCount++;
#ifdef _DEBUG
EC_LOG_INFO("ref count (a): " << it->second.refCount);
#endif
return it->second.refCount;
}
Texture *SceneParser::loadTexture(KeyValues *data)
{
const char* identifier = data->getString("identifier");
if(!identifier) {
fprintf(stderr, "Key 'identifier' not found on Texture\n");
return NULL;
}
const char *file = data->getString("file");
if(!file) {
fprintf(stderr, "Key 'file' not found on Texture\n");
return NULL;
}
char *filename = resolvePath(file);
return new Texture(filename, identifier);
}
void fn_lsr (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
inode_ptr ogcwd = state.getCwd();
inode_ptr newCwd = ogcwd;
if (words.size() > 0){
newCwd = resolvePath(words[1], state.getCwd());
state.setCwd(newCwd);
}
auto pathList = newCwd->getContents()->getAllDirs();
wordvec ls {"ls"};
fn_ls(state, ls);
for(int i = 0; i < pathList.size(); i++){
DFS(pathList[i], state);
}
state.setCwd(ogcwd);
}
// If a callback is specified, the included files will be loaded asynchronously and the callback will be called
// when all of the files have finished loading.
// If no callback is specified, the included files will be loaded synchronously and will block execution until
// all of the files have finished loading.
void ScriptEngine::include(const QStringList& includeFiles, QScriptValue callback) {
if (_stoppingAllScripts) {
qCDebug(scriptengine) << "Script.include() while shutting down is ignored..."
<< "includeFiles:" << includeFiles << "parent script:" << getFilename();
return; // bail early
}
QList<QUrl> urls;
for (QString file : includeFiles) {
urls.append(resolvePath(file));
}
BatchLoader* loader = new BatchLoader(urls);
auto evaluateScripts = [=](const QMap<QUrl, QString>& data) {
for (QUrl url : urls) {
QString contents = data[url];
if (contents.isNull()) {
qCDebug(scriptengine) << "Error loading file: " << url << "line:" << __LINE__;
} else {
QScriptValue result = evaluate(contents, url.toString());
}
}
if (callback.isFunction()) {
QScriptValue(callback).call();
}
loader->deleteLater();
};
connect(loader, &BatchLoader::finished, this, evaluateScripts);
// If we are destroyed before the loader completes, make sure to clean it up
connect(this, &QObject::destroyed, loader, &QObject::deleteLater);
loader->start();
if (!callback.isFunction() && !loader->isFinished()) {
QEventLoop loop;
QObject::connect(loader, &BatchLoader::finished, &loop, &QEventLoop::quit);
loop.exec();
}
}
void fn_mkdir (inode_state& state, const wordvec& words){
DEBUGF ('c', state);
DEBUGF ('c', words);
if (words.size() <= 0){
cout << "mkdir: missing operand" << endl;
return;
}
//root case?
if (words[1] == "/"){
inode_ptr ogcwd = state.getCwd();
auto root = state.getCwd()->getContents()->mkdir(words[1]);
root->getContents()->setPath("..", ogcwd);
root->getContents()->setPath(".", root);
return;
}
wordvec pathvec = split(words[1], "/");
string dirname = *(pathvec.end()-1);
string fullpath = "";
for (auto it = pathvec.begin(); it != pathvec.end()-1; ++it)
fullpath += (*it + "/");
inode_ptr res = resolvePath(fullpath,state.getCwd());
if (res == nullptr) return;
inode_ptr directory = res->getContents()->getNode(dirname);
if (directory != nullptr && res != nullptr) //if filename exists and path exists
//dont overwrite anything (ie file or directory)
return;
inode_ptr dir = res->getContents()->mkdir(dirname);
dir->getContents()->setPath("..", res);
dir->getContents()->setPath(".",res->getContents()->getNode(dirname));
/*if (state.getCwd()->getContents()->getNode(filename) != nullptr)
return; */
/*
inode_ptr ogcwd = state.getCwd();
for (auto it = words.begin()+1; it != words.end(); ++it){
auto newDir = state.getCwd()->getContents()->mkdir(*it);
newDir->getContents()->setPath("..", ogcwd);
newDir->getContents()->setPath(".", newDir);
}
*/
}
AbcArchiveCache* getArchiveCache(std::string const& path,
CommonProgressBar* pBar)
{
ESS_PROFILE_SCOPE("getArchiveCache");
getArchiveFromID(path);
std::string resolvedPath = resolvePath(path);
std::map<std::string, AlembicArchiveInfo>::iterator it;
it = gArchives.find(resolvedPath);
if (it == gArchives.end()) return NULL;
// compute cache if required.
if (it->second.archiveCache.size() == 0) {
if (!createAbcArchiveCache(it->second.archive, &(it->second.archiveCache),
pBar)) {
it->second.archiveCache.clear();
return 0;
}
}
return &(it->second.archiveCache);
}
QGLShader *SceneParser::loadShader(KeyValues *data)
{
const char *type = data->getString("type");
if(!type) {
fprintf(stderr, "Key 'type' not found on Shader\n");
return NULL;
}
const char *file = data->getString("file");
if(!file) {
fprintf(stderr, "Key 'file' not found on Shader\n");
return NULL;
}
char *filename = resolvePath(file);
QGLShader::ShaderType shaderType;
if(strcmp(type, "vertex") == 0) {
shaderType = QGLShader::Vertex;
}
else if(strcmp(type, "fragment") == 0) {
shaderType = QGLShader::Fragment;
}
else {
fprintf(stderr, "Invalid shader type: %s\n", type);
delete[] filename;
return NULL;
}
QGLShader *shader = new QGLShader(shaderType);
if(!shader->compileSourceFile(filename)) {
fprintf(stderr, "Failed to load shader %s\n", filename);
fprintf(stdout, shader->log().toStdString().c_str());
delete shader;
delete[] filename;
return NULL;
}
delete[] filename;
return shader;
}
bool FileSystem::fileExists(const char* filePath, bool external)
{
GP_ASSERT(filePath);
std::string fullPath;
#ifdef __ANDROID__
fullPath = __assetPath;
fullPath += resolvePath(filePath);
if (androidFileExists(fullPath.c_str()))
{
return true;
}
#endif
getFullPath(filePath, fullPath, external);
gp_stat_struct s;
return stat(fullPath.c_str(), &s) == 0;
}
void QgsExternalResourceWidget::loadDocument( const QString &path )
{
QString resolvedPath;
if ( path.isEmpty() )
{
#ifdef WITH_QTWEBKIT
if ( mDocumentViewerContent == Web )
{
mWebView->setUrl( QUrl( QStringLiteral( "about:blank" ) ) );
}
#endif
if ( mDocumentViewerContent == Image )
{
mPixmapLabel->clear();
updateDocumentViewer();
}
}
else
{
resolvedPath = resolvePath( path );
#ifdef WITH_QTWEBKIT
if ( mDocumentViewerContent == Web )
{
mWebView->setUrl( QUrl( resolvedPath ) );
}
#endif
if ( mDocumentViewerContent == Image )
{
QPixmap pm( resolvedPath );
mPixmapLabel->setPixmap( pm );
updateDocumentViewer();
}
}
}
std::wstring findFile(const std::wstring& f)
{
ODBGS(f);
if (mol::Path::exists(f))
{
ODBGS("FOUND");
return f;
}
std::wstring modulePath = mol::Path::pathname(mol::app<mol::win::AppBase>().getModulePath());
modulePath = mol::Path::addBackSlash(modulePath);
modulePath.append(f);
ODBGS(modulePath);
if (mol::Path::exists(modulePath))
{
ODBGS("FOUND");
return modulePath;
}
return mol::towstring(resolvePath(mol::tostring(f)));
}
Alembic::Abc::IArchive* getArchiveFromID(std::string const& path)
{
ESS_PROFILE_SCOPE("getArchiveFromID-1");
std::map<std::string, AlembicArchiveInfo>::iterator it;
std::string resolvedPath = resolvePath(path);
it = gArchives.find(resolvedPath);
if (it == gArchives.end()) {
// check if the file exists
if (!boost::filesystem::exists(resolvedPath.c_str())) {
ESS_LOG_ERROR("Can't find Alembic file. Path: "
<< path << " Resolved path: " << resolvedPath);
return NULL;
}
FILE* file = fopen(resolvedPath.c_str(), "rb");
if (file == NULL) {
return NULL;
}
else {
fclose(file);
AbcF::IFactory iFactory;
AbcF::IFactory::CoreType oType;
addArchive(new Abc::IArchive(iFactory.getArchive(resolvedPath, oType)));
// addArchive(new Abc::IArchive( Alembic::AbcCoreHDF5::ReadArchive(),
// resolvedPath));
Abc::IArchive* pArchive = gArchives.find(resolvedPath)->second.archive;
EC_LOG_INFO("Opening Abc Archive: " << pArchive->getName());
return pArchive;
}
}
return it->second.archive;
}
Template::Ptr TemplateCache::getTemplate(const Path& path)
{
if ( _logger )
{
poco_trace_f1(*_logger, "Trying to load %s", path.toString());
}
Path templatePath = resolvePath(path);
std::string templatePathname = templatePath.toString();
if ( _logger )
{
poco_trace_f1(*_logger, "Path resolved to %s", templatePathname);
}
File templateFile(templatePathname);
Template::Ptr tpl;
std::map<std::string, Template::Ptr>::iterator it = _cache.find(templatePathname);
if ( it == _cache.end() )
{
if ( templateFile.exists() )
{
if ( _logger )
{
poco_information_f1(*_logger, "Loading template %s", templatePath.toString());
}
tpl = new Template(templatePath);
try
{
tpl->parse();
_cache[templatePathname] = tpl;
}
catch(JSONTemplateException& jte)
{
if ( _logger )
{
poco_error_f2(*_logger, "Template %s contains an error: %s", templatePath.toString(), jte.message());
}
}
}
else
{
if ( _logger )
{
poco_error_f1(*_logger, "Template file %s doesn't exist", templatePath.toString());
}
throw FileNotFoundException(templatePathname);
}
}
else
{
tpl = it->second;
if ( tpl->parseTime() < templateFile.getLastModified() )
{
if ( _logger )
{
poco_information_f1(*_logger, "Reloading template %s", templatePath.toString());
}
tpl = new Template(templatePath);
try
{
tpl->parse();
_cache[templatePathname] = tpl;
}
catch(JSONTemplateException& jte)
{
if ( _logger )
{
poco_error_f2(*_logger, "Template %s contains an error: %s", templatePath.toString(), jte.message());
}
}
}
}
return tpl;
}
LLView* LLUI::resolvePath(LLView* context, const std::string& path)
{
// Nothing about resolvePath() should require non-const LLView*. If caller
// wants non-const, call the const flavor and then cast away const-ness.
return const_cast<LLView*>(resolvePath(const_cast<const LLView*>(context), path));
}
