/home/fwph/code/wurde/rde/utils/DirectoryLoader.H

Go to the documentation of this file.

#ifndef DIRECTORY_LOADER_H
#define DIRECTORY_LOADER_H

#include <Time.H>
#include <Logger.H>
#include <dirent.h>

namespace WURDE {
        class FileEntry {
                
        public:
                std::string filename;
                int index;      
                Time timestamp;
                
                bool operator<(const FileEntry &right) const{
                        if(timestamp.getSeconds()<right.timestamp.getSeconds()){
                                return true;
                        }else if(timestamp.getSeconds()==right.timestamp.getSeconds()){
                                if(timestamp.getUSeconds()<right.timestamp.getUSeconds()){
                                        return true;
                                }
                        }
                        return false;
                }
        };
        
        class DirectoryScanner{
        public:
                DirectoryScanner(std::string path,std::string pattern1,std::string pattern2){
                        m_path=path;
                        m_patterns.push_back(pattern1);
                        m_patterns.push_back(pattern2);
                }
                
                explicit DirectoryScanner(std::string path){
                        m_path=path;
                }
                
                DirectoryScanner(){};

                void setPath(std::string path){m_path=path;}
                
                std::vector<FileEntry> getSortedFileList(){
                        return m_files;
                }
                
                void addPattern(const std::string &val){
                        //                      g_logdebug << "Adding pattern " << val << std::endl;
                        m_patterns.push_back(val);
                }
                
                void openDirectory(){
                        FileEntry temp;
                        struct dirent *current=NULL;
                        bool member=false;
                        char *marker=NULL;
                        unsigned long frameno=0;
                        unsigned long seconds=0;
                        unsigned long useconds=0;                      
                        DIR *directory=NULL;
                        long index=0;
                        directory=opendir(m_path.c_str());
                        if(!directory){
                                g_logerror << "Couldn't open directory " << m_path << std::endl;
                                return;
                        }
                        
                        while(true){
                                member=true;

                                current=readdir(directory);
                                if(!current){
                                        break;
                                }
                                //                              g_logdebug << "Reading directory entry " << index << " name " << current->d_name << std::endl;
                                index++;
                                for( int i=0;i<m_patterns.size();i++){
                                        if(!strstr(current->d_name,m_patterns[i].c_str())){
                                                member=false;
                                        }
                                }
                                if(member){                                    
                                
                                        marker=strstr(current->d_name,"-");
                                        if(marker){
                                                marker++;
                                                frameno=strtol(marker,&marker,10);              
                                                if(*marker='-'){
                                                        marker++;
                                                        marker=strstr(marker,"-");
                                                        if(marker){
                                                                marker++;
                                                                seconds=strtol(marker,&marker,10);
                                                                if(*marker='.'){
                                                                        marker++;
                                                                        useconds=strtol(marker,&marker,10);
                                                                        //g_logdebug << "Adding file " << current->d_name << std::endl;
                                                                        temp.filename=m_path+"/"+current->d_name;
                                                                        temp.index=frameno;
                                                                        temp.timestamp.setSeconds(seconds);
                                                                        temp.timestamp.setUSeconds(useconds);
                                                                        m_files.push_back(temp);
                                                                }else{
                                                                        g_logdebug << "Unexpected " << *marker << std::endl;
                                                                        g_logwarn << "Filename " << current->d_name << " doesn't conform."<<std::endl;
                                                                }
                                                        }else{
                                                                g_logdebug << "Unexpected " << *marker << std::endl;
                                                                g_logwarn << "Filename " << current->d_name << " doesn't conform."<<std::endl;
                                                        }
                                                }else{
                                                        g_logdebug << "Unexpected " << *marker << std::endl;
                                                        g_logwarn << "Filename " << current->d_name << " doesn't conform."<<std::endl;
                                                }
                                        }else{
                                                g_logwarn << "Filename " << current->d_name << " doesn't conform."<<std::endl;
                                        }
                                }

                        }
                        
                        closedir(directory);
                        
                        sort(m_files.begin(),m_files.end());
                        
                }
                
        private:
                std::string m_path;
                int filterfunc(const struct dirent *entry){
                        for(int i=0;i<m_patterns.size();i++){
                                if(strstr(entry->d_name,m_patterns[i].c_str())){
                                        return 0;
                                }
                        }
                        return 1;
                }
                std::vector<std::string> m_patterns;
                std::vector<FileEntry> m_files;
                
        };

}

#endif

---