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