bool CodeLocation::isValid() const { return !filePath().isEmpty(); }
int main(int argc, char *argv[]) { try { if(argc < 2) { std::cerr << "Input file not specified!!!" << std::endl; return EXIT_FAILURE; } // check if input file exist std::ifstream inFile(argv[1]); if(!inFile.is_open()) { std::cerr << "Input file '" << argv[1] << "' not found!!!" << std::endl; return EXIT_FAILURE; } // create file name std::string filePath(argv[1]); size_t nameStart = filePath.find_last_of("/\\"); size_t extStart = filePath.find_last_of("."); std::string fileName(filePath, nameStart + 1, extStart - nameStart); fileName += "cpp"; // prepare output stream std::ofstream outFile(fileName.c_str()); if(!outFile.is_open()) { std::cerr << "Cannot create output file '" << fileName << "'!!!" << std::endl; return EXIT_FAILURE; } // create logger & translator freettcn::translator::CLogger logger; freettcn::translator::CDumper dumper(outFile); freettcn::translator::CTranslator translator(argv[1], logger); // create input stream pANTLR3_UINT8 fName((pANTLR3_UINT8)argv[1]); pANTLR3_INPUT_STREAM input = antlr3AsciiFileStreamNew(fName); if(!input) std::cerr << "Unable to open file " << (char *)fName << " due to malloc() failure1" << std::endl; // create lexer pttcn3Lexer lexer = ttcn3LexerNew(input); if(!lexer) { std::cerr << "Unable to create the lexer due to malloc() failure1" << std::endl; return EXIT_FAILURE; } // override warning messages for lexer lexer->pLexer->rec->displayRecognitionError = freettcn::translator::DisplayRecognitionError; // create tokens stream from input file pANTLR3_COMMON_TOKEN_STREAM tokens = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lexer)); if(!tokens) { std::cerr << "Out of memory trying to allocate token stream" << std::endl; return EXIT_FAILURE; } // create parser pttcn3Parser parser = ttcn3ParserNew(tokens); if(!parser) { std::cerr << "Out of memory trying to allocate parser" << std::endl; return EXIT_FAILURE; } // override warning messages for parser parser->pParser->rec->displayRecognitionError = freettcn::translator::DisplayRecognitionError; if(argc >= 3 && std::string(argv[2]) == "-t") { // print tokens stream pANTLR3_UINT8 *tokenNames = parser->pParser->rec->state->tokenNames; if(!tokenNames) { std::cerr << "Token names not initiated!!!" << std::endl; return EXIT_FAILURE; } // estimate the longest token name size_t maxTokenLength = 0; pANTLR3_VECTOR vector = tokens->getTokens(tokens); for(unsigned i=0; i<vector->size(vector); i++) { pANTLR3_COMMON_TOKEN token = (pANTLR3_COMMON_TOKEN)vector->get(vector, i); maxTokenLength = std::max(maxTokenLength, std::string((char *)tokenNames[token->getType(token)]).size()); } // print tokens for(unsigned i=0; i<vector->size(vector); i++) { pANTLR3_COMMON_TOKEN token = (pANTLR3_COMMON_TOKEN)vector->get(vector, i); std::cout << "Token[" << std::setw(3) << std::right << token->getType(token) << "] - " << std::setw(maxTokenLength) << std::left << tokenNames[token->getType(token)] << " = " << token->getText(token)->chars << std::endl; } return EXIT_SUCCESS; } // parse tokes stream parser->ttcn3Module(parser); if(translator.WarningNum() || translator.ErrorNum()) { std::cerr << filePath << ": Errors: " << translator.ErrorNum() << "; Warnings: " << translator.WarningNum() << std::endl; return EXIT_FAILURE; } // dump to output file translator.Dump(dumper); // must manually clean up // parser->free(parser); tokens->free(tokens); lexer->free(lexer); input->close(input); } catch(freettcn::Exception &ex) { std::cerr << "Error: Unhandled freettcn exception caught:" << std::endl; std::cerr << ex.what() << std::endl; return EXIT_FAILURE; } catch(std::exception &ex) { std::cerr << "Error: Unhandled system exception caught:" << std::endl;; std::cerr << ex.what() << std::endl;; return EXIT_FAILURE; } catch(...) { std::cerr << "Unknown exception caught!!!" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; }
bool LevelLoader::LoadLevel(std::string filename) { string filePath("resource/data/levels/"); filePath += filename + ".xml"; xml_document doc; if(!LoadXMLFile(doc,filePath)) return false; bool anythingLoaded = false; for(xml_node entityNode = doc.child("entity"); entityNode; entityNode = entityNode.next_sibling("entity")) { Entity* entity = nullptr; // Get the number of components unsigned int componentCount = std::distance(entityNode.children("component").begin(), entityNode.children("component").end()); // Throws on bad allocation and if we pass something wrong to it try { entity = new Entity(m_nextEntityID++,entityNode.attribute("name").as_string(), componentCount); } catch(std::invalid_argument& ia) { LOG("A new entity could not be allocated. invalid_argument caught: " << ia.what()); continue; } catch(std::bad_alloc& ba) { LOG("A new entity could not be allocated. bad_alloc caught: " << ba.what()); continue; } entity->IsActive(entityNode.attribute("active").as_bool()); entity->SetHP(entityNode.attribute("hp").as_int()); entity->SetLayer(entityNode.attribute("layer").as_int()); vec3<float> entityPos(entityNode.attribute("posX").as_float(), entityNode.attribute("posY").as_float(), 0.0f); vec3<float> entityVel(entityNode.attribute("velX").as_float(), entityNode.attribute("velY").as_float(), 0.0f); entity->SetPosition(entityPos); entity->SetVelocity(entityVel); for(xml_node componentNode = entityNode.child("component"); componentNode; componentNode = componentNode.next_sibling("component")) { ComponentAttribute compAt; std::string componentName = componentNode.attribute("type").as_string(); if(componentName == "") { LOG("Tried to load invalid component type on Entity: " << entityNode.attribute("name").as_string() << " Invalid Component Type: " << componentNode.attribute("type").as_string()); continue; } // Grab all attributes for this component and give to the component factory to construct // Iteration is starting at second attribute since first is type and we already have that xml_attribute attributeNode = componentNode.first_attribute(); attributeNode = attributeNode.next_attribute(); std::vector<xml_attribute> compAttributes; for(; attributeNode; attributeNode = attributeNode.next_attribute()) { compAttributes.push_back(attributeNode); } ComponentFactory::GetInstance().AddComponentToEntity(entity, componentName, &compAttributes); } entity->RegisterForMessages(); m_worldMan->AddEntity(entity); anythingLoaded = true; } if(!anythingLoaded) { LOG("No valid entities to load in : " << filePath); return false; } return true; }
/// Provide access to files as allowed by process definitions. void HttpFileAccess::processRequest(const HttpRequestContext& requestContext, const HttpMessage& request, HttpMessage*& response ) { UtlString message; response = new HttpMessage(); UtlString peerName; if (mSipxRpc->isAllowedPeer(requestContext, peerName)) { if (requestContext.methodIs(HTTP_GET_METHOD)) { UtlString path; requestContext.getMappedPath(path); FileResource* resource = FileResourceManager::getInstance()->find(path); if (resource) { if (resource->isReadable()) { sendFile(path, peerName, requestContext, request, response); } else { message.append("resource "); resource->appendDescription(message); message.append(" does not allow write access to '"); message.append(path); message.append("'"); OsSysLog::add(FAC_SUPERVISOR, PRI_ERR, "HttpFileAccess::processRequest from %s %s", peerName.data(), message.data()); response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION, HTTP_FORBIDDEN_CODE, "Access denied by process definition"); response->setBody(new HttpBody(message.data(),message.length())); response->setContentType(CONTENT_TYPE_TEXT_PLAIN); response->setContentLength(message.length()); } } else { message.append("File resource '"); message.append(path); message.append("' not known to sipXsupervisor."); OsSysLog::add(FAC_SUPERVISOR, PRI_ERR, "HttpFileAccess::processRequest from %s %s", peerName.data(), message.data()); response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION, HTTP_FILE_NOT_FOUND_CODE, HTTP_FILE_NOT_FOUND_TEXT); response->setBody(new HttpBody(message.data(),message.length())); response->setContentType(CONTENT_TYPE_TEXT_PLAIN); response->setContentLength(message.length()); } } else if (requestContext.methodIs(HTTP_DELETE_METHOD)) { UtlString path; requestContext.getMappedPath(path); FileResource* resource = FileResourceManager::getInstance()->find(path); if (resource) { if (resource->isWriteable()) { OsPath filePath(path); if (OsFileSystem::exists(filePath)) { if (OS_SUCCESS == OsFileSystem::remove(filePath, TRUE /* recursive */, TRUE /* force */)) { message.append("File '"); message.append(path); message.append("' deleted"); OsSysLog::add(FAC_SUPERVISOR, PRI_INFO, "HttpFileAccess::processRequest from %s %s", peerName.data(), message.data()); response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION_1_1, HTTP_OK_CODE, "Deleted"); response->setContentLength(0); // tell anyone who cares that this has changed resource->modified(); } else { int httpStatusCode; UtlString httpStatusText; switch (errno) { case EACCES: httpStatusCode = HTTP_FORBIDDEN_CODE; httpStatusText = "File Access Denied"; break; default: httpStatusCode = HTTP_SERVER_ERROR_CODE; httpStatusText.append("Unknown error "); httpStatusText.appendNumber(errno); break; } message.append("File '"); message.append(path); message.append("' errno "); message.appendNumber(errno); message.append(" "); char errnoMsg[1024]; strerror_r(errno, errnoMsg, sizeof(errnoMsg)); message.append(errnoMsg); OsSysLog::add(FAC_SUPERVISOR, PRI_ERR, "HttpFileAccess::processRequest from %s %s", peerName.data(), message.data()); response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION, httpStatusCode, httpStatusText); response->setBody(new HttpBody(message.data(),message.length())); response->setContentType(CONTENT_TYPE_TEXT_PLAIN); response->setContentLength(message.length()); } } else { message.append("File to be deleted '"); message.append(path); message.append("' does not exist"); OsSysLog::add(FAC_SUPERVISOR, PRI_INFO, "HttpFileAccess::processRequest from %s %s", peerName.data(), message.data()); response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION_1_1, HTTP_OK_CODE, "File does not exist"); response->setContentLength(0); } } else { message.append("resource "); resource->appendDescription(message); message.append(" does not allow write access to '"); message.append(path); message.append("'"); OsSysLog::add(FAC_SUPERVISOR, PRI_ERR, "HttpFileAccess::processRequest from %s %s", peerName.data(), message.data()); response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION, HTTP_FORBIDDEN_CODE, "Access denied by process definition"); response->setBody(new HttpBody(message.data(),message.length())); response->setContentType(CONTENT_TYPE_TEXT_PLAIN); response->setContentLength(message.length()); } } else { message.append("File resource '"); message.append(path); message.append("' not known to sipXsupervisor."); OsSysLog::add(FAC_SUPERVISOR, PRI_ERR, "HttpFileAccess::processRequest from %s %s", peerName.data(), message.data()); response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION, HTTP_FILE_NOT_FOUND_CODE, HTTP_FILE_NOT_FOUND_TEXT); response->setBody(new HttpBody(message.data(),message.length())); response->setContentType(CONTENT_TYPE_TEXT_PLAIN); response->setContentLength(message.length()); } } else { OsSysLog::add(FAC_SUPERVISOR, PRI_ERR, "HttpFileAccess::processRequest %s from %s", HTTP_UNSUPPORTED_METHOD_TEXT, peerName.data()); response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION, HTTP_UNSUPPORTED_METHOD_CODE, HTTP_UNSUPPORTED_METHOD_TEXT); } } else { message.append("Request not supported from untrusted peer."); OsSysLog::add(FAC_SUPERVISOR, PRI_ERR, "HttpFileAccess::processRequest %s", message.data()); response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION, HTTP_FORBIDDEN_CODE, HTTP_FORBIDDEN_TEXT); response->setBody(new HttpBody(message.data(),message.length())); response->setContentType(CONTENT_TYPE_TEXT_PLAIN); response->setContentLength(message.length()); } }
static install_status_t iterateOverNativeFiles(JNIEnv *env, jstring javaFilePath, jstring javaCpuAbi, jstring javaCpuAbi2, iterFunc callFunc, void* callArg) { ScopedUtfChars filePath(env, javaFilePath); ScopedUtfChars cpuAbi(env, javaCpuAbi); ScopedUtfChars cpuAbi2(env, javaCpuAbi2); ZipFileRO zipFile; if (zipFile.open(filePath.c_str()) != NO_ERROR) { ALOGI("Couldn't open APK %s\n", filePath.c_str()); return INSTALL_FAILED_INVALID_APK; } const int N = zipFile.getNumEntries(); char fileName[PATH_MAX]; bool hasPrimaryAbi = false; for (int i = 0; i < N; i++) { const ZipEntryRO entry = zipFile.findEntryByIndex(i); if (entry == NULL) { continue; } // Make sure this entry has a filename. if (zipFile.getEntryFileName(entry, fileName, sizeof(fileName))) { continue; } // Make sure we're in the lib directory of the ZIP. if (strncmp(fileName, APK_LIB, APK_LIB_LEN)) { continue; } // Make sure the filename is at least to the minimum library name size. const size_t fileNameLen = strlen(fileName); static const size_t minLength = APK_LIB_LEN + 2 + LIB_PREFIX_LEN + 1 + LIB_SUFFIX_LEN; if (fileNameLen < minLength) { continue; } const char* lastSlash = strrchr(fileName, '/'); ALOG_ASSERT(lastSlash != NULL, "last slash was null somehow for %s\n", fileName); // Check to make sure the CPU ABI of this file is one we support. const char* cpuAbiOffset = fileName + APK_LIB_LEN; const size_t cpuAbiRegionSize = lastSlash - cpuAbiOffset; ALOGV("Comparing ABIs %s and %s versus %s\n", cpuAbi.c_str(), cpuAbi2.c_str(), cpuAbiOffset); if (cpuAbi.size() == cpuAbiRegionSize && *(cpuAbiOffset + cpuAbi.size()) == '/' && !strncmp(cpuAbiOffset, cpuAbi.c_str(), cpuAbiRegionSize)) { ALOGV("Using primary ABI %s\n", cpuAbi.c_str()); hasPrimaryAbi = true; } else if (cpuAbi2.size() == cpuAbiRegionSize && *(cpuAbiOffset + cpuAbi2.size()) == '/' && !strncmp(cpuAbiOffset, cpuAbi2.c_str(), cpuAbiRegionSize)) { /* * If this library matches both the primary and secondary ABIs, * only use the primary ABI. */ if (hasPrimaryAbi) { ALOGV("Already saw primary ABI, skipping secondary ABI %s\n", cpuAbi2.c_str()); continue; } else { ALOGV("Using secondary ABI %s\n", cpuAbi2.c_str()); } } else { ALOGV("abi didn't match anything: %s (end at %zd)\n", cpuAbiOffset, cpuAbiRegionSize); continue; } // If this is a .so file, check to see if we need to copy it. if ((!strncmp(fileName + fileNameLen - LIB_SUFFIX_LEN, LIB_SUFFIX, LIB_SUFFIX_LEN) && !strncmp(lastSlash, LIB_PREFIX, LIB_PREFIX_LEN) && isFilenameSafe(lastSlash + 1)) || !strncmp(lastSlash + 1, GDBSERVER, GDBSERVER_LEN)) { install_status_t ret = callFunc(env, callArg, &zipFile, entry, lastSlash + 1); if (ret != INSTALL_SUCCEEDED) { ALOGV("Failure for entry %s", lastSlash + 1); return ret; } } } return INSTALL_SUCCEEDED; }
void apply_colors_gtk(Fl_Color fg, Fl_Color bg, Fl_Color selection, Fl_Color selection_text, Fl_Color tooltip, Fl_Color tooltip_text, Fl_Color text, Fl_String font) { uchar r, g, b; uchar text_r, text_g, text_b; //, b1, r2, g2, b2; uchar selection_r, selection_g, selection_b; uchar selection_text_r, selection_text_g, selection_text_b; uchar tooltip_r, tooltip_g, tooltip_b; uchar tooltip_text_r, tooltip_text_g, tooltip_text_b; fl_get_color(bg, r, g, b); fl_get_color(fg, text_r, text_g, text_b); fl_get_color(selection, selection_r, selection_g, selection_b); fl_get_color(selection_text, selection_text_r, selection_text_g, selection_text_b); fl_get_color(tooltip, tooltip_r, tooltip_g, tooltip_b); fl_get_color(tooltip_text, tooltip_text_r, tooltip_text_g, tooltip_text_b); // fl_get_color(text, r2, g2, b2); Fl_String filePath(fl_homedir()); filePath += "/.gtkrc"; FILE *gtkFile = fopen(filePath.c_str(), "w"); fprintf(gtkFile, "style \"default\" \n"); fprintf(gtkFile, "{\n"); fprintf(gtkFile, "fontset = \"%s\" \n", font.c_str()); fprintf(gtkFile, "bg[NORMAL] = \"#%02X%02X%02X\"\n", r, g, b); fprintf(gtkFile, "fg[NORMAL] = \"#%02X%02X%02X\"\n", text_r, text_g, text_b); fprintf(gtkFile, "bg[PRELIGHT] = \"#%02X%02X%02X\"\n", r, g, b); fprintf(gtkFile, "fg[PRELIGHT] = \"#%02X%02X%02X\"\n", text_r, text_g, text_b); fprintf(gtkFile, "bg[ACTIVE] = \"#%02X%02X%02X\"\n", r, g, b); fprintf(gtkFile, "fg[ACTIVE] = \"#%02X%02X%02X\"\n", text_r, text_g, text_b); fprintf(gtkFile, "bg[SELECTED] = \"#%02X%02X%02X\"\n", selection_r, selection_g, selection_b); fprintf(gtkFile, "fg[SELECTED] = \"#%02X%02X%02X\"\n", selection_text_r, selection_text_g, selection_text_b); fprintf(gtkFile, "}\n"); fprintf(gtkFile, "style \"menu\" \n"); fprintf(gtkFile, "{\n"); fprintf(gtkFile, "bg[PRELIGHT] = \"#%02X%02X%02X\"\n", selection_r, selection_g, selection_b); fprintf(gtkFile, "fg[PRELIGHT] = \"#%02X%02X%02X\"\n", selection_text_r, selection_text_g, selection_text_b); fprintf(gtkFile, "}\n"); fprintf(gtkFile, "style \"tooltip\" \n"); fprintf(gtkFile, "{\n"); fprintf(gtkFile, "bg[NORMAL] = \"#%02X%02X%02X\"\n", tooltip_r, tooltip_g, tooltip_b); fprintf(gtkFile, "fg[NORMAL] = \"#%02X%02X%02X\"\n", tooltip_text_r, tooltip_text_g, tooltip_text_b); fprintf(gtkFile, "}\n"); fprintf(gtkFile, "class \"*\" style \"default\"\n"); fprintf(gtkFile, "widget_class \"*Menu*\" style \"menu\" \n"); fprintf(gtkFile, "widget \"gtk-tooltips\" style \"tooltip\" \n"); fclose(gtkFile); }
bool Directory::fileIsDir(void) const { if(!mDirent) throw Exception("No more files in directory"); //return (mDirent->d_type == DT_DIR); return Exist(filePath()); }
bool QDir::mkdir( const QString &dirName, bool acceptAbsPath ) const { return MKDIR( QFile::encodeName(filePath(dirName,acceptAbsPath)), 0777 ) == 0; }
QString ProFileDocument::defaultPath() const { QFileInfo fi(filePath()); return fi.absolutePath(); }
void DIALOG_SPICE_MODEL::loadLibrary( const wxString& aFilePath ) { wxString curModel = m_modelName->GetValue(); m_models.clear(); wxFileName filePath( aFilePath ); bool in_subckt = false; // flag indicating that the parser is inside a .subckt section // Look for the file in the project path if( !filePath.Exists() ) { filePath.SetPath( Prj().GetProjectPath() + filePath.GetPath() ); if( !filePath.Exists() ) return; } // Display the library contents wxWindowUpdateLocker updateLock( this ); m_libraryContents->Clear(); wxTextFile file; file.Open( filePath.GetFullPath() ); int line_nr = 0; // Process the file, looking for components while( !file.Eof() ) { const wxString& line = line_nr == 0 ? file.GetFirstLine() : file.GetNextLine(); m_libraryContents->AppendText( line ); m_libraryContents->AppendText( "\n" ); wxStringTokenizer tokenizer( line ); while( tokenizer.HasMoreTokens() ) { wxString token = tokenizer.GetNextToken().Lower(); // some subckts contain .model clauses inside, // skip them as they are a part of the subckt, not another model if( token == ".model" && !in_subckt ) { wxString name = tokenizer.GetNextToken(); if( name.IsEmpty() ) break; token = tokenizer.GetNextToken(); SPICE_PRIMITIVE type = MODEL::parseModelType( token ); if( type != SP_UNKNOWN ) m_models.emplace( name, MODEL( line_nr, type ) ); } else if( token == ".subckt" ) { wxASSERT( !in_subckt ); in_subckt = true; wxString name = tokenizer.GetNextToken(); if( name.IsEmpty() ) break; m_models.emplace( name, MODEL( line_nr, SP_SUBCKT ) ); } else if( token == ".ends" ) { wxASSERT( in_subckt ); in_subckt = false; } } ++line_nr; } wxArrayString modelsList; // Refresh the model name combobox values m_modelName->Clear(); for( const auto& model : m_models ) { m_modelName->Append( model.first ); modelsList.Add( model.first ); } m_modelName->AutoComplete( modelsList ); // Restore the previous value or if there is none - pick the first one from the loaded library if( !curModel.IsEmpty() ) m_modelName->SetValue( curModel ); else if( m_modelName->GetCount() > 0 ) m_modelName->SetSelection( 0 ); }
bool QDir::rmdir( const QString &dirName, bool acceptAbsPath ) const { return RMDIR( QFile::encodeName(filePath(dirName,acceptAbsPath)) ) == 0; }
/// Get example path static inline std::string getExamplePath() { std::string filePath(__FILE__); return filePath.substr( 0, filePath.length() - std::string("main.cpp").length()); }
boost::filesystem::path FileUtils::filePath(int64_t id) { return filePath(id, prefix_); }
void ReflectionParser::GenerateFiles(void) { fs::path sourceRootDirectory( m_options.sourceRoot ); fs::path outputFileDirectory( m_options.outputModuleFileDirectory ); m_moduleFileHeaderTemplate = LoadTemplate( kTemplateModuleFileHeader ); if (!m_moduleFileHeaderTemplate.isValid( )) { std::stringstream error; error << "Unable to compile module file header template." << std::endl; error << m_moduleFileHeaderTemplate.errorMessage( ); throw std::exception( error.str( ).c_str( ) ); } m_moduleFileSourceTemplate = LoadTemplate( kTemplateModuleFileSource ); if (!m_moduleFileSourceTemplate.isValid( )) { std::stringstream error; error << "Unable to compile module file source template." << std::endl; error << m_moduleFileSourceTemplate.errorMessage( ); throw std::exception( error.str( ).c_str( ) ); } TemplateData moduleFilesData { TemplateData::Type::List }; fs::path metaCacheFileName = m_options.outputModuleFileDirectory; metaCacheFileName /= ".meta-cache"; auto metaCacheFileExists = exists( metaCacheFileName ); std::string moduleFileCache; for (auto &file : m_moduleFiles) { fs::path filePath( file.first ); // path relative to the source root auto relativeDir = utils::MakeRelativePath( sourceRootDirectory, filePath ) .replace_extension( "" ).string( ); if (relativeDir.find_first_of( ".." ) != std::string::npos) continue; auto outputFile = outputFileDirectory / relativeDir; auto outputFileHeader = change_extension( outputFile, "Generated.h" ); auto outputFileSource = change_extension( outputFile, "Generated.cpp" ); // module file name file.second.name = boost::regex_replace( relativeDir, kSpecialCharsRegex, "_" ); moduleFileCache += file.second.name + '\n'; TemplateData moduleFileData { TemplateData::Type::Object }; moduleFileData[ "name" ] = file.second.name; moduleFileData[ "header" ] = outputFileHeader.string( ); moduleFilesData << moduleFileData; // if the generated file header doesn't exist, we need to regenerate if (m_options.forceRebuild || !metaCacheFileExists || !exists( outputFileHeader )) { generateModuleFile( outputFileHeader, outputFileSource, file.first, file.second ); continue; } auto lastSourceWrite = last_write_time( filePath ); auto lastGeneratedWrite = last_write_time( outputFileHeader ); // if the generated file is older than the source file, we need to regenerate if (lastSourceWrite > lastGeneratedWrite) generateModuleFile( outputFileHeader, outputFileSource, file.first, file.second ); } fs::path moduleCacheFileName = m_options.outputModuleFileDirectory; moduleCacheFileName /= ".meta-cache"; if (!m_options.forceRebuild && metaCacheFileExists) { std::ifstream cacheFile( moduleCacheFileName.string( ) ); std::istreambuf_iterator<char> cacheFileBegin( cacheFile ); std::istreambuf_iterator<char> cacheFileEnd( nullptr ); // the cache is the same, so we don't need to write the source files if (utils::RangeEqual( moduleFileCache.begin( ), moduleFileCache.end( ), cacheFileBegin, cacheFileEnd )) { return; } } // update the cache utils::WriteText( moduleCacheFileName.string( ), moduleFileCache ); // module source file { auto sourceTemplate = LoadTemplate( kTemplateModuleSource ); if (!sourceTemplate.isValid( )) { std::stringstream error; error << "Unable to compile module source template." << std::endl; error << sourceTemplate.errorMessage( ); throw std::exception( error.str( ).c_str( ) ); } TemplateData sourceData { TemplateData::Type::Object }; addGlobalTemplateData( sourceData ); sourceData[ "moduleFile" ] = moduleFilesData; COMPILE_TYPE_TEMPLATES( sourceData, "external", m_externals ); fs::path sourcePath( m_options.outputModuleSource ); fs::create_directory( sourcePath.parent_path( ) ); utils::WriteText( sourcePath.string( ), sourceTemplate.render( sourceData ) ); } }
/*! Advances the iterator to the next entry, and returns the file path of this new entry. If hasNext() returns false, this function does nothing, and returns a null QString. You can call fileName() or filePath() to get the current entry file name or path, or fileInfo() to get a QFileInfo for the current entry. \sa hasNext(), fileName(), filePath(), fileInfo() */ QString QDirIterator::next() { d->advance(); return filePath(); }
QString ProFileDocument::suggestedFileName() const { QFileInfo fi(filePath()); return fi.fileName(); }
QString Solid::StorageAccess::filePath() const { Q_D(const StorageAccess); return_SOLID_CALL(Ifaces::StorageAccess *, d->backendObject(), QString(), filePath()); }
Foam::Istream* Foam::IOobject::objectStream() { return objectStream(filePath()); }
inline void VEventServerDbTask::UpdateDBSession(bool bIsFirst) { std::time_t pTime = time(NULL); /* Get the Event Server Conf */ VidEventDBConf cDBConf; m_Factory.GetEventDBConf(cDBConf); Poco::Timestamp pTimeStamp = Poco::Timestamp::fromEpochTime(pTime); /* Use next sec to check */ Poco::DateTime pTimeTime(pTimeStamp); int nYear = pTimeTime.year(); int nMonth = pTimeTime.month(); int nHour = pTimeTime.hour(); if (bIsFirst != true) { /* Every day check if need new database */ if (pTime%3600 != 0 || nHour != 0) { return; } if (nYear == m_nYear && nMonth == m_nMonth) { return; } } m_nYear = nYear; m_nMonth = nMonth; char strPlus[1024]; sprintf(strPlus, "%d_%d", m_nYear, nMonth); if (cDBConf.ntype() == VID_DB_SQLITE) { if (m_pSqlSession != NULL) { delete m_pSqlSession; m_pSqlSession = NULL; } try { Poco::Path path(cDBConf.strdbpath()); Poco::File file(path); file.createDirectories(); SQLite::Connector::registerConnector(); VDC_DEBUG("Create the Event DB path %s\n", path.toString().c_str()); Poco::Path filePath("eventdb.db"); path.append(filePath); path.makeFile(); VDC_DEBUG("Create the Event DB file %s\n", path.toString().c_str()); m_pSqlSession = new Poco::Data::Session("SQLite", path.toString()); *m_pSqlSession << "CREATE TABLE IF NOT EXISTS events " "(id INTEGER PRIMARY KEY, strId TEXT, strDevice TEXT, " "strDeviceName TEXT, strType TEXT, nTime INTEGER, strEvttime DATE, strDesc TEXT)", now; } catch (exception const &e) { VDC_DEBUG("%s Create SQLITE session failed \n", __FUNCTION__); } }else { VDC_DEBUG( "%s Do not support the DB TYPE \n",__FUNCTION__); ve_sleep(1000); } }
QString ProFileDocument::defaultPath() const { return filePath().toFileInfo().absolutePath(); }
NS_IMETHODIMP nsGNOMEShellService::SetDesktopBackground(nsIDOMElement* aElement, int32_t aPosition) { nsCString brandName; nsresult rv = GetBrandName(brandName); NS_ENSURE_SUCCESS(rv, rv); // build the file name nsCString filePath(PR_GetEnv("HOME")); filePath.Append('/'); filePath.Append(brandName); filePath.AppendLiteral("_wallpaper.png"); // get the image container nsCOMPtr<nsIImageLoadingContent> imageContent(do_QueryInterface(aElement, &rv)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<imgIRequest> request; rv = imageContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST, getter_AddRefs(request)); NS_ENSURE_TRUE(request, rv); nsCOMPtr<imgIContainer> container; rv = request->GetImage(getter_AddRefs(container)); NS_ENSURE_TRUE(request, rv); nsCOMPtr<nsIImageToPixbuf> imgToPixbuf(do_GetService("@mozilla.org/widget/image-to-gdk-pixbuf;1")); if (!imgToPixbuf) return NS_ERROR_NOT_AVAILABLE; GdkPixbuf* pixbuf = imgToPixbuf->ConvertImageToPixbuf(container); if (!pixbuf) return NS_ERROR_NOT_AVAILABLE; // write the image to a file in the home dir gboolean res = gdk_pixbuf_save(pixbuf, filePath.get(), "png", NULL, NULL); g_object_unref(pixbuf); if (!res) return NS_ERROR_FAILURE; // set desktop wallpaper filling style const char* options; switch (aPosition) { case BACKGROUND_TILE: options = "wallpaper"; break; case BACKGROUND_STRETCH: options = "stretched"; break; case BACKGROUND_FILL: options = "zoom"; break; case BACKGROUND_FIT: options = "scaled"; break; default: options = "centered"; break; } // Try GSettings first. If we don't have GSettings or the right schema, fall back // to using GConf instead. Note that if GSettings works ok, the changes get // mirrored to GConf by the gsettings->gconf bridge in gnome-settings-daemon nsCOMPtr<nsIGSettingsService> gsettings(do_GetService(NS_GSETTINGSSERVICE_CONTRACTID)); if (gsettings) { nsCOMPtr<nsIGSettingsCollection> background_settings; gsettings->GetCollectionForSchema(NS_LITERAL_CSTRING(OGDB_SCHEMA), getter_AddRefs(background_settings)); if (background_settings) { gchar *file_uri = g_filename_to_uri(filePath.get(), NULL, NULL); if (!file_uri) return NS_ERROR_FAILURE; background_settings->SetString(NS_LITERAL_CSTRING(OGDB_OPTIONS), nsDependentCString(options)); background_settings->SetString(NS_LITERAL_CSTRING(OGDB_IMAGE), nsDependentCString(file_uri)); g_free(file_uri); background_settings->SetBoolean(NS_LITERAL_CSTRING(OGDB_DRAWBG), true); return NS_OK; } } // if the file was written successfully, set it as the system wallpaper nsCOMPtr<nsIGConfService> gconf(do_GetService(NS_GCONFSERVICE_CONTRACTID)); if (gconf) { gconf->SetString(NS_LITERAL_CSTRING(DGB_OPTIONS), nsDependentCString(options)); // Set the image to an empty string first to force a refresh (since we could // be writing a new image on top of an existing SeaMonkey_wallpaper.png // and nautilus doesn't monitor the file for changes). gconf->SetString(NS_LITERAL_CSTRING(DGB_IMAGE), EmptyCString()); gconf->SetString(NS_LITERAL_CSTRING(DGB_IMAGE), filePath); gconf->SetBool(NS_LITERAL_CSTRING(DGB_DRAWBG), true); } return NS_OK; }
QString ProFileDocument::suggestedFileName() const { return filePath().fileName(); }
std::string File::shortInfo() const { return filePath(); }
// --------------------------------------------------------------------------- // From MMPXPlaybackCallback // Handle media // --------------------------------------------------------------------------- // void CAiPlayerPluginEngine::HandleMediaL( const CMPXMedia& aMedia, TInt aError ) { if ( KErrNone == aError ) { delete iUri; iUri = NULL; if (aMedia.IsSupported(KMPXMediaGeneralUri)) { TParsePtrC filePath(aMedia.ValueText(KMPXMediaGeneralUri) ); iUri = filePath.FullName().AllocL(); } delete iTitle; iTitle = NULL; if ( aMedia.IsSupported( KMPXMediaGeneralTitle ) ) { iTitle = ( aMedia.ValueText( KMPXMediaGeneralTitle ) ).AllocL(); } else if ( aMedia.IsSupported( KMPXMediaGeneralDuration)) { RDebug::Print(_L("duration found")); TInt val=aMedia.ValueTObjectL<TInt>( KMPXMediaGeneralDuration ); RDebug::Print(_L("val %d"),val); iDuration=val/KMPXOneSecInMilliSecs; } else if ( aMedia.IsSupported( KMPXMediaGeneralUri ) ) { TParsePtrC filePath( aMedia.ValueText( KMPXMediaGeneralUri ) ); iTitle = (filePath.Name()).AllocL(); } delete iArtist; iArtist = NULL; if ( aMedia.IsSupported( KMPXMediaMusicArtist ) ) { iArtist = ( aMedia.ValueText( KMPXMediaMusicArtist ) ).AllocL(); } iObserver->TrackInfoChanged(iTitle ? *iTitle : KNullDesC(), iArtist ? *iArtist : KNullDesC()); if (!iSkipping) { if (iExtractingAlbumArt) { if (iAlbumArtUtil){iAlbumArtUtil->CancelRequest();} iExtractingAlbumArt=EFalse; } if ( aMedia.IsSupported( KMPXMediaMusicAlbumArtFileName ) ) { delete iMedia; iMedia=NULL; iMedia = CMPXMedia::NewL( aMedia ); TRAPD(err,iAlbumArtUtil->ExtractAlbumArtL( *iMedia, *this, KAlbumArtSize, EFalse)); if (err != KErrNone) { iObserver->AlbumArtChanged(NULL); } } else { iObserver->AlbumArtChanged(NULL); } } else { iObserver->AlbumArtChanged(NULL); } } }
String WebInspectorProxy::inspectorPageURL() const { GOwnPtr<gchar> filePath(g_build_filename(inspectorFilesBasePath(), "inspector.html", NULL)); GOwnPtr<gchar> fileURI(g_filename_to_uri(filePath.get(), 0, 0)); return WebCore::filenameToString(fileURI.get()); }
/*! Returns the file name part of the file path, ie the current file. Must not be called on an empty Location object. */ QString Location::fileName() const { QString fp = filePath(); return fp.mid(fp.lastIndexOf('/') + 1); }
DatabaseWidget::DatabaseWidget(Database* db, QWidget* parent) : QStackedWidget(parent) , m_db(db) , m_searchUi(new Ui::SearchWidget()) , m_searchWidget(new QWidget()) , m_newGroup(Q_NULLPTR) , m_newEntry(Q_NULLPTR) , m_newParent(Q_NULLPTR) { m_searchUi->setupUi(m_searchWidget); m_searchTimer = new QTimer(this); m_searchTimer->setSingleShot(true); m_mainWidget = new QWidget(this); QLayout* layout = new QHBoxLayout(m_mainWidget); QSplitter* splitter = new QSplitter(m_mainWidget); QWidget* rightHandSideWidget = new QWidget(splitter); m_searchWidget->setParent(rightHandSideWidget); m_groupView = new GroupView(db, splitter); m_groupView->setObjectName("groupView"); m_groupView->setContextMenuPolicy(Qt::CustomContextMenu); connect(m_groupView, SIGNAL(customContextMenuRequested(QPoint)), SLOT(emitGroupContextMenuRequested(QPoint))); m_entryView = new EntryView(rightHandSideWidget); m_entryView->setObjectName("entryView"); m_entryView->setContextMenuPolicy(Qt::CustomContextMenu); m_entryView->setGroup(db->rootGroup()); connect(m_entryView, SIGNAL(customContextMenuRequested(QPoint)), SLOT(emitEntryContextMenuRequested(QPoint))); QSizePolicy policy; policy = m_groupView->sizePolicy(); policy.setHorizontalStretch(30); m_groupView->setSizePolicy(policy); policy = rightHandSideWidget->sizePolicy(); policy.setHorizontalStretch(70); rightHandSideWidget->setSizePolicy(policy); QAction* closeAction = new QAction(m_searchWidget); QIcon closeIcon = filePath()->icon("actions", "dialog-close"); closeAction->setIcon(closeIcon); m_searchUi->closeSearchButton->setDefaultAction(closeAction); m_searchUi->closeSearchButton->setShortcut(Qt::Key_Escape); m_searchWidget->hide(); m_searchUi->caseSensitiveCheckBox->setVisible(false); QVBoxLayout* vLayout = new QVBoxLayout(rightHandSideWidget); vLayout->setMargin(0); vLayout->addWidget(m_searchWidget); vLayout->addWidget(m_entryView); rightHandSideWidget->setLayout(vLayout); splitter->addWidget(m_groupView); splitter->addWidget(rightHandSideWidget); layout->addWidget(splitter); m_mainWidget->setLayout(layout); m_editEntryWidget = new EditEntryWidget(); m_editEntryWidget->setObjectName("editEntryWidget"); m_historyEditEntryWidget = new EditEntryWidget(); m_editGroupWidget = new EditGroupWidget(); m_editGroupWidget->setObjectName("editGroupWidget"); m_changeMasterKeyWidget = new ChangeMasterKeyWidget(); m_changeMasterKeyWidget->headlineLabel()->setText(tr("Change master key")); QFont headlineLabelFont = m_changeMasterKeyWidget->headlineLabel()->font(); headlineLabelFont.setBold(true); headlineLabelFont.setPointSize(headlineLabelFont.pointSize() + 2); m_changeMasterKeyWidget->headlineLabel()->setFont(headlineLabelFont); m_databaseSettingsWidget = new DatabaseSettingsWidget(); m_databaseSettingsWidget->setObjectName("databaseSettingsWidget"); m_databaseOpenWidget = new DatabaseOpenWidget(); m_databaseOpenWidget->setObjectName("databaseOpenWidget"); m_keepass1OpenWidget = new KeePass1OpenWidget(); m_keepass1OpenWidget->setObjectName("keepass1OpenWidget"); m_unlockDatabaseWidget = new UnlockDatabaseWidget(); m_unlockDatabaseWidget->setObjectName("unlockDatabaseWidget"); addWidget(m_mainWidget); addWidget(m_editEntryWidget); addWidget(m_editGroupWidget); addWidget(m_changeMasterKeyWidget); addWidget(m_databaseSettingsWidget); addWidget(m_historyEditEntryWidget); addWidget(m_databaseOpenWidget); addWidget(m_keepass1OpenWidget); addWidget(m_unlockDatabaseWidget); connect(m_groupView, SIGNAL(groupChanged(Group*)), this, SLOT(clearLastGroup(Group*))); connect(m_groupView, SIGNAL(groupChanged(Group*)), SIGNAL(groupChanged())); connect(m_groupView, SIGNAL(groupChanged(Group*)), m_entryView, SLOT(setGroup(Group*))); connect(m_entryView, SIGNAL(entryActivated(Entry*, EntryModel::ModelColumn)), SLOT(entryActivationSignalReceived(Entry*, EntryModel::ModelColumn))); connect(m_entryView, SIGNAL(entrySelectionChanged()), SIGNAL(entrySelectionChanged())); connect(m_editEntryWidget, SIGNAL(editFinished(bool)), SLOT(switchToView(bool))); connect(m_editEntryWidget, SIGNAL(historyEntryActivated(Entry*)), SLOT(switchToHistoryView(Entry*))); connect(m_historyEditEntryWidget, SIGNAL(editFinished(bool)), SLOT(switchBackToEntryEdit())); connect(m_editGroupWidget, SIGNAL(editFinished(bool)), SLOT(switchToView(bool))); connect(m_changeMasterKeyWidget, SIGNAL(editFinished(bool)), SLOT(updateMasterKey(bool))); connect(m_databaseSettingsWidget, SIGNAL(editFinished(bool)), SLOT(switchToView(bool))); connect(m_databaseOpenWidget, SIGNAL(editFinished(bool)), SLOT(openDatabase(bool))); connect(m_keepass1OpenWidget, SIGNAL(editFinished(bool)), SLOT(openDatabase(bool))); connect(m_unlockDatabaseWidget, SIGNAL(editFinished(bool)), SLOT(unlockDatabase(bool))); connect(this, SIGNAL(currentChanged(int)), this, SLOT(emitCurrentModeChanged())); connect(m_searchUi->searchEdit, SIGNAL(textChanged(QString)), this, SLOT(startSearchTimer())); connect(m_searchUi->caseSensitiveCheckBox, SIGNAL(toggled(bool)), this, SLOT(startSearch())); connect(m_searchUi->searchCurrentRadioButton, SIGNAL(toggled(bool)), this, SLOT(startSearch())); connect(m_searchUi->searchRootRadioButton, SIGNAL(toggled(bool)), this, SLOT(startSearch())); connect(m_searchTimer, SIGNAL(timeout()), this, SLOT(search())); connect(closeAction, SIGNAL(triggered()), this, SLOT(closeSearch())); setCurrentWidget(m_mainWidget); }
static void DeserializePrefs(const char *prefsTxt, SerializableGlobalPrefs& globalPrefs, FileHistory& fh, Favorites *favs) { BencObj *obj = BencObj::Decode(prefsTxt); if (!obj || obj->Type() != BT_DICT) goto Exit; BencDict *prefs = static_cast<BencDict *>(obj); BencDict *global = prefs->GetDict(GLOBAL_PREFS_STR); if (!global) goto Exit; Retrieve(global, TOOLBAR_VISIBLE_STR, globalPrefs.toolbarVisible); Retrieve(global, TOC_VISIBLE_STR, globalPrefs.tocVisible); Retrieve(global, FAV_VISIBLE_STR, globalPrefs.favVisible); Retrieve(global, SIDEBAR_DX_STR, globalPrefs.sidebarDx); Retrieve(global, TOC_DY_STR, globalPrefs.tocDy); Retrieve(global, PDF_ASSOCIATE_DONT_ASK_STR, globalPrefs.pdfAssociateDontAskAgain); Retrieve(global, PDF_ASSOCIATE_ASSOCIATE_STR, globalPrefs.pdfAssociateShouldAssociate); Retrieve(global, ESC_TO_EXIT_STR, globalPrefs.escToExit); Retrieve(global, USE_SYS_COLORS_STR, globalPrefs.useSysColors); Retrieve(global, BG_COLOR_STR, globalPrefs.bgColor); Retrieve(global, ENABLE_AUTO_UPDATE_STR, globalPrefs.enableAutoUpdate); Retrieve(global, REMEMBER_OPENED_FILES_STR, globalPrefs.rememberOpenedFiles); Retrieve(global, GLOBAL_PREFS_ONLY_STR, globalPrefs.globalPrefsOnly); Retrieve(global, SHOW_RECENT_FILES_STR, globalPrefs.showStartPage); Retrieve(global, DISPLAY_MODE_STR, globalPrefs.defaultDisplayMode); Retrieve(global, ZOOM_VIRTUAL_STR, globalPrefs.defaultZoom); Retrieve(global, WINDOW_STATE_STR, globalPrefs.windowState); Retrieve(global, WINDOW_X_STR, globalPrefs.windowPos.x); Retrieve(global, WINDOW_Y_STR, globalPrefs.windowPos.y); Retrieve(global, WINDOW_DX_STR, globalPrefs.windowPos.dx); Retrieve(global, WINDOW_DY_STR, globalPrefs.windowPos.dy); Retrieve(global, INVERSE_SEARCH_COMMANDLINE, globalPrefs.inverseSearchCmdLine); Retrieve(global, ENABLE_TEX_ENHANCEMENTS_STR, globalPrefs.enableTeXEnhancements); Retrieve(global, VERSION_TO_SKIP_STR, globalPrefs.versionToSkip); RetrieveRaw(global, LAST_UPDATE_STR, globalPrefs.lastUpdateTime); const char *lang = GetRawString(global, UI_LANGUAGE_STR); const char *langCode = trans::ValidateLanguageCode(lang); if (langCode) globalPrefs.currentLanguage = langCode; Retrieve(global, FWDSEARCH_OFFSET, globalPrefs.fwdSearch.offset); Retrieve(global, FWDSEARCH_COLOR, globalPrefs.fwdSearch.color); Retrieve(global, FWDSEARCH_WIDTH, globalPrefs.fwdSearch.width); Retrieve(global, FWDSEARCH_PERMANENT, globalPrefs.fwdSearch.permanent); Retrieve(global, CBX_RIGHT2LEFT, globalPrefs.cbxR2L); Retrieve(global, OPEN_COUNT_WEEK_STR, globalPrefs.openCountWeek); int weekDiff = GetWeekCount() - globalPrefs.openCountWeek; globalPrefs.openCountWeek = GetWeekCount(); BencArray *fileHistory = prefs->GetArray(FILE_HISTORY_STR); if (!fileHistory) goto Exit; size_t dlen = fileHistory->Length(); for (size_t i = 0; i < dlen; i++) { BencDict *dict = fileHistory->GetDict(i); assert(dict); if (!dict) continue; DisplayState *state = DeserializeDisplayState(dict, globalPrefs.globalPrefsOnly); if (state) { // "age" openCount statistics (cut in in half after every week) state->openCount >>= weekDiff; fh.Append(state); } } BencArray *favsArr = prefs->GetArray(FAVS_STR); if (!favsArr) goto Exit; for (size_t i = 0; i < favsArr->Length(); i += 2) { BencString *filePathBenc = favsArr->GetString(i); BencArray *favData = favsArr->GetArray(i+1); if (!filePathBenc || !favData) break; ScopedMem<WCHAR> filePath(filePathBenc->Value()); for (size_t j = 0; j < favData->Length(); j += 2) { // we're lenient about errors BencInt *pageNoBenc = favData->GetInt(j); BencString *nameBenc = favData->GetString(j + 1); if (!pageNoBenc || !nameBenc) break; int pageNo = (int)pageNoBenc->Value(); ScopedMem<WCHAR> name(nameBenc->Value()); favs->AddOrReplace(filePath, pageNo, EmptyToNull(name)); } } Exit: delete obj; }
/*! Returns a QFileInfo for the current directory entry. If the current entry is invalid (i.e., isValid() returns false), a null QFileInfo is returned. \sa filePath(), fileName() */ QFileInfo QFileSystemIterator::fileInfo() const { return QFileInfo(filePath()); }
//----------------------------------------------------------------------------- int ctkAbstractPluginFactoryTest1(int argc, char * argv []) { QCoreApplication app(argc, argv); if (argc <= 1) { std::cerr << "Missing argument" << std::endl; return EXIT_FAILURE; } QString filePath(argv[1]); QFileInfo file(filePath); while (filePath.contains("$(OutDir)")) { QString debugFilePath = filePath; debugFilePath.replace("$(OutDir)","Debug"); if (QFile::exists(QString(debugFilePath))) { file = QFileInfo(debugFilePath); break; } QString releaseFilePath = filePath; releaseFilePath.replace("$(OutDir)","Release"); if (QFile::exists(QString(releaseFilePath))) { file = QFileInfo(releaseFilePath); break; } return EXIT_FAILURE; } ctkAbstractPluginFactory< ctkDummyPlugin > pluginFactory; pluginFactory.setVerbose(true); QString itemKey = pluginFactory.registerFileItem(QFileInfo("foo/bar.txt")); if (!itemKey.isEmpty()) { std::cerr << "ctkAbstractPluginFactory::registerLibrary() registered bad file" << std::endl; return EXIT_FAILURE; } itemKey = pluginFactory.registerFileItem(file); if (itemKey.isEmpty() || pluginFactory.itemKeys().count() != 1) { std::cerr << __LINE__ << ": ctkAbstractPluginFactory::registerLibrary() failed: " << pluginFactory.itemKeys().count() << std::endl; return EXIT_FAILURE; } // register twice must return false itemKey = pluginFactory.registerFileItem(file); if (itemKey.isEmpty() || pluginFactory.itemKeys().count() != 1) { std::cerr << __LINE__ << ": ctkAbstractPluginFactory::registerLibrary() failed: " << qPrintable(itemKey) << " count: " << pluginFactory.itemKeys().count() << std::endl; return EXIT_FAILURE; } if (QFileInfo(pluginFactory.path(itemKey)) != file) { std::cerr << __LINE__ << ": ctkAbstractPluginFactory::registerLibrary() failed: " << pluginFactory.path(itemKey).toStdString() << std::endl; return EXIT_FAILURE; } ctkDummyPlugin* plugin = pluginFactory.instantiate(itemKey); if (plugin == 0) { std::cerr << __LINE__ << ": ctkAbstractPluginFactory::instantiate() failed" << std::endl; return EXIT_FAILURE; } pluginFactory.uninstantiate(itemKey); // ctkDummyPlugin is not a QPushButton, it should fail then. ctkAbstractPluginFactory< QTimer > buttonPluginFactory; buttonPluginFactory.setVerbose(true); // it should register but fail while instanciating itemKey = buttonPluginFactory.registerFileItem(file); if (itemKey.isEmpty() || buttonPluginFactory.itemKeys().count() != 1) { std::cerr << __LINE__ << ": ctkAbstractPluginFactory::registerLibrary() failed" << std::endl; return EXIT_FAILURE; } QTimer* timer = buttonPluginFactory.instantiate("foo"); if (timer != 0) { std::cerr << __LINE__ << ": ctkAbstractPluginFactory::instantiate() failed" << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; }