自学教程：C++ FileInfo函数代码示例

int main(int argc, const char* argv[]){  FileInfo info(argv[1]);  cout << "1 -- " << endl;  cout << " Basename = " << info.Basename() << endl;  cout << " dirname = " << info.dirname() << endl;  cout << " realpath = " << info.realpath() << endl;  cout << endl << "2 -- " << endl;  cout << " Basename = " << FileInfo(argv[1]).Basename() << endl;  cout << " dirname = " << FileInfo(argv[1]).dirname() << endl;  cout << " realpath = " << FileInfo(argv[1]).realpath() << endl;}

bool CModelManager::AddModelReference(const std::string& fileName, bool mirrored, int objRank){    auto it = m_models.find(FileInfo(fileName, mirrored));    if (it == m_models.end())    {        if (!LoadModel(fileName, mirrored))            return false;        it = m_models.find(FileInfo(fileName, mirrored));    }    m_engine->SetObjectBaseRank(objRank, (*it).second.baseObjRank);    return true;}

bool TPluginSpecPrivate::Read(const QString &SpecFile)   {      Name = Version = /*CompatVersion =*/ Vendor = Copyright = License = Description = Url = /*Location =*/ "";      State = TPluginSpec::Invalid;      HasError = false;      ErrorString = "";      Dependencies.clear();      QFile File(SpecFile);      if(!File.exists())         return ReportError(QString("TPluginSpecPrivate::Read(const QString &SpecFile): File does not exist: %1").arg(File.fileName()));      if(!File.open(QIODevice::ReadOnly))         return ReportError(QString("TPluginSpecPrivate::Read(const QString &SpecFile): Could not open file for read: %1").arg(File.fileName()));      QFileInfo FileInfo(File);      Location = FileInfo.absolutePath();      //FilePath = fileInfo.absoluteFilePath();      QXmlStreamReader XmlReader(&File);      while(!XmlReader.atEnd())         {            XmlReader.readNext();            if(XmlReader.tokenType() == QXmlStreamReader::StartElement)                ReadPluginSpec(XmlReader);         }      if(XmlReader.hasError())         return ReportError(QString("TPluginSpecPrivate::Read(const QString &SpecFile): Error parsing file %1: %2, at line %3, column %4")                            .arg(File.fileName()).arg(XmlReader.errorString()).arg(XmlReader.lineNumber()).arg(XmlReader.columnNumber()));      State = TPluginSpec::Read;      return true;   }

bool DatabaseWrapperBase::LookupAttachment(FileInfo& attachment,        int64_t id,        FileContentType contentType){    SQLite::Statement s(db_, SQLITE_FROM_HERE,                        "SELECT uuid, uncompressedSize, compressionType, compressedSize, uncompressedMD5, compressedMD5 FROM AttachedFiles WHERE id=? AND fileType=?");    s.BindInt64(0, id);    s.BindInt(1, contentType);    if (!s.Step())    {        return false;    }    else    {        attachment = FileInfo(s.ColumnString(0),                              contentType,                              s.ColumnInt64(1),                              s.ColumnString(4),                              static_cast<CompressionType>(s.ColumnInt(2)),                              s.ColumnInt64(3),                              s.ColumnString(5));        return true;    }}

	void getFileListFromZip(VectorFileInfo& _result, const char*_zipfile,  const std::string& _folder, const std::string& filename)	{		unzFile pFile = NULL;		std::string path = _folder + filename;		bool isDir = false;				pFile = unzOpen(_zipfile);		if (!pFile)			return;		do		{			int nRet = unzLocateFile(pFile, path.c_str(), 1);			CC_BREAK_IF(UNZ_OK != nRet);						char szFilePathA[260];			unz_file_info unzInfo;			nRet = unzGetCurrentFileInfo(pFile, &unzInfo, szFilePathA, sizeof(szFilePathA), NULL, 0, NULL, 0);			CC_BREAK_IF(UNZ_OK != nRet);						if (szFilePathA[unzInfo.size_filename - 1] == '/' ||			    szFilePathA[unzInfo.size_filename - 1] == '//')				isDir = true;			else				isDir = false;							_result.push_back(FileInfo(filename, isDir));		} while (0);				unzClose(pFile);	}

void QVolumeSocketData::Send(QBaseSocket* Socket, QByteArray& Data){	QByteArray Voxels((char*)this->Voxels, this->NoBytes);		QByteArray ByteArray;	QDataStream DataStream(&ByteArray, QIODevice::WriteOnly);	DataStream.setVersion(QDataStream::Qt_4_0);	QFileInfo FileInfo(this->FileName);	DataStream << FileInfo.fileName();			DataStream << this->Resolution[0];	DataStream << this->Resolution[1];	DataStream << this->Resolution[2];	DataStream << this->Spacing[0];	DataStream << this->Spacing[1];	DataStream << this->Spacing[2];			DataStream << Voxels;	DataStream << this->NoBytes;	QSocketData::Send(Socket, ByteArray);}

bool ListFilesInDirectory(const String & directoryPath, std::vector<FileInfo> & fi){	WIN32_FIND_DATA findData;	HANDLE hFind;	// "C:/Windows" needs to be "C:/Windows/*" for FindFirstFile to work	String workingDirPath = directoryPath;	workingDirPath.append(L"//*");	hFind = FindFirstFile(workingDirPath.c_str(), &findData);	if (hFind == INVALID_HANDLE_VALUE)	{		return false;	}	do	{ 		// exclude '.' & '..'		String filename (findData.cFileName);		if (filename != L"." && filename != L"..")		{			fi.push_back(FileInfo(directoryPath, filename));		}	} 	while (FindNextFile(hFind, &findData));	DWORD err = GetLastError();	// no files left, we listed all of them	return err == ERROR_NO_MORE_FILES;}

// Calls all writing functions and generates 3D files.void TrackGen::Generate(){	PrepareForGeneration();	CreateSegment();	// Decides whether to generate X segments, or keep adding until a minimum length is met.	if (_segmentLimit != -1)		_totalLength = std::numeric_limits<float>::max();	else		_segmentLimit = INT_MAX;	CreateSegment();	while (_totalLength < _lengthLowerLimit)// && _sectionNumber < _segmentLimit)	{		if (rand() % 100 < 70)			CreateCurveSegment();		else			CreateSegment();	}	ConnectToEnd();	if (_returnCode)	{			std::cout << "Intersection";		return;	}	// If X position of final segment is not within 0.01 of starting point, the track is deemed to have not connected.	if (_segmentList.back()->GetEndPos().x > 0.01 || _segmentList.at(_segmentList.size()-1)->GetEndPos().x < -0.01)	{		std::cout << "No end meet.";		_returnCode = true;		return;	}	WriteSegmentsToXML();		// Generate 3D files and copy files.	std::string generateName;	// Copy files into track directory.	if (_torcsDirectory.length() > 0)	{		generateName = "/"" + _torcsDirectory + "//trackgen.exe/" -c road -n " + _trackName;		system(generateName.c_str());		std::string copyCommand = "copy /"tracks//road//" + _trackName + "/" /"" + _torcsDirectory + "//tracks//road//" + _trackName;		system(copyCommand.c_str());			// Remove temporary folder from directory.		std::string removeFolder = "RD tracks /S /Q";		system(removeFolder.c_str());	}	else 	{		generateName = "trackgen.exe -c road -n " + _trackName;		system(generateName.c_str());	}		FileInfo();}

int main(int argc, char** argv){    const s_plf_version_info * libplf_version;    printf("/n/nplfinfo/n");    printf("****************/n");    printf("2011 & 2015 scorp2kk & @SteveClement/n");    printf("/n/n");    libplf_version = plf_lib_get_version();    printf("libplf Version: %d.%d.%d/n/n", libplf_version->major, libplf_version->minor, libplf_version->bugfix);    if (parse_options(argc, argv) < 0 || input_file_name == 0)    {        print_help("plfinfo");        return 0;    }    printf("Input file: %s/n", input_file_name);    FileInfo(input_file_name);    printf("==> DONE <==/n/n");    return 0;}

voidCBFileListTable::ReadSetup	(	istream&			input,	const JFileVersion	vers	){	RemoveAllFiles();	JSize fileCount;	input >> fileCount;	StopListening(GetFullNameDataList());	JString fileName;	for (JIndex i=1; i<=fileCount; i++)		{		JFAID_t id;		time_t t;		input >> fileName >> id >> t;		JIndex index;		const JBoolean isNew = JXFileListTable::AddFile(fileName, &index);		assert( isNew );		itsFileInfo->InsertElementAtIndex(index, FileInfo(id, t));		}	ListenTo(GetFullNameDataList());	if (vers >= 80)		{		input >> itsLastUniqueID;		}

void DirectoryNavigation::SetDestinationPath(const string& path){	_currentDirectory = path;	_dirName.clear();	DIR *d = opendir(path.c_str());	dirent* dir;	if(d)	{		while((dir = readdir(d)) != NULL)		{			IconType icon = FindType(dir);			_dirName.push_back(FileInfo(dir->d_name, icon));		}		closedir(d);	}	_dirName.pop_front();	_dirName.pop_front();	std::sort(_dirName.begin(), _dirName.end());}

void Manifest::awaken(Origin origin) const{    if (!m_remote.at(origin)) return;    const std::size_t chunk(origin / m_chunkSize * m_chunkSize);    const auto m(m_endpoint.getSubEndpoint("m"));    const auto bytes(io::ensureGet(m, std::to_string(chunk)));    const auto json(parse(bytes->data()));    std::lock_guard<std::mutex> lock(m_mutex);    if (!json.isArray())    {        throw std::runtime_error(                "Invalid file-info chunk - expected array: " +                json.toStyledString());    }    else if (json.size() != std::min(m_chunkSize, size() - chunk))    {        throw std::runtime_error("Invalid file-info chunk - unexpected size");    }    std::size_t i(chunk);    for (const auto& f : json)    {        m_fileInfo.at(i) = FileInfo(f);        m_remote.at(i) = false;        ++i;    }}

// Returns true if the path exists and is a directorybool IsDirectory(const std::string& path){#ifdef _WIN32  return PathIsDirectory(UTF8ToUTF16(path).c_str());#else  return FileInfo(path).IsDirectory();#endif}

int CModelManager::GetModelBaseObjRank(const std::string& fileName, bool mirrored){    auto it = m_models.find(FileInfo(fileName, mirrored));    if (it == m_models.end())        return -1;    return (*it).second.baseObjRank;}

	SourceIndex::FileInfo FileInfo::getFileInfo(ConstStrW fname)	{		IFileIOServices &svc = IFileIOServices::getIOServices();		PFolderIterator iter = svc.getFileInfo(fname);		return FileInfo(FilePath(iter->getFullPath(), false), iter->getModifiedTime());	}

 FileInfo RunManager_Util::dirFile(QFileInfo fi)  {   fi.refresh();   return FileInfo(toString(fi.fileName()),       (fi.exists()&&fi.lastModified().isValid())?toDateTime(fi.lastModified()):openstudio::DateTime(),       toString(fi.fileName()), /* The default key is the filename */       toPath(fi.absoluteFilePath()),       fi.exists()); }

	static const FileInfo * getInfo(const char *filename) {		set<FileInfo>::iterator it = FileInfo::cActiveFileInfo.find(FileInfo(filename));		if(it != FileInfo::cActiveFileInfo.end()) {			return &(*it);		}		else {			return NULL;		}	}

FileInfoMap FileSystem::filesInfoFromPath( const std::string& path ){	FileInfoMap files;	String tpath( path );	if ( tpath[ tpath.size() - 1 ] == '/' || tpath[ tpath.size() - 1 ] == '//' )	{		tpath += "*";	}	else	{		tpath += "//*";	}	WIN32_FIND_DATAW findFileData;	HANDLE hFind = FindFirstFileW( (LPCWSTR)tpath.toWideString().c_str(), &findFileData );	if( hFind != INVALID_HANDLE_VALUE )	{		std::string name( String( findFileData.cFileName ).toUtf8() );		std::string fpath( path + name );		if ( name != "." && name != ".." )		{			files[ name ] = FileInfo( fpath );		}		while( FindNextFileW( hFind, &findFileData ) )		{			name = String( findFileData.cFileName ).toUtf8();			fpath = path + name;			if ( name != "." && name != ".." )			{				files[ name ] = FileInfo( fpath );			}		}		FindClose( hFind );	}	return files;}

void CModelManager::UnloadModel(const std::string& fileName, bool mirrored){    auto it = m_models.find(FileInfo(fileName, mirrored));    if (it == m_models.end())        return;    m_engine->DeleteBaseObject((*it).second.baseObjRank);    m_models.erase(it);}

void FileEx::ListDirectory(){	pos = 0;	topline = 0;	std::tstring search(path);	search += _T("//*");	WIN32_FIND_DATA fd;	HANDLE hFile = ::FindFirstFile(search.c_str(), &fd);	if (hFile == INVALID_HANDLE_VALUE)	{		DWORD dwError = ::GetLastError();		std::tcerr << _T("::FindFirstFile failed. : ") << dwError << std::endl;		path = path.substr(0, path.find_last_of(_T("//")));		::FindClose(hFile);		return;	}	filelist.clear();	std::list<FileInfo> dirlist;	std::list<FileInfo> normallist;	do {		if (fd.cFileName == std::tstring(_T(".")))			continue;		bool bDir = ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);		if (bDir)			dirlist.push_back(FileInfo(fd.cFileName, bDir));		else			normallist.push_back(FileInfo(fd.cFileName, bDir));	} while (::FindNextFile(hFile, &fd));	filelist.insert(filelist.cend(), dirlist.begin(), dirlist.end());	filelist.insert(filelist.cend(), normallist.begin(), normallist.end());	::FindClose(hFile);}

    void visitProduct(const ResolvedProductConstPtr &product)    {        QBS_CHECK(product->buildData);        ArtifactVisitor::visitProduct(product);        // For target artifacts, we have to update the on-disk timestamp, because        // the executor will look at it.        for (Artifact * const targetArtifact : product->targetArtifacts()) {            if (FileInfo(targetArtifact->filePath()).exists())                QFile(targetArtifact->filePath()).open(QIODevice::WriteOnly | QIODevice::Append);        }    }

void FileWatcher :: unwatchfile(const char *filename) {    if(!g_filewatcher) g_filewatcher = new FileWatcherImpl();	set<FileInfo>::iterator it = FileInfo::cActiveFileInfo.find(FileInfo(filename));	if(it != FileInfo::cActiveFileInfo.end()) FileInfo::cActiveFileInfo.erase(it);    if(!inotifytools_remove_watch_by_filename(filename)) {        int err = inotifytools_error();        printf("Error: unwatchingfile %d/n", err);        return;    }}

const char* FileInfo::realpath(){	char* pt = strdup( _path.c_str());    string dir = ::dirname(pt);	free(pt);	_realpath = _path;	if ( dir[0] == '~' )	{//		const char* pt = getenv("HOME");		const gchar* pt = g_get_home_dir() ;		if ( pt != NULL )			dir = pt + dir.substr(1);	}	else if ( dir[0] == '$' )	{		char varname[80];		const char* pt;		int i;		for ( i=0, pt = dir.c_str()+1;			*pt && *pt != ')' && strncmp(pt,_path_delim,1) ; ++pt )			if ( *pt == '(' ) continue;			else varname[i++] = *pt;		varname[i] = 0;		if ( *pt == ')' ) ++pt;		if ( varname[0] ) {			const char* pt2 = getenv(varname);			if ( pt2 != NULL ) {				dir = string(pt2) + string(pt);			} else				Log::err() << "Error in FileInfo::realpath : undefined environment variable " << varname << endl;		}	}	else if ( dir[0] == '.' )	{  		char resolved[MAXPATHLEN];		char current[MAXPATHLEN];		if ( getcwd(current, sizeof(current)) == NULL )			return "";  // rep courant indefini		if ( chdir(dir.c_str()) != 0 )			return ""; // path invalide		getcwd(resolved, sizeof(resolved));		chdir (current);		dir=resolved;	}	_realpath = FileInfo(dir).join(Basename());	return _realpath.c_str();}

void CrabRibbonBaseUI::dropEvent(QDropEvent *event){    QList<QUrl> urls = event->mimeData()->urls(); if(urls.isEmpty()) {return;}    QString FilePath = urls.first().toLocalFile(); QFileInfo FileInfo(FilePath);    if(!FileInfo.isFile()) {qDebug() << "CrabRibbonBaseUI::dropEvent() File should be a file!"; return;}    if(!FileInfo.isReadable()) {qDebug() << "CrabRibbonBaseUI::dropEvent() Error! File is unreadable!"; return;}    //QString FileType = FilePath.section(".",-1); //section separated by ".", and -1 means start from the right end.    //if(FileType!="pdf") {qDebug() << "CrabPDFReader::dropEvent() Error! File should be a pdf!"; return;}    /* Send open file signal */    emit signal_open_file(FilePath);    QWidget::dropEvent(event);}

QScriptValue File::js_lastModified(QScriptContext *context, QScriptEngine *engine){    Q_UNUSED(engine);    if (Q_UNLIKELY(context->argumentCount() < 1)) {        return context->throwError(QScriptContext::SyntaxError,                                   Tr::tr("File.lastModified() expects an argument"));    }    const QString filePath = context->argument(0).toString();    const FileTime timestamp = FileInfo(filePath).lastModified();    const auto se = static_cast<ScriptEngine *>(engine);    se->addFileLastModifiedResult(filePath, timestamp);    return timestamp.asDouble();}

bool DlgCompareDir::FetchDir(String dir, VectorMap<String, FileInfo>& files, VectorMap<String, String>& dirs){	FindFile ff;	if(!ff.Search(AppendFileName(dir, "*")))		return false;	do		if(ff.IsFile() && PatternMatchMulti(fm, ff.GetName()))			files.Add(NormalizePathCase(ff.GetName()), FileInfo(ff.GetName(), ff.GetLength(), ff.GetLastWriteTime()));		else if(ff.IsFolder())			dirs.Add(NormalizePathCase(ff.GetName()), ff.GetName());	while(ff.Next());	return true;}

  Job JobFactory::createIdfToModelJob(      const openstudio::path &t_idf,      const openstudio::path &t_outdir,      const boost::optional<openstudio::UUID> &t_uuid)  {    JobParams params;    params.append("outdir", toString(t_outdir));    Files files;    files.append(FileInfo(t_idf, "idf"));    return createIdfToModelJob(Tools(), params, files, std::vector<openstudio::URLSearchPath>(), t_uuid);  }

  Files OpenStudioPostProcessJob::outputFilesImpl() const  {    // Dan: what's the output files generated?    if (!boost::filesystem::exists(outdir() / toPath("report.xml")))    {      // no output file has been generated yet      return Files();    }    Files f;    f.append(FileInfo(outdir() / toPath("report.xml"), "xml"));    return f;  }