C++ createDir函数代码示例

void QInstallPage::createDirs(){
    QChar s = QDir::separator();
    /* Set installation status directory if not there already */
    //installationDir = henHouse() + tr("install_status") + s;
    installationDir = henHouse() + tr("log") + s;
    createDir(installationDir, false, henHouse());
    QDir::setCurrent(installationDir); //SETTING CURRENT DIR ON WRITEABLE AREA !!!!
    /* Create work area directory if not there already */
    createDir(egsHome(),true);
    /* Create work area bin directory if not there already */
    homeBinDir = egsHome() + tr("bin") + s + my_machine() + s;
    createDir(homeBinDir,true);
    /* Create pegs4 directory in work area if not there already */
    createDir(egsHome() + tr("pegs4") + s);
    createDir(egsHome() + tr("pegs4") + s + tr("inputs") + s);
    createDir(egsHome() + tr("pegs4") + s + tr("data")   + s);
    createDir(egsHome() + tr("pegs4") + s + tr("density")+ s);
    /* Create system bin directory if not there already */
    egsBinDir = henHouse() + tr("bin") + s + my_machine() + s;
    createDir(egsBinDir,true);
    /* Create system lib directory if not there already */
    egsLibDir = henHouse() + tr("lib") + s + my_machine() + s;
    createDir(egsLibDir,true);
    /* Create system dso directory if not there already */
    dsoDir = henHouse() + "egs++" + s + "dso" + s + my_machine() + s;
    createDir(dsoDir,true);
}

QString WidgetDigSignValidation::getRootDirectory( const QString& rootDirectory, const QString& processUid )
{
    QString result = NULL;
    QChar driveLetter(NULL);
    
    if ( rootDirectory.length() >= 1 ) 
    {
        driveLetter = rootDirectory[0];
        if (!driveLetter.isLetter())
            return QString();

        // Handle edge case when only drive letter is available from rootDirectory (and no subdirectories) 
        else if (rootDirectory.length() <= strlen("A:\\")) 
                result = QDir::toNativeSeparators( QString(driveLetter) + QDir::separator() + PrivateDirectory + QDir::separator() + processUid );
                
        // Use the passed driveletter and root dir
        else
        {
            QString rootDrive = rootDirectory;
            if (!(rootDrive.startsWith("\\") || rootDrive.startsWith("/")))
                rootDrive.remove(0, 2);
            QString rootPath = "";
            rootPath.append(driveLetter);
            rootPath = rootPath+':'+rootDrive;
            rootPath = QDir::toNativeSeparators(rootPath);
            result = rootPath;
        }
    } 
    else 
    {
        if (driveLetter.isNull()) {
            result = DefaultDrive + QDir::separator() + PrivateDirectory + QDir::separator() + processUid; //DefaultRootDirectory;
        }
    }
    
    QString installPath("");
    installPath = QDir::toNativeSeparators(result);
    
    if (installPath.startsWith("Z"))
        installPath.replace(0, 1, "C");
    
    QString privatePath = installPath[0]+":"+QDir::separator()+"private";
    if ( !createDir(privatePath) ) 
    {
        return QString();
    }
    
    if (! createDir(installPath)) {
        return QString();
    }
    installPath = installPath + QDir::separator() + WidgetFolder;
    
    if (! createDir(installPath)) {
        return QString();
    }
    return installPath;   
}

bool Install::createQiptablesDir()
{
    bool result = true;
    QString tmp;

    createDir(Install::INSTALL_DIR);
    createDir(QString("%1/%2").arg(Install::INSTALL_DIR).arg("tmp"));
    createDir(QString("%1/%2").arg(Install::INSTALL_DIR).arg("tools"));

    return result;
}

void createSaveDir(int slot) {
	// game slots are currently 1-4
	if (slot == 0) return;

	std::stringstream ss;
	ss << PATH_USER << "saves/" << SAVE_PREFIX << "/";

	createDir(path(&ss));

	ss << slot;
	createDir(path(&ss));
}

