vector< string > ScanFolder( const char* dir_path ) { vector< string > file_vec; tinydir_dir dir; //==== Open Path ====// if ( tinydir_open( &dir, dir_path ) == -1 ) { tinydir_close( &dir ); return file_vec; } //==== Load Files ====// while ( dir.has_next ) { tinydir_file file; if ( tinydir_readfile( &dir, &file ) == -1 ) { } else if ( file.is_dir ) { } else { file_vec.push_back( file.name ); } tinydir_next( &dir ); } return file_vec; }
void MapParser::initCinematique(Cinematique* cinematique, CinematiqueView* cinematiqueView, const char* dossier) { tinydir_dir dir; tinydir_open(&dir, dossier); int nbImages = 0; while(dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if (!file.is_dir && file.name[0]!='T') { nbImages++; } tinydir_next(&dir); } tinydir_close(&dir); std::cout << "nb images cinematique " << dossier << " : " << nbImages << std::endl; cinematique->setNbImages(nbImages); cinematiqueView->m_cinematique = cinematique; for(int i=0; i<nbImages; i++) { std::stringstream s; s << dossier << "/" << i << ".png"; cinematiqueView->m_tex_images.push_back(sf::Texture()); cinematiqueView->m_tex_images.at(i).loadFromFile(s.str()); } }
int ScanFolder() { tinydir_dir dir; if ( tinydir_open( &dir, "." ) == -1 ) { perror( "Error opening file" ); goto bail; } while ( dir.has_next ) { tinydir_file file; if ( tinydir_readfile( &dir, &file ) == -1 ) { perror( "Error getting file" ); goto bail; } printf( "%s", file.name ); if ( file.is_dir ) { printf( "/" ); } printf( "\n" ); tinydir_next( &dir ); } bail: tinydir_close( &dir ); return 0; }
static ERR_VALUE _obtain_files(PPOINTER_ARRAY_char Array, const size_t MaxCount, tinydir_dir *Dir) { ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = ERR_SUCCESS; pointer_array_clear_char(Array); if (Dir->has_next) { for (size_t i = 0; i < MaxCount; ++i) { tinydir_file file; char *str = NULL; if (ret != ERR_SUCCESS || !Dir->has_next) break; tinydir_readfile(Dir, &file); if (strcmp(file.name, ".") == 0 || strcmp(file.name, "..") == 0) { tinydir_next(Dir); continue; } ret = utils_copy_string(file.path, &str); if (ret == ERR_SUCCESS) pointer_array_push_back_no_alloc_char(Array, str); if (ret != ERR_SUCCESS || !Dir->has_next) break; tinydir_next(Dir); } } return ret; }
std::string TinyDirInterface::getNextEntry(bool includeBasePath) { if (!isOpen_) return{}; std::string str{}; bool foundEntry = false; while (resource_.has_next && !foundEntry) { // query next entry tinydir_file file; int errnum = tinydir_readfile(&resource_, &file); if (errnum != 0) { // cannot access entry std::string errMsg{ "Cannot access entry in \"" }; errMsg.append(resource_.path); errMsg.append("\": "); errMsg.append(strerror(errnum)); throw FileException(errMsg); } // check whether entry matches current ListMode setting foundEntry = ((mode_ == ListMode::FilesAndDirectories) || ((file.is_dir == 0) != (mode_ == ListMode::DirectoriesOnly))); if (foundEntry) { str = (includeBasePath ? file.path : file.name); } tinydir_next(&resource_); } // close resource if no more entries are available if (!resource_.has_next) { close(); } return str; }
void FileSystem::ReadFolder(const std::string& dir) { tinydir_dir d; tinydir_open(&d, dir.c_str()); while (d.has_next) { tinydir_file file; tinydir_readfile(&d, &file); if (file.is_dir && strcmp(file.name, ".") && strcmp(file.name, "..")) { ReadFolder(file.path); } else { if (strcmp(file.name, ".") && strcmp(file.name, "..")) { (*this)[file.name] = file.path; } } tinydir_next(&d); } tinydir_close(&d); }
mrb_value mrb_dir_entries(mrb_state* mrb, mrb_value self) { mrb_value entries = mrb_ary_new(mrb); mrb_value dirname; mrb_get_args(mrb, "S", &dirname); const char* name = mrb_string_value_ptr(mrb, dirname); tinydir_dir dir; if (tinydir_open(&dir, name) == -1) { mrb_raisef(mrb, E_RUNTIME_ERROR, "Error opening file: %S", mrb_str_new_cstr(mrb, name)); } while (dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); mrb_ary_push(mrb, entries, mrb_str_new_cstr(mrb, file.name)); tinydir_next(&dir); } tinydir_close(&dir); return entries; }
std::list<std::string> getFilesInDirs(const std::list<std::string> & directory_list) { std::list<std::string> files; for (std::list<std::string>::const_iterator it = directory_list.begin(); it != directory_list.end(); ++it) { tinydir_dir dir; dir.has_next = 0; // Avoid a garbage value in has_next (clang StaticAnalysis) tinydir_open(&dir, it->c_str()); while (dir.has_next) { tinydir_file file; file.is_dir = 0; // Avoid a garbage value in is_dir (clang StaticAnalysis) tinydir_readfile(&dir, &file); if (!file.is_dir) files.push_back(*it + "/" + file.name); tinydir_next(&dir); } tinydir_close(&dir); } return files; }
// // 1. Iterates through the chisel files on disk (.sc and .lua) // 2. Opens them and extracts the fields (name, description, etc) // 3. Adds them to the chisel_descs vector. // void sinsp_chisel::get_chisel_list(vector<chisel_desc>* chisel_descs) { for(vector<chiseldir_info>::const_iterator it = g_chisel_dirs->begin(); it != g_chisel_dirs->end(); ++it) { if(string(it->m_dir).empty()) { continue; } tinydir_dir dir; tinydir_open(&dir, it->m_dir); while(dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); string fpath(file.path); bool add_to_vector = false; chisel_desc cd; filename fn = split_filename(string(file.name)); if(fn.ext != "sc" && fn.ext != "lua") { goto next_file; } for(vector<chisel_desc>::const_iterator it_desc = chisel_descs->begin(); it_desc != chisel_descs->end(); ++it_desc) { if(fn.name == it_desc->m_name) { goto next_file; } } cd.m_name = fn.name; #ifdef HAS_LUA_CHISELS if(fn.ext == "lua") { add_to_vector = init_lua_chisel(cd, fpath); } if(add_to_vector) { chisel_descs->push_back(cd); } #endif next_file: tinydir_next(&dir); } tinydir_close(&dir); } }
static void LoadArchivePics( PicManager *pm, const char *archive, const char *dirname) { char *buf = NULL; char path[CDOGS_PATH_MAX]; sprintf(path, "%s/%s", archive, dirname); tinydir_dir dir; if (tinydir_open(&dir, path) != 0) { LOG(LM_MAP, LL_DEBUG, "no pic dir(%s): %s", path, strerror(errno)); goto bail; } while (dir.has_next) { tinydir_file file; if (tinydir_readfile(&dir, &file) != 0) { LOG(LM_MAP, LL_WARN, "cannot read file: %s", strerror(errno)); break; } if (!file.is_reg) goto nextFile; long len; buf = ReadFileIntoBuf(file.path, "rb", &len); if (buf == NULL) goto nextFile; SDL_RWops *rwops = SDL_RWFromMem(buf, len); bool isPng = IMG_isPNG(rwops); if (isPng) { SDL_Surface *data = IMG_Load_RW(rwops, 0); if (data != NULL) { char nameBuf[CDOGS_FILENAME_MAX]; PathGetBasenameWithoutExtension(nameBuf, file.path); PicManagerAdd(&pm->customPics, &pm->customSprites, nameBuf, data); } } rwops->close(rwops); nextFile: CFREE(buf); buf = NULL; if (tinydir_next(&dir) != 0) { printf( "Could not go to next file in dir %s: %s\n", path, strerror(errno)); goto bail; } } bail: CFREE(buf); tinydir_close(&dir); }
static void LoadArchiveSounds( SoundDevice *device, const char *archive, const char *dirname) { char *buf = NULL; char path[CDOGS_PATH_MAX]; sprintf(path, "%s/%s", archive, dirname); tinydir_dir dir; if (tinydir_open(&dir, path) != 0) { LOG(LM_MAP, LL_DEBUG, "no sound dir(%s): %s", path, strerror(errno)); goto bail; } while (dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if (!file.is_reg) goto nextFile; long len; buf = ReadFileIntoBuf(file.path, "rb", &len); if (buf == NULL) goto nextFile; SDL_RWops *rwops = SDL_RWFromMem(buf, len); Mix_Chunk *data = Mix_LoadWAV_RW(rwops, 0); if (data != NULL) { char nameBuf[CDOGS_FILENAME_MAX]; strcpy(nameBuf, file.name); // Remove extension char *dot = strrchr(nameBuf, '.'); if (dot != NULL) { *dot = '\0'; } SoundAdd(&device->customSounds, nameBuf, data); } rwops->close(rwops); nextFile: CFREE(buf); buf = NULL; if (tinydir_next(&dir) != 0) { printf( "Could not go to next file in dir %s: %s\n", path, strerror(errno)); goto bail; } } bail: CFREE(buf); tinydir_close(&dir); }
void MapParser::initZonesFromFiles() { std::string racineZones("./zones"); std::cout << "ouverture dossier zones" << std::endl; tinydir_dir dir; tinydir_open(&dir, racineZones.c_str()); while(dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if (file.is_dir && file.name[0]!='.') { std::string chemin = racineZones + "/" + file.name; std::cout << chemin << std::endl; parseAndInit(chemin, TAILLE_CASE_X, TAILLE_CASE_Y); } tinydir_next(&dir); } tinydir_close(&dir); //vérification debug: std::cout << "## portails trouvés : ##" << std::endl; std::map<sf::Uint32, std::pair<Destination, Destination> >::iterator it; for(it=m_portails.begin(); it!=m_portails.end(); it++) { std::cout << " " << it->first << "=>[ (zone:" << it->second.first.m_numZone << " \tx:" << it->second.first.m_x << " \ty:" << it->second.first.m_y << ") ~ (zone:" << it->second.second.m_numZone << " \tx:" << it->second.second.m_x << " \ty:" << it->second.second.m_y << ") ]\n"; } std::cout << "## (fin portails) ##" << std::endl; // CINEMATIQUES initCinematique(&Modeles::m_cinematiqueIntro, &Vues::m_cinematiqueViewIntro, "./intro"); initCinematique(&Modeles::m_cinematiqueFin, &Vues::m_cinematiqueViewFin, "./fin"); //TEXTURES OBJETS std::string texFichiers[] = { "sante.png", "arme.png", "bouton.png" }; std::string objRacine("./objets/"); for(int i=0; i<Objet::NB_OBJETS_ID; i++) { Objet::ObjetID id = (Objet::ObjetID) i; Vues::m_objetsView.addTexture(id, objRacine + texFichiers[i]); } }
void TryPrintAllFileNamesInFolder(std::string folder_dir_name, std::ostream &PRINT_HERE) { tinydir_dir dir; tinydir_open(&dir, folder_dir_name.c_str()); while(dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if(file.is_dir == false && file.name[0] != '.') { PRINT_HERE << "\"" << folder_dir_name << "\" contains:" << std::string(file.name) << std::endl; } tinydir_next(&dir); } tinydir_close(&dir); }
void PluginManager::LoadPlugins() { tinydir_dir dir; if (tinydir_open(&dir, PLUGINPATH) == -1) { Log("Error opening file"); } int cpt = 0; while (dir.has_next) { tinydir_file file; if (tinydir_readfile(&dir, &file) == -1) { Log("Error getting file"); } if (std::string(file.extension) == "dll") { void* handle = nullptr; handle = SDL_LoadObject(file.path); if (handle != nullptr) { std::vector<std::string>* (*func)(); func = (std::vector<std::string>*(*)())SDL_LoadFunction(handle, "GetPluginFeatures"); if (func != nullptr) { std::vector<std::string>* pluginFeatures = func(); _plugins.push_back(handle); for (std::string& str : (*pluginFeatures)) { _features[str].push_back(handle); } delete pluginFeatures; } else Log("Unable to load GetPluginFeatures function in : " + std::string(file.path)); } else Log("Unable to load plugin : "+std::string(file.path)); } tinydir_next(&dir); } tinydir_close(&dir); }
bool listFilesInDir(const std::string& rootDir, PathList* filesList, const std::string& extFilter, bool recursive) { bool success = true; if(!filesList) { errno = EINVAL; return false; } tinydir_dir dir; if(tinydir_open(&dir, rootDir.c_str()) == -1) return false; while(dir.has_next) { tinydir_file file; if(tinydir_readfile(&dir, &file) == -1) { success = false; continue; } // Regular file if(file.is_reg && (extFilter.empty() || extFilter == file.extension)) filesList->push_back(file.path); // Directory else if(recursive && file.is_dir && strcmp(file.name, ".") != 0 && strcmp(file.name, "..") != 0) { if(!listFilesInDir(file.path, filesList, extFilter, true)) success = false; } if(tinydir_next(&dir) == -1) { success = false; break; } } tinydir_close(&dir); return success; }
std::vector<std::string> GetImageFilenamesInFolder(std::string folder_dir_name) { std::vector<std::string> returnedFnames; tinydir_dir dir; tinydir_open(&dir, folder_dir_name.c_str()); while(dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if(file.is_dir == false && file.name[0] != '.' && filename_extension_is_image_type(get_extension_from_filename(file.name))) { returnedFnames.push_back(file.name); } tinydir_next(&dir); } tinydir_close(&dir); return returnedFnames; }
int CountNumImagesInFolder(std::string folder_dir_name) { int returned_num_images = 0; tinydir_dir dir; tinydir_open(&dir, folder_dir_name.c_str()); while(dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if(file.is_dir == false && file.name[0] != '.' && filename_extension_is_image_type(get_extension_from_filename(file.name))) { returned_num_images++; } tinydir_next(&dir); } tinydir_close(&dir); return returned_num_images; }
void LoadSongList(struct SongDef **songList, const char *dirPath) { tinydir_dir dir; int errsv; if (tinydir_open(&dir, dirPath) == -1) { errsv = errno; printf("Cannot open music dir: %s\n", strerror(errsv)); goto bail; } for (; dir.has_next; tinydir_next(&dir)) { Mix_Music *m; tinydir_file file; if (tinydir_readfile(&dir, &file) == -1) { errsv = errno; debug(D_VERBOSE, "cannot read file: %s\n", strerror(errsv)); goto bail; } if (!file.is_reg) { debug(D_VERBOSE, "not a regular file %s\n", file.name); continue; } if (strcmp(file.extension, "txt") == 0 || strcmp(file.extension, "TXT") == 0) { debug(D_VERBOSE, "Skipping text file %s\n", file.name); continue; } m = Mix_LoadMUS(file.path); if (m == NULL) { debug(D_VERBOSE, "not a music file %s\n", file.name); continue; } Mix_FreeMusic(m); AddSong(songList, file.path); } bail: tinydir_close(&dir); }
vector<string> LCSSaveFiles() { vector<string> save_files; tinydir_dir dir; tinydir_open(&dir, homedir); while (dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if(strstr(file.name, ".dat") != NULL &&strstr(file.name, "score") == NULL) save_files.push_back(file.name); tinydir_next(&dir); } tinydir_close(&dir); return save_files; }
std::vector<std::string> filesInDirectory(std::string filepath) { tinydir_dir dir; tinydir_open(&dir, filepath.c_str()); std::vector<std::string> result; while (dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if (!file.is_dir) { result.push_back(file.name); } tinydir_next(&dir); } return result; }
void Graphics::loadSkyBoxes(std::string directory) { std::cout << "Loading SkyBox" << std::endl; // Get names of nested skybox directories std::vector<std::string> directories; tinydir_dir dir; tinydir_open(&dir, directory.c_str()); while(dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if(file.is_dir && file.name[0] != '.') { directories.push_back(file.name); } tinydir_next(&dir); } tinydir_close(&dir); unsigned int shader = resources->getShader("cubemap"); for(int i=0; i<directories.size(); i++) { std::string fileName(directories.at(i)); resources->addSkyBox(SkyBox(directory+directories[i], shader), fileName); } }
static void ScanDirectory(const std::string& path, std::function<void(const std::string& path, const char* filename)> callback, const std::string& requiredSuffix = "", bool recursive = true) { tinydir_dir dir; for (tinydir_open(&dir, path.c_str()); dir.has_next; tinydir_next(&dir)) { tinydir_file file; tinydir_readfile(&dir, &file); if (file.name[0] == '.') continue; if (file.is_dir) { if (recursive) ScanDirectory(path + "/" + file.name, callback, requiredSuffix, recursive); } else if (requiredSuffix.empty() || EndsWith(file.name, requiredSuffix)) callback(path + "/" + file.name, file.name); } tinydir_close(&dir); }
static void SoundLoadDirImpl( SoundDevice *s, const char *path, const char *prefix) { tinydir_dir dir; if (tinydir_open(&dir, path) == -1) { LOG(LM_MAIN, LL_ERROR, "Cannot open sound dir '%s'", path); goto bail; } for (; dir.has_next; tinydir_next(&dir)) { tinydir_file file; if (tinydir_readfile(&dir, &file) == -1) { LOG(LM_MAIN, LL_ERROR, "Cannot read sound file '%s'", file.path); continue; } char buf[CDOGS_PATH_MAX]; if (prefix != NULL) { sprintf(buf, "%s/%s", prefix, file.name); } else { strcpy(buf, file.name); } if (file.is_reg) { LoadSound(s, buf, file.path); } else if (file.is_dir && file.name[0] != '.') { SoundLoadDirImpl(s, file.path, buf); } } bail: tinydir_close(&dir); }
void test(const char* path) { tinydir_dir dir; tinydir_open(&dir, path); printf("dir: %s\n", dir.path); while(dir.has_next) { tinydir_file file; if(tinydir_readfile(&dir, &file)== -1) { perror("Error"); return; } if(!strcmp(file.name, ".") || !strcmp(file.name, "..")) continue; if(strcmp(get_file_encoding(file.path), "UNKNOWN")) printf("%s\n", file.name); if(file.is_dir && strcmp(file.name, ".") && strcmp(file.name, "..")) { test(file.path); } tinydir_next(&dir); } tinydir_close(&dir); }
void Graphics::loadShaders(std::string directory){ std::cout << "Loading shaders" << std::endl; std::vector<std::string> files; tinydir_dir dir; tinydir_open(&dir, directory.c_str()); while( dir.has_next ){ tinydir_file file; tinydir_readfile(&dir, &file); if( !file.is_dir && strcmp(file.extension, "vert") == 0 ){ files.push_back(file.name); } tinydir_next(&dir); } tinydir_close(&dir); for( int i=0; i<files.size(); i++ ){ std::string fileName(files[i]); std::string name = fileName.substr(0, files[i].size()-5); std::cout << "Adding shader " << fileName << std::endl; resources->addShader(compileShader(directory + name), name); } }
void Graphics::loadModels(std::string directory){ std::cout << "Loading models from " << directory << std::endl; // Get names of contents of directory (might break stuff sometimes maybe) std::vector<std::string> files; tinydir_dir dir; tinydir_open(&dir, directory.c_str()); while( dir.has_next ){ tinydir_file file; tinydir_readfile(&dir, &file); if( !file.is_dir && strcmp(file.extension, "obj") == 0 ){ files.push_back(file.name); } tinydir_next(&dir); } tinydir_close(&dir); // unsigned int shader = resources->getShader("debug_normal"); unsigned int shader = resources->getShader("texture"); for( int i=0; i<files.size(); i++ ){ std::string fileName(files[i]); std::cout << "Adding model " << fileName << std::endl; resources->addModel(Model(directory+files[i], shader), fileName.substr(0, files[i].size()-4)); } }
void DeleteFilesOfTypeInFolder(std::string folder, std::string filename_extension) { std::string thisfname; std::string thisextens; tinydir_dir dir; tinydir_open(&dir, folder.c_str()); while(dir.has_next) { tinydir_file file; tinydir_readfile(&dir, &file); if(file.is_dir == false && file.name[0] != '.') { thisfname = std::string(file.name); //std::cout<<"found file (might delete?) "<<thisfname<<std::endl; thisextens = trim_chars_after_delim(thisfname,'.',true); //std::cout<<" extension: \""<<thisextens<<"\""<<std::endl; if(!__stricmp(thisextens.c_str(),filename_extension.c_str())) { thisfname = std::string(file.path); //std::cout<<"DELETING \""<<thisfname<<"\""<<std::endl; std::remove(thisfname.c_str()); } } tinydir_next(&dir); } tinydir_close(&dir); }
//based upon tinydir_open_sorted void getFiles(tinydir_dir *dir, const char *path) { //count number of files size_t n_files = 0; tinydir_open(dir, path); while (dir->has_next) { n_files++; tinydir_next(dir); } tinydir_close(dir); //populate data tinydir_open(dir, path); dir->n_files = 0; dir->_files = (tinydir_file*)malloc(n_files * (sizeof *dir->_files)); while (dir->has_next) { tinydir_file *file; file = &dir->_files[dir->n_files]; tinydir_readfile(dir, file); if (strcmp(file->extension, "sav") == 0) { dir->n_files++; } tinydir_next(dir); } }
void CommonOutputAction::setRecoverFileBase() { // Extract the default directory for recover files std::string dir = getRecoveryDirectory(); pcrecpp::RE re_base_and_file_num("(.*?(\\d+))\\..*"); // Will pull out the full base and the file number simultaneously tinydir_dir tdir; if (tinydir_open(&tdir, dir.c_str()) == -1) mooseError("Cannot open directory: " << dir); time_t newest_time = 0; std::vector<std::string> newest_restart_files; // First, the newest candidate files. // Note that these might have the same modification time if the simulation was fast // In that case we're going to save all of the "newest" files and sort it out momentarily while(tdir.has_next) { tinydir_file file; if (tinydir_readfile(&tdir, &file) == -1) { tinydir_next(&tdir); continue; } std::string file_name = file.name; if ((!file.is_dir)) { struct stat stats; std::string full_path = dir + "/" + file_name; stat(full_path.c_str(), &stats); time_t mod_time = stats.st_mtime; if (mod_time > newest_time) { newest_restart_files.clear(); newest_time = mod_time; } if (mod_time == newest_time) newest_restart_files.push_back(file_name); } tinydir_next(&tdir); } int max_file_num = -1; std::string max_base; // Now, out of the newest files find the one with the largest number in it for(unsigned int i=0; i<newest_restart_files.size(); i++) { std::string file_name = newest_restart_files[i]; std::string the_base; int file_num = 0; re_base_and_file_num.FullMatch(file_name, &the_base, &file_num); if (file_num > max_file_num) { max_file_num = file_num; max_base = the_base; } } if (max_file_num == -1) mooseError("Unable to find suitable recovery file!"); std::string recovery = dir + "/" + max_base; Moose::out << "\nUsing " << recovery << " for recovery.\n" << std::endl; _app.setRecoverFileBase(recovery); }
/** * Gets test files and store labels/filenames in vector classes **/ void getsTestFiles() { // open directory containing number directories tinydir_dir test_root_dir; tinydir_open(&test_root_dir, "test_files"); // iterate over directories while (test_root_dir.has_next) { // get file tinydir_file file; tinydir_readfile(&test_root_dir, &file); // if it is a directory if(file.is_dir) { std::string numbersDirName = file.name; // skip . / .. / .DS_Store (OSX) if(numbersDirName != "." && numbersDirName != ".." && numbersDirName != ".DS_Store") { // atoi isn't supersafe but sufficient for this test int currentLabel = atoi(file.name); // prepend full test_files directory numbersDirName.insert(0, "test_files/"); // open directory containing number directories tinydir_dir test_number_dir; tinydir_open(&test_number_dir, numbersDirName.c_str() ); // iterate over directories while (test_number_dir.has_next) { // get file tinydir_file testJpgFile; tinydir_readfile(&test_number_dir, &testJpgFile); // get directory name std::string testJpgFileName = testJpgFile.name; // skip . / .. / .DS_Store (OSX) if (testJpgFileName != "." && testJpgFileName != ".." && testJpgFileName != ".DS_Store") { // prepend full test_files directory testJpgFileName.insert(0, numbersDirName + "/"); // store test filename and expected label testFilenames.push_back(testJpgFileName); expectedLabels.push_back(currentLabel); } // get next file tinydir_next(&test_number_dir); } // close directory tinydir_close(&test_number_dir); } } // get next file tinydir_next(&test_root_dir); } // close directory tinydir_close(&test_root_dir); }