[boost] Re: Any interest in a boost::glob() function?

From: Angus Leeming (angus.leeming_at_[hidden])
Date: 2004-09-28 09:24:12

Angus Leeming wrote:

> Gennadiy Rozental wrote:
>> You need to implement iterator that match InputIterator concept.
>> Also it is very similar to iteration though N-ary matrix.
>> 
>> You need to build a collection of directory iterators on each
>> level.
>> 
>> Here is a sketch of how next function would look like (if you use
>> input_iterator_adaptor).
>> 
>> void next()
>> {
>>     starting from end find first level iterator that is not equal
>>     to end
>> 
>>     If not found, finite la comedi.
>> 
>>     if found last level, increment it and that's all
>> 
>>     If found level in the middle increment it, rebuild all
>>     directory
>> iterators for following levels and start from the beginning.
>> }
>> 
>> I think there should be iterator like this (generic, over matrix)
>> somewhere.If not it would be interesting undertaking.
> 
> Gennadiy,
> 
> Thank you for this. I'll mull it over and get back to you.

Ok, I've thought a bit and think I understand your proposal. Let's 
use a class to store the predicates that will be used to initialise 
the filter_iterators at each level of the tree:

class glob_pattern {
        vector<glob_predicate<> > predicates;
};

Ie, "../foo*bar/baz?.eps" would require that glob_pattern stored a 
vector of 3 predicates.

Let's call these "filter_iterators at each level of the 
tree" glob_directory_iterators. A glob_iterator will store a 
vector of glob_directory_iterators. (Also 3 in the example's case). 
Incrementing a glob_iterator will use a strategy similar to the one 
you outline above.

class glob_pattern {
        vector<glob_predicate<> > predicates;
public:
        glob_iterator begin() const;
        glob_iterator end() const;
};

class glob_iterator {
        vector<glob_directory_iterator> dir_iterators;
public:
        glob_iterator(vector<glob_predicate<> > const & p)
        {
                typedef vector<glob_predicate<> > p_vec;

                dir_iterators.reserve(p.size());
                p_vec::const_iterator it = p.begin();
                p_vec::const_iterator const end = p.end();
                for (; it != end; ++it)
                        dir_iterators.push_back(
                                glob_directory_iterator(*it));
        }

        glob_iterator operator++() 
        { /* implement the "next" strategy */ }
};

This strategy moves all the nonsense about "does the predicate 
contain wildcards or not" into glob_directory_iterator. Fine.

No doubt there's lots of implementation details left, (like using 
input_iterator_adaptor), but I think that this pseudo code covers the 
idea. 

Am I on the right track?
Angus