// Windows paths
void setPaths() {

	// handle Windows-specific path options
	if (getenv("APPDATA") != NULL) {
		PATH_CONF = PATH_USER = (std::string)getenv("APPDATA") + "\\flare";
		createDir(PATH_CONF);
		createDir(PATH_USER);

		PATH_CONF += "\\config";
		PATH_USER += "\\userdata";
		createDir(PATH_CONF);
		createDir(PATH_USER);
	}
	else {
		PATH_CONF = "config";
		PATH_USER = "userdata";
		createDir(PATH_CONF);
		createDir(PATH_USER);
	}

	createDir(PATH_USER + "\\mods");
	createDir(PATH_USER + "\\saves");

	PATH_DATA = "";
	if (dirExists(CUSTOM_PATH_DATA)) PATH_DATA = CUSTOM_PATH_DATA;
	else if (!CUSTOM_PATH_DATA.empty()) logError("Settings: Could not find specified game data directory.");

	PATH_CONF = PATH_CONF + "/";
	PATH_USER = PATH_USER + "/";
}

void ManageCrossPlayerData::saveData(CrossPlayerDataInfo * cross_player_data_info)
{
	createDir(CROSS_PLAYER_PATH);
	createDir(CROSS_PLAYER_PATH + cross_player_data_info->platform);
	string line_dir = CROSS_PLAYER_PATH + cross_player_data_info->platform + "/" + cross_player_data_info->line_id + "/";
	createDir(line_dir);
	string player_dir = line_dir + boost::lexical_cast<string>(cross_player_data_info->player_guid) + "/";
	createDir(player_dir);

	for (CrossPlayerDataInfo::MsgMap_t::iterator it = cross_player_data_info->msg_map.begin(); it != cross_player_data_info->msg_map.end(); ++it)
	{
		string file_name = player_dir + boost::lexical_cast<string>(it->first);
		saveFile(file_name, it->second->SerializeAsString());
	}
}

/* Archive::importDir
 * Imports all files (including subdirectories) from [directory] into
 * the archive
 *******************************************************************/
bool Archive::importDir(string directory)
{
	// Get a list of all files in the directory
	wxArrayString files;
	wxDir::GetAllFiles(directory, &files);

	// Go through files
	for (unsigned a = 0; a < files.size(); a++)
	{
		string name = files[a];
		name.Replace(directory, "", false);	// Remove directory from entry name

		// Split filename into dir+name
		wxFileName fn(name);
		string ename = fn.GetFullName();
		string edir = fn.GetPath();

		// Remove beginning \ or / from dir
		if (edir.StartsWith("\\") || edir.StartsWith("/"))
			edir.Remove(0, 1);

		// Add the entry
		ArchiveTreeNode* dir = createDir(edir);
		ArchiveEntry* entry = addNewEntry(ename, dir->numEntries()+1, dir);

		// Load data
		entry->importFile(files[a]);

		// Set unmodified
		entry->setState(0);
		dir->getDirEntry()->setState(0);
	}

	return true;
}

bool CFileHelper::createDirs(const char* szDir)
{
    if (szDir == NULL)
    {
        ScutLog("createDirs Error %s %d", szDir, __LINE__);
        return false;
    }

    const char *pBegin = szDir;
    const char *pend = szDir;
    do 	{
        char szBuf[MAX_PATH];
        pend = strchr(pend,FILE_SEP);
        if (NULL != pend)
        {
            ++pend;
            int nSize = pend-pBegin;
            memcpy(szBuf,pBegin,nSize);
            szBuf[nSize] = '\0';
            std::string dir;
            dir = szBuf;
            if (!isDirExists(dir.c_str()))
            {
                if(!createDir(dir.c_str()))
                {
                    ScutLog("createDirs Error %s %d", szDir, __LINE__);
                    break;
                }
            }
        }
    } while (NULL != pend);

    return true;
}

