Iterator.h

Go to the documentation of this file.

 
#pragma once
 
#include <iterator>
 
namespace Gorgon {
    
    namespace Filesystem {
        
        namespace internal {
            class iterator_data;
        }
        
        class Iterator : public std::iterator<std::forward_iterator_tag, std::string> {
        public:
 
            Iterator(const std::string &directory, const std::string &pattern="*");
            
            Iterator(Iterator &&dir) : data(dir.data), basedir(std::move(dir.basedir)), 
            current(std::move(dir.current)) { 
                dir.data=nullptr;
            }
            
            Iterator(const Iterator &other);
            
            Iterator() : data(nullptr) { }
            
            Iterator &operator =(Iterator other) { Swap(other); return *this; }
            
            ~Iterator() { Destroy(); }
 
            void Swap(Iterator &other) {
                using std::swap;
                
                swap(data, other.data);
                swap(basedir, other.basedir);
                swap(current, other.current);
            }
            
            std::string Get() const {
#ifdef DEBUG
                if(!data || current=="") {
                    throw std::runtime_error("Invalid iterator.");
                }
#endif
                    
                return current;
            }
 
            const std::string *operator ->() {
#ifdef DEBUG
                if(!data || current=="") {
                    throw std::runtime_error("Invalid iterator.");
                }
#endif
                    
                return &current;
            }
 
            operator std::string() const {
                return Get();
            }
 
            std::string operator *() const {
                return Get();
            }
 
            std::string Current() {
                return Get();
            }
 
            Iterator &operator ++() {
                Next();
 
                return *this;
            }
 
            Iterator &operator +=(int i) {
                for(int j=0;j<i;j++)
                    ++(*this);
                
                return *this;
            }           
            
            Iterator operator ++(int) {
                Iterator it=*this;
                
                Next();
                return it;
            }
 
            bool Next();
            
            void Destroy();
 
            bool IsValid() const {
                return data && current!="";
            }
 
            bool operator ==(const Iterator &other) const {
                if(!data)
                    return other.data==nullptr;
                else if(!other.data)
                    return false;
                
                return other.basedir==basedir && other.current==current;
            }
 
            bool operator !=(const Iterator &other) const {
                if(!data)
                    return other.data!=nullptr;
                else if(!other.data)
                    return true;
                
                return other.basedir!=basedir || other.current!=current;
            }
 
        private:
            internal::iterator_data *data;
            std::string basedir;
            std::string current;
        };
        
 
        inline void swap(Iterator &l, Iterator &r) {
            l.Swap(r);
        }
        
    }
}