Glob.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_GLOB_H
#define ZYPP_GLOB_H

extern "C"
{
#include <glob.h>
}

#include <iosfwd>

#include "zypp/base/Easy.h"
#include "zypp/base/Flags.h"
#include "zypp/base/Iterator.h"
#include "zypp/base/NonCopyable.h"
#include "zypp/base/DefaultIntegral.h"

#include "zypp/Pathname.h"

namespace zypp
{ 

  namespace filesystem
  { 

    //
    //  CLASS NAME : Glob
    //
    class Glob : private base::NonCopyable
    {
      public:
        typedef size_t size_type;
        typedef const char * value_type;

        class const_iterator : public boost::iterator_adaptor<
              const_iterator                // Derived
            , char **                       // Base
            , value_type                    // Value
            , boost::forward_traversal_tag  // CategoryOrTraversal
            , const value_type              // Reference
            >
        {
          public:
            const_iterator()
            : const_iterator::iterator_adaptor_( 0 )
            {}

            explicit const_iterator( char ** _idx )
            : const_iterator::iterator_adaptor_( _idx && *_idx ? _idx : 0 )
            {}

          private:
            friend class boost::iterator_core_access;
            void increment()
            {
              if ( base_reference() && !*(++base_reference()) )
                base_reference() = 0;
            }
            reference dereference() const
            { return( base() ? *base() : 0 ); }
        };

      public:
        enum Bits {
          kErr          = GLOB_ERR,             
          kMark         = GLOB_MARK,            
          kNoSort       = GLOB_NOSORT,          
          // unsupported kDoOffs = GLOB_DOOFFS, //!< Insert PGLOB->gl_offs NULLs.
          kNoCheck      = GLOB_NOCHECK,         
          // autoapplied kAppend = GLOB_APPEND, //!< Append to results of a previous call.
          kNoEscape     = GLOB_NOESCAPE,        
          kPeriod       = GLOB_PERIOD,          
          // unsupported kMagChar = GLOB_MAGCHAR,//!< Set in gl_flags if any metachars seen.
          kAltDirFunc   = GLOB_ALTDIRFUNC,      
          kBrace        = GLOB_BRACE,           
          kNoMagic      = GLOB_NOMAGIC,         
          kTilde        = GLOB_TILDE,           
          kOnlyDir      = GLOB_ONLYDIR,         
          kTildeCheck   = GLOB_TILDE_CHECK,     
        };

        ZYPP_DECLARE_FLAGS( Flags, Bits );

      public:
        Glob( Flags flags_r = Flags() )
        : _defaultFlags( flags_r )
        {}

        explicit Glob( const Pathname & pattern_r, Flags flags_r = Flags() )
        : _defaultFlags( flags_r )
        { add( pattern_r, flags_r ); }
        explicit Glob( const std::string & pattern_r, Flags flags_r = Flags() )
        : _defaultFlags( flags_r )
        { add( pattern_r, flags_r ); }
        explicit Glob( const char * pattern_r, Flags flags_r = Flags() )
        : _defaultFlags( flags_r )
        { add( pattern_r, flags_r ); }

        ~Glob()
        { if ( _result ) ::globfree( &(*_result) ); }

        int add( const Pathname & pattern_r, Flags flags_r = Flags() )
        { return add( pattern_r.c_str(), flags_r ); }
        int add( const std::string & pattern_r, Flags flags_r = Flags() )
        { return add( pattern_r.c_str(), flags_r ); }
        int add( const char * pattern_r, Flags flags_r = Flags() );

        void clear();

        void reset( Flags flags_r = Flags() )
        { clear(); setDefaultFlags( flags_r ); }


      public:
        Flags defaultFlags() const
        { return _defaultFlags; }

        void setDefaultFlags( Flags flags_r = Flags() )
        { _defaultFlags = flags_r; }

        int lastGlobReturn() const
        { return _lastGlobReturn; }

      public:
        bool empty() const
        { return ! ( _result && _result->gl_pathc ); }

        size_type size() const
        { return( _result ? _result->gl_pathc : 0 ); }

        const_iterator begin() const
        { return( _result ? const_iterator( _result->gl_pathv ) : const_iterator() ); }

        const_iterator end() const
        { return const_iterator(); }

      public:

        template<class TOutputIterator>
        static int collect( const Pathname & pattern_r, TOutputIterator result_r )
        { return collect( pattern_r.c_str(), Flags(), result_r ); }
        template<class TOutputIterator>
        static int collect( const std::string & pattern_r, TOutputIterator result_r )
        { return collect( pattern_r.c_str(), Flags(), result_r ); }
        template<class TOutputIterator>
        static int collect( const char * pattern_r, TOutputIterator result_r )
        { return collect( pattern_r, Flags(), result_r ); }

        template<class TOutputIterator>
        static int collect( const Pathname & pattern_r, Flags flags_r, TOutputIterator result_r )
        { return collect( pattern_r.c_str(), flags_r, result_r ); }
        template<class TOutputIterator>
        static int collect( const std::string & pattern_r, Flags flags_r, TOutputIterator result_r )
        { return collect( pattern_r.c_str(), flags_r, result_r ); }
        template<class TOutputIterator>
        static int collect( const char * pattern_r, Flags flags_r, TOutputIterator result_r )
        {
          Glob glob( pattern_r, flags_r );
          if ( glob.lastGlobReturn() == 0 )
            for_( it, glob.begin(), glob.end() )
              (*result_r)++ = typename TOutputIterator::container_type::value_type(*it);
          return glob.lastGlobReturn();
        }

      private:
        Flags _defaultFlags;
        scoped_ptr< ::glob_t> _result;
        DefaultIntegral<int,0> _lastGlobReturn;
    };

    std::ostream & operator<<( std::ostream & str, const Glob & obj );

    inline std::ostream & operator<<( std::ostream & str, const Glob::const_iterator & obj )
    { return str << *obj; }

    ZYPP_DECLARE_OPERATORS_FOR_FLAGS( Glob::Flags );


  } // namespace filesystem
} // namespace zypp
#endif // ZYPP_GLOB_H