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;
}

void
CBFileListTable::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 directory
bool 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());

	}