codebase / stimlib

  #ifndef STIM_FILENAME_H
  #define STIM_FILENAME_H
  
  #include <stdio.h>  /* defines FILENAME_MAX */
  #include <sstream>
  #include <vector>
  #include <algorithm>
  #include <iostream>
  #include <iomanip>
  
  #include <stim/parser/parser.h>
  
  // set OS dependent defines, including:
  //	1) path division character ('/' or '\') used for output only
  //	2) command for getting the current working directory
  //	3) header files for getting the current working directory
  //	4) include BOOST filesystem class if compiling on GCC
  #define STIM_DIV '/'
  #ifdef _WIN32
  	#include <windows.h>
  	#include <direct.h>
  	#define GetCurrentDir _getcwd
  	#define STIM_FILENAME_DIV '\\'
  #else
  	#ifdef BOOST_PRECOMPILED
  		#include <boost/filesystem.hpp>
  	#endif
  	#include <unistd.h>
  	#define GetCurrentDir getcwd
  	#define STIM_FILENAME_DIV '/'
   #endif
  
  namespace stim{
  
  class filepath{
  protected:
  	std::string _drive;					//drive on which the file is located (used for Windows)
  	std::vector<std::string> _path;		//path for the specified file (list of hierarchical directories)
  
  	/// replaces win32 dividers with the Linux standard (used internally by default)
  	std::string unix_div(std::string s) {
  		std::replace( s.begin(), s.end(), '\\', '/');
  		return s;
  	}
  
  	/// gets the directory hierarchy for the current working directory
  	static std::string cwd(){
  		char cCurrentPath[FILENAME_MAX];
  
  		 if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath))){
  			 std::cout<<"ERROR getting current working directory."<<std::endl;
  			 exit(1);
  		 }
  
  		 std::stringstream ss;
  		 ss<<cCurrentPath;
  		 return ss.str();
  	}
  
  	/// convert a relative path to an absolute path
  	void get_absolute(std::string &drive, std::vector<std::string> &absolute, std::vector<std::string> relative){
  
  		std::string current = cwd();						//get the current directory as a string
  
  		std::string current_drive;
  		std::vector<std::string> current_dir;
  		parse_path(current_drive, current_dir, current);			//get the current drive and directories
  		drive = current_drive;										//all relative paths have to be relative to the current drive
  		if (current_dir.size() > 0) {
  
  			// step through each directory in the relative path, adjusting the current directory
  			//		index depending on whether the relative path is specified with '.' or '..'
  			int current_i = (int)current_dir.size() - 1;
  			int relative_i;
  			for (relative_i = 0; relative_i < relative.size(); relative_i++) {
  				if (relative[relative_i] == "..") current_i--;
  				else if (relative[relative_i] != ".") break;
  			}
  			if (current_i < 0) {
  				std::cerr << "ERROR stim::filepath - relative path is incompatible with working directory" << std::endl;
  				exit(1);
  			}
  
  			absolute.clear();
  			for (size_t i = 0; i <= current_i; i++) {
  				absolute.push_back(current_dir[i]);
  			}
  			for (size_t i = relative_i; i < relative.size(); i++) {
  				absolute.push_back(relative[i]);
  			}
  		}
  		else {
  			if (relative[0] == ".")
  				relative = std::vector<std::string>(relative.begin() + 1, relative.end());
  			absolute = relative;
  		}
  	}
  
  	/// Parses a directory string into a drive (NULL if not Windows) and list of hierarchical directories
  	void parse_path(std::string &drive, std::vector<std::string> &absolute, std::string dir){
  		drive = "";											//initialize the drive to NULL (it will stay that way for Windows)
  		std::vector<std::string> path;
  		bool relative = true;								//the default path is relative
  
  		if(dir.length() == 0) return;						//return if the file locator is empty
  		std::string unix_dir = unix_div(dir);				//replace any Windows division characters with Unix
  
  		if(unix_dir.length() > 1 && unix_dir[1] == ':'){	//if a drive identifier is given
  			if(unix_dir[0] > 64 && unix_dir[0] < 91)		//if the drive letter is upper case
  				drive = unix_dir[0] + 32;					//convert it to lower case
  			else if(unix_dir[0] > 96 && unix_dir[0] < 123)	//if the drive character is lower case
  				drive = unix_dir[0];					//store it as-is
  			else{											//otherwise throw an error
  				std::cerr<<"ERROR stim::filename - drive letter is invalid: "<<unix_dir[0]<<std::endl;
  				exit(1);
  			}
  			unix_dir = unix_dir.substr(2, unix_dir.length()-2);	//extract the directory structure
  		}
  
  		if(drive.size() != 0){
  			relative = false;
  		}
  		if (unix_dir.size() > 0) {										//if there is a directory specified, remove surrounding slashes
  			if (unix_dir[0] == '/') {						//if there is a leading slash
  				relative = false;								//the path is not relative
  				unix_dir = unix_dir.substr(1, unix_dir.length() - 1);	//remove the slash
  			}
  		}
  		if(unix_dir.size() > 0){
  			if(unix_dir[unix_dir.size()-1] == '/')
  				unix_dir = unix_dir.substr(0, unix_dir.length() - 1);
  		}
  
  		path = stim::parser::split(unix_dir, '/');					//split up the directory structure
  		
  		if(relative)
  			get_absolute(drive, absolute, path);
  		else
  			absolute = path;
  	}
  
  	
  
  public:
  	filepath(){
  		_drive = "";
  	}
  
  	filepath(const stim::filepath& p){
  		*this = p;
  	}
  
  	filepath(const std::string s){
  		parse_path(_drive, _path, s);
  	}
  
  	stim::filepath& operator=(const std::string s){
  		parse_path(_drive, _path, s);		//parse the string to get the drive and relative path
  		return *this;
  	}
  
  	std::string str(){
  		std::stringstream ss;
  		if(_drive != "")							//if a drive letter is specified
  			ss<<_drive<<":";						//add it to the string
  		for(size_t i = 0; i < _path.size(); i++)
  			ss<<STIM_FILENAME_DIV<<_path[i];
  		ss<<STIM_FILENAME_DIV;
  		return ss.str();
  	}	
  };				//end filepath
  
  class filename : public filepath{
  protected:
  	std::string _prefix;				//filename prefix
  	std::string _extension;				//filename extension
  
  	void set_filename(std::string fname){
  		size_t ext_i = fname.find_last_of('.');								//calculate the index of the '.'
  		if(ext_i != std::string::npos){											//if there is an extension
  			_prefix = fname.substr(0, ext_i);				//store the prefix
  			_extension = fname.substr(ext_i + 1, fname.size() - ext_i - 1);	//store the extension
  		}
  		else												//otherwise just store the prefix
  			_prefix = fname;
  	}
  
  public:
  	filename(){}
  
  	filename(stim::filepath p, std::string fname) : stim::filepath(p){
  		set_filename(fname);
  	}
  
  	stim::filename& operator=(const std::string s){
  		std::string unix_s = unix_div(s);					//convert dividers to unix
  		size_t name_i = unix_s.find_last_of('/');		//find the index of the last divider
  
  		if(name_i == std::string::npos){					//if there is no divider, this is just a filename
  			unix_s = "./" + unix_s;							//append a ./ to the beginning so that the working directory is used
  			name_i = 1;
  		}
  
  		name_i++;
  
  
  		std::string filename = unix_s.substr(name_i, unix_s.size() - name_i);	//extract the filename
  		std::string filepath = unix_s.substr(0, name_i-1);						//extract the filepath
  
  		filepath::operator=(filepath);						//parse and store the file path
  
  		set_filename(filename);
  		return *this;
  	}
  
  	filename(std::string s){
  		operator=(s);
  	}
  
  	bool is_relative(){
  		return false;
  	}
  
  
  	std::string str(){
  		std::stringstream ss;
  		ss<<filepath::str()<<_prefix;
  		if(_extension.size() != 0)
  			ss<<"."<<_extension;
  		return ss.str();
  	}
  
  	//return a string for the filename without an extension
  	std::string str_noext(){
  		std::stringstream ss;
  		ss<<filepath::str()<<_prefix;
  		return ss.str();
  	}
  
  	/// Create a matching file locator with a prefix s
  	stim::filename with_prefix(std::string s){
  		stim::filename result = *this;
  		result._prefix = s;
  		return result;
  	}
  
  	std::string prefix(){
  		return _prefix;
  	}
  
  	std::string get_prefix(){
  		return _prefix;
  	}
  
  	/// Create a matching file locator with the extension changed to s
  	stim::filename extension(std::string s){
  		stim::filename result = *this;
  		result._extension = s;
  		return result;
  	}
  
  	std::string extension(){
  		return _extension;
  	}
  
  	stim::filename fname(std::string s){
  		stim::filename result = *this;
  		size_t ext_i = s.find_last_of('.');								//calculate the index of the '.'
  		if(ext_i != std::string::npos){											//if there is an extension
  			result._prefix = s.substr(0, ext_i);				//store the prefix
  			result._extension = s.substr(ext_i + 1, s.size() - ext_i - 1);	//store the extension
  		}
  		else												//otherwise just store the prefix
  			result._prefix = s;
  		return result;
  	}
  
  	std::string fname(){
  		std::string result = prefix();
  		result += ".";
  		result += extension();
  		return result;
  	}
  
  	/// create a matching file locator with the path changed to s
  	stim::filename path(std::string s){
  		stim::filename result = *this;
  		result.parse_path(result._drive, result._path, s);
  		return result;
  	}
  
  	std::string path(){
  		return filepath::str();
  	}
  
  	/// Casting operator, casts to a string
  	operator std::string(){
  		return str();
  	}
  
  	/// This function replaces a wildcard in the prefix with the specified string
  	stim::filename insert(std::string str){
  
  		stim::filename result = *this;				//initialize the result filename to the current filename
  		size_t loc = result._prefix.find('*');		//find a wild card in the string
  		if(loc == std::string::npos)						//if a wildcard isn't found
  			result._prefix += str;							//append the value to the prefix
  		else
  			result._prefix.replace(loc, 1, str);			//replace the wildcard with the string
  		return result;								//return the result
  	}
  
  	/// This function replaces a wildcard in the prefix with the specified integer (with a padding of n)
  	stim::filename insert(size_t i, size_t n = 2){
  
  		std::stringstream ss;
  		ss << std::setw(n) << std::setfill('0') << i;
  		return insert(ss.str());
  	}
  
  	///This method returns true if any characters in the filename contain '*' or '?'
  	bool wildcards() {
  		if (_prefix.find('*') != std::string::npos) return true;
  		if (_prefix.find('?') != std::string::npos) return true;
  		if (_extension.find('*') != std::string::npos) return true;
  		if (_extension.find('?') != std::string::npos) return true;
  		return false;
  	}
  
  	
  	/// Returns a list of files using the current filename as a template.
  	/// For example:
  	///			C:\this\is\a\path\file*.txt
  	///		can be used as a template to find a series of files file001.txt, file002.txt, file003.txt, etc.
  	std::vector<stim::filename> get_list(){
  		//this is OS dependent, so we're starting with Windows
  		//the Unix version requires Boost
  
  #ifdef _WIN32
  
  		HANDLE            hFind = INVALID_HANDLE_VALUE;							//allocate data structures for looping through files
  		WIN32_FIND_DATAA   FindFileData;
  		std::vector<stim::filename> file_list;									//initialize a list to hold all matching filenames
  
  		std::string path_string = str();
  		hFind = FindFirstFileA(path_string.c_str(), &FindFileData);		//find the first file that matches the specified file path
  
  		if (hFind == INVALID_HANDLE_VALUE) { 									//if there are no matching files
  			//printf ("Invalid file handle. Error is %u.\n", GetLastError());		//print an error
  			return file_list;
  		}
  		else {
  			std::string file_name = FindFileData.cFileName;						//save the file name
  			std::string file_path = path();										//the file is in the specified directory, so save it
  			stim::filename current_file(file_path + file_name);					//create a stim::filename structure representing this file
  			if(!(FindFileData.cFileName[0] == '.' && FindFileData.cFileName[1] == '\0'))
  				file_list.push_back(current_file);									//push the new stim::filename to the file list
  
  
  			// List all the other files in the directory.
  			while (FindNextFileA(hFind, &FindFileData) != 0){ 					//iterate until there are no more matching files
  				if(!(FindFileData.cFileName[0] == '.' && FindFileData.cFileName[1] == '.' && FindFileData.cFileName[2] == '\0')){	//account for the possibility of the '..' filename
  					file_name = FindFileData.cFileName;								//save the next file
  					current_file = fname(file_name);								//append the directory
  					file_list.push_back(current_file);								//push it to the list
  				}
  			}
  			FindClose(hFind);													//close the file data structure
  		}
  		return file_list;														//return the list of files
  
  #elif BOOST_PRECOMPILED
  
  		boost::filesystem::path p(path());	//create a path from the current filename
  		std::vector<stim::filename> file_list;
  		if(boost::filesystem::exists(p)){
  			if(boost::filesystem::is_directory(p)){
  				typedef std::vector<boost::filesystem::path> vec;             // store paths,
  				vec v;                                // so we can sort them later
  				std::copy(boost::filesystem::directory_iterator(p), boost::filesystem::directory_iterator(), back_inserter(v));
  				std::sort(v.begin(), v.end());             // sort, since directory iteration
  				  // is not ordered on some file systems
  				//compare file names to the current template (look for wild cards)
  				for (vec::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it)
  				{
  					//if the filename is a wild card *or* it matches the read file name
  					if( _prefix == "*" || _prefix == (*it).filename().stem().string()){
  						//if the extension is a wild card *or* it matches the read file extension
  						if( _extension == "*" || "." + _extension == (*it).filename().extension().string()){
  							file_list.push_back((*it).string());	//include it in the final list
  						}
  
  					}
  
  
  
  				}
  
  			}
  
  		}
  		return file_list;
  #else
  		std::cout<<"ERROR: UNIX systems don't support file lists without the Boost precompiled libraries."<<std::endl;
  		exit(1);
  #endif
  		
  	}
  };				//end filename
  }				//end namespace stim
  #endif