/*
 bool KDirectory::isDirEmpty( const KData& fullDir )
 {
 KData dtDir = fullDir;
 dtDir.makePath( true );
 DIR* dir;
 if ( (dir=opendir(dtDir.getData())) == NULL )
 return false;
 struct dirent *pDirent;
 while( ( pDirent = readdir(dir) ) != NULL  )
 {
 struct stat statbuf;
 KData dtPath = dtDir;
 dtPath += pDirent->d_name;
 if ( stat(dtPath.getData(),&statbuf) == -1 )
 continue;
 if ( S_ISDIR(statbuf.st_mode) )
 {
 if ( pDirent->d_name && strcmp(pDirent->d_name,".") && strcmp(pDirent->d_name,"..") )
 {
 if ( !isDirEmpty(dtPath) )
 {
 closedir( dir );
 return false;
 }
 }
 }
 else
 {
 closedir( dir );
 return false;
 }
 }
 closedir( dir );
 return true;

 }
 */
bool KDirectory::open(const KData& directory, bool create)
{
	if (directory.isEmpty())
	{
		return false;
	}

	KData dir = directory;
	int pos;
	KData dtKData = "\\";
	while ((pos = dir.find(dtKData)) != -1)
	{
		dir.replace(pos, 1, "/");
	}
	_directory.erase();

	bool bDirExist = isDirectoryExist(dir);
	if (!bDirExist)
	{
		if (create)
		{
			if (!createDir(dir))
				return false;
		}
		else
		{
			return false;
		}
	}
	_directory = dir;
	_directory.makePath();
	return true;
}

// -----------------------------------------------------------------------------
// Imports all files (including subdirectories) from [directory] into the
// archive
// -----------------------------------------------------------------------------
bool Archive::importDir(string_view directory)
{
	// Get a list of all files in the directory
	vector<string> files;
	for (const auto& item : std::filesystem::recursive_directory_iterator{ directory })
		if (item.is_regular_file())
			files.push_back(item.path().string());

	// Go through files
	for (const auto& file : files)
	{
		StrUtil::Path fn{ StrUtil::replace(file, directory, "") }; // Remove directory from entry name

		// Split filename into dir+name
		auto ename = fn.fileName();
		auto edir  = fn.path();

		// Remove beginning \ or / from dir
		if (StrUtil::startsWith(edir, '\\') || StrUtil::startsWith(edir, '/'))
			edir.remove_prefix(1);

		// Add the entry
		auto dir   = createDir(edir);
		auto entry = addNewEntry(ename, dir->numEntries() + 1, dir);

		// Load data
		entry->importFile(file);

		// Set unmodified
		entry->setState(ArchiveEntry::State::Unmodified);
		dir->dirEntry()->setState(ArchiveEntry::State::Unmodified);
	}

	return true;
}

bool FolderScanner::createDir(const string &path, bool allowRecursive)
{
    if (isDir(path))
        return true;

    std::cout << "creating dir <" << path << ">" << std::endl;

    std::system(("mkdir " + path).c_str());

    if (!isDir(path))
    {
        if (!allowRecursive) {
            L_ERROR_P("couldn't create dir <%s>", path.c_str());
            return false;
        }
        L_INFO_P("creating subfolders of <%s>", path.c_str());

        auto subfolders = HelperUtils::stringSplit(path, PATH_SEPARATOR[0]);
        string p;
        for (auto& subfolder : subfolders)
        {
            if (!p.empty()) p += PATH_SEPARATOR;
            p += subfolder;

            if (!createDir(p, false))
                return false;
        }
    }
    return true;
}

/*
 * Creates a directory. We can ignore mode since we're not dealing with
 * permissions, as long as getattr returns appropriate ones for us.
 */
static int cs1550_mkdir(const char *path, mode_t mode)
{
	(void) mode;

	char dir[MAX_FILENAME + 1];
	char fileName[MAX_FILENAME + 1];
	char ext[MAX_EXTENSION + 1];

	getPath(path, dir, fileName, ext);
	int pathType = getPathType(path, dir, fileName, ext);

	if (strlen(dir) >= MAX_FILENAME) {
		return -ENAMETOOLONG;
	}
	else if (dirExists(dir) == 1){
			return -EEXIST;
	}
	else if (pathType != 1){
		return -EPERM;
	}
	else {
				cs1550_root_directory r;
				getRoot(&r);
				if (r.nDirectories < MAX_DIRS_IN_ROOT) {
					createDir(dir);
				}
			}
	return 0;
}

	bool XlsWriter::writeToFile( const string &filePath, const XlsSheetStruct &xlsSheet, SheetFormat sheetFormat ){
		string folderPath = filePath.substr( 0, filePath.find_last_of('/', filePath.size() )+1 );
		if( !createDir( folderPath ) )  return false;
	
		workbook wb;
		worksheet *ws;
		xf_t *xf = wb.xformat();
		ws = wb.sheet("sheet1");

		cell_t *p_Cell;
		int line(0), column(0);
		for( XlsSheetStruct::const_iterator citerRow = xlsSheet.begin(); citerRow != xlsSheet.end(); ++citerRow ){
			column = 0;
			for( XlsRowStruct::const_iterator citer = citerRow->begin(); citer != citerRow->end(); ++citer ){
				p_Cell = ws->label( line, column, *citer, xf );
				//p_Cell->fontcolor( (xlslib_core::color_name_t)getXlsColor( sheetFormat.getFontColor( line, column ) ) );
				int long_color = getXlsColor( sheetFormat.getFontColor( line, column ) );
//				int long_color = CLR_RED;
				p_Cell->fontcolor( (xlslib_core::color_name_t)(long_color) );
				++column;
			}
			++line;
		}

		wb.Dump( filePath);

		return true;
	}

int main(int argc, char *argv[])
{
    int  i      = 0;
    int  numDir = 5;
    FILE *file  = NULL;
    char *buffer[20];

    signal(SIGALRM, SIG_DFL);
    alarm(2);
    signal(SIGALRM, handler_alarm);
    createDir();

    for (i = 0; i < numDir; i++)
    {
        printf("Creando archivos\n");
        int signal;
        flag = 1;
        file = fopen(buffer, "w+");
        sprintf(buffer, "./Data/a%d", i);
        alarm(3);
        while (flag)
            fputc('x', file);
        fclose(file);
    }
    printf("INFO\n\n");
    printDir();

    return 0;
}

/* main test functions */
int create(void)
{
   char buf[4096];
   char *s;
   int i;
   int ret = 1;
   char *spec;
   if ( ret && createDir(testDir) )
      ret = 0;

   if ( totalSize < maxSize )
   {
       maxSize = totalSize;
   }
   int nb = maxSize;
   spec = specToName(0, nb, csv);

   STARTTIME();
   for(i=0;i < nb &&createFileBefore;i++)
   {
      snprintf(buf,sizeof(buf), "%s/f_%d",testDir,i);
      int fd = open(buf, O_WRONLY | O_CREAT | O_TRUNC, 0666);
      if ( fd > 0 )
      {
         close(fd);
      }
      else
      {
         ret = 0;
         break;
      }
   }
   ENDTIME();
   SETDT();
   double createPerSecond = nb*1000000.0/dt;

   fprintf(stdout,"Create %-18s time %8.3f sec %8.0f     F/s\n",
           spec,
           (double)dt/1000000,
           createPerSecond
           );
   STARTTIME();
   for(i=0;i < nb; i++)
   {
      snprintf(buf,sizeof(buf),"%s/f_%d",testDir,i);
      deleteFile(buf);
   }
   ENDTIME();
   SETDT();
   createPerSecond = nb*1000000.0/dt;
   fprintf(stdout,"Delete %-18s time %8.3f sec %8.0f     F/s\n",
           spec,
           (double)dt/1000000,
           createPerSecond
           );
   
   deleteTestDir(1);
   return ret;
}