---

SearchPath.h

Go to the documentation of this file.

#ifndef CLASSLIB_SEARCH_PATH_H
# define CLASSLIB_SEARCH_PATH_H

//<<<<<< INCLUDES                                                       >>>>>>

# include "classlib/iobase/Filename.h"
# include <string>
# include <list>
# undef SearchPath // Ugh, defined by windows to SearchPath[UA]

namespace lat {
//<<<<<< PUBLIC DEFINES                                                 >>>>>>
//<<<<<< PUBLIC CONSTANTS                                               >>>>>>
//<<<<<< PUBLIC TYPES                                                   >>>>>>

class SearchPath;
class logstream;

//<<<<<< PUBLIC VARIABLES                                               >>>>>>
//<<<<<< PUBLIC FUNCTIONS                                               >>>>>>

logstream &operator<< (logstream &out, const SearchPath &path);

//<<<<<< CLASS DECLARATIONS                                             >>>>>>

class SearchPath
{
    typedef std::list<Filename>                 DirList;
public:
    typedef DirList::iterator                   iterator;
    typedef DirList::const_iterator             const_iterator;
    typedef DirList::reverse_iterator           reverse_iterator;
    typedef DirList::const_reverse_iterator     const_reverse_iterator;

    typedef DirList::size_type                  size_type;
    typedef DirList::reference                  reference;
    typedef DirList::const_reference            const_reference;

    SearchPath (void);
    explicit SearchPath (const std::string &path);
# if HAVE_MEMBER_TEMPLATES
    template <class I> SearchPath (I first, I last);
# else
    SearchPath (const_iterator first, const_iterator last);
# endif
    // default copy constructor
    // default destructor
    // default assignment operator

    // general queries
    bool                        operator== (const SearchPath &x);
    bool                        empty (void) const;
    size_type                   size (void) const;

    // member access
    iterator                    begin (void);
    const_iterator              begin (void) const;
    iterator                    end (void);
    const_iterator              end (void) const;

    reverse_iterator            rbegin (void);
    const_reverse_iterator      rbegin (void) const;
    reverse_iterator            rend (void);
    const_reverse_iterator      rend (void) const;

    reference                   front (void);
    const_reference             front (void) const;
    reference                   back (void);
    const_reference             back (void) const;

    // alterations
    void                        swap (SearchPath &x);

    void                        push_front (const Filename &dir);
    void                        push_back (const Filename &dir);
    iterator                    insert (iterator pos, const Filename &dir);
    void                        insert (iterator pos, const_iterator first,
                                        const_iterator last);

    void                        pop_front (void);
    void                        pop_back (void);
    iterator                    erase (iterator pos);
    iterator                    erase (iterator first, iterator last);
    void                        clear (void);

    void                        splice (iterator pos, SearchPath &x);
    void                        splice (iterator pos, SearchPath &x,
                                        iterator i);
    void                        splice (iterator pos, SearchPath &x,
                                        iterator first, iterator last);

    void                        remove (const Filename &dir);
    void                        reverse (void);

    // file search services (FIXME: should these accept mode to
    // describe what one should search for: existence, read, write,
    // execute, combinations?)
    Filename                    expand (const Filename &name) const;
    const_iterator              search (const Filename &name) const;
    const_iterator              search (const_iterator from,
                                        const Filename &name) const;

    // system information
    static const char *         separator (void);

private:
    DirList                     m_list;
};

//<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
//<<<<<< INLINE MEMBER FUNCTIONS                                        >>>>>>

inline
SearchPath::SearchPath (void)
{}

# if HAVE_MEMBER_TEMPLATES

template <class I> inline
SearchPath::SearchPath (I first, I last)
    : m_list (first, last)
{}
# else // ! HAVE_MEMBER_TEMPLATES

inline
SearchPath::SearchPath (const_iterator first, const_iterator last)
    : m_list (first, last)
{}
# endif // HAVE_MEMBER_TEMPLATES

inline bool
SearchPath::operator== (const SearchPath &x)
{ return m_list == x.m_list; }

inline bool
SearchPath::empty (void) const
{ return m_list.empty (); }

inline SearchPath::size_type
SearchPath::size (void) const
{ return m_list.size (); }

inline SearchPath::iterator
SearchPath::begin (void)
{ return m_list.begin (); }

inline SearchPath::const_iterator
SearchPath::begin (void) const
{ return m_list.begin (); }

inline SearchPath::iterator
SearchPath::end (void)
{ return m_list.end (); }

inline SearchPath::const_iterator
SearchPath::end (void) const
{ return m_list.end (); }

inline SearchPath::reverse_iterator
SearchPath::rbegin (void)
{ return m_list.rbegin (); }

inline SearchPath::const_reverse_iterator
SearchPath::rbegin (void) const
{ return m_list.rbegin (); }

inline SearchPath::reverse_iterator
SearchPath::rend (void)
{ return m_list.rend (); }

inline SearchPath::const_reverse_iterator
SearchPath::rend (void) const
{ return m_list.rend (); }

inline SearchPath::reference
SearchPath::front (void)
{ return m_list.front (); }

inline SearchPath::const_reference
SearchPath::front (void) const
{ return m_list.front (); }

inline SearchPath::reference
SearchPath::back (void)
{ return m_list.back (); }

inline SearchPath::const_reference
SearchPath::back (void) const
{ return m_list.back (); }

inline void
SearchPath::swap (SearchPath &x)
{ m_list.swap (x.m_list); }

inline void
SearchPath::push_front (const Filename &dir)
{ m_list.push_front (dir); }

inline void
SearchPath::push_back (const Filename &dir)
{ m_list.push_back (dir); }

inline SearchPath::iterator
SearchPath::insert (iterator pos, const Filename &dir)
{ return m_list.insert (pos, dir); }

inline void
SearchPath::insert (iterator pos, const_iterator first, const_iterator last)
{ m_list.insert (pos, first, last); }

inline void
SearchPath::pop_front (void)
{ m_list.pop_front (); }

inline void
SearchPath::pop_back (void)
{ m_list.pop_back (); }

inline SearchPath::iterator
SearchPath::erase (iterator pos)
{ return m_list.erase (pos); }

inline SearchPath::iterator
SearchPath::erase (iterator first, iterator last)
{ return m_list.erase (first, last); }

inline void
SearchPath::clear (void)
{ m_list.clear (); }

inline void
SearchPath::splice (iterator pos, SearchPath &x)
{ m_list.splice (pos, x.m_list); }

inline void
SearchPath::splice (iterator pos, SearchPath &x, iterator i)
{ m_list.splice (pos, x.m_list, i); }

inline void
SearchPath::splice (iterator pos, SearchPath &x, iterator first, iterator last)
{ m_list.splice (pos, x.m_list, first, last); }

inline void
SearchPath::remove (const Filename &dir)
{ m_list.remove (dir); }

inline void
SearchPath::reverse (void)
{ m_list.reverse (); }

inline SearchPath::const_iterator
SearchPath::search (const Filename &name) const
{ return search (begin (), name); }

} // namespace lat
#endif // CLASSLIB_SEARCH_PATH_H

---