platformstl/filesystem/readdir_sequence.hpp

Go to the documentation of this file.

/* /////////////////////////////////////////////////////////////////////////
 * File:        platformstl/filesystem/readdir_sequence.hpp
 *
 * Purpose:     Platform header for the readdir_sequence components.
 *
 * Created:     29th April 2006
 * Updated:     10th August 2009
 *
 * Home:        http://stlsoft.org/
 *
 * Copyright (c) 2006-2009, Matthew Wilson and Synesis Software
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of
 *   any contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * ////////////////////////////////////////////////////////////////////// */


#ifndef PLATFORMSTL_INCL_PLATFORMSTL_FILESYSTEM_HPP_READDIR_SEQUENCE
#define PLATFORMSTL_INCL_PLATFORMSTL_FILESYSTEM_HPP_READDIR_SEQUENCE

/* File version */
#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
# define PLATFORMSTL_VER_PLATFORMSTL_FILESYSTEM_HPP_READDIR_SEQUENCE_MAJOR      2
# define PLATFORMSTL_VER_PLATFORMSTL_FILESYSTEM_HPP_READDIR_SEQUENCE_MINOR      2
# define PLATFORMSTL_VER_PLATFORMSTL_FILESYSTEM_HPP_READDIR_SEQUENCE_REVISION   2
# define PLATFORMSTL_VER_PLATFORMSTL_FILESYSTEM_HPP_READDIR_SEQUENCE_EDIT       18
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////
 * Includes
 */

#ifndef PLATFORMSTL_INCL_PLATFORMSTL_HPP_PLATFORMSTL
# include <platformstl/platformstl.hpp>
#endif /* !PLATFORMSTL_INCL_PLATFORMSTL_HPP_PLATFORMSTL */

#if defined(PLATFORMSTL_OS_IS_UNIX)
# ifndef UNIXSTL_INCL_UNIXSTL_FILESYSTEM_HPP_READDIR_SEQUENCE
#  include <unixstl/filesystem/readdir_sequence.hpp>
# endif /* !UNIXSTL_INCL_UNIXSTL_FILESYSTEM_HPP_READDIR_SEQUENCE */
#elif defined(PLATFORMSTL_OS_IS_WINDOWS)
# ifndef WINSTL_INCL_WINSTL_FILESYSTEM_HPP_FINDFILE_SEQUENCE
#  include <winstl/filesystem/findfile_sequence.hpp>
# endif /* !WINSTL_INCL_WINSTL_FILESYSTEM_HPP_FINDFILE_SEQUENCE */
# ifndef WINSTL_INCL_WINSTL_FILESYSTEM_HPP_FILESYSTEM_TRAITS
#  include <winstl/filesystem/filesystem_traits.hpp>
# endif /* !WINSTL_INCL_WINSTL_FILESYSTEM_HPP_FILESYSTEM_TRAITS */
#else /* ? operating system */
# error Operating system not discriminated
#endif /* operating system */

/* /////////////////////////////////////////////////////////////////////////
 * Namespace
 */

#if defined(_STLSOFT_NO_NAMESPACE) || \
    defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
/* There is no stlsoft namespace, so must define ::platformstl */
namespace platformstl
{
#else
/* Define stlsoft::platformstl_project */

namespace stlsoft
{

namespace platformstl_project
{
#endif /* _STLSOFT_NO_NAMESPACE */

/* ////////////////////////////////////////////////////////////////////// */

#if defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)

    class readdir_sequence
    {};

#elif defined(PLATFORMSTL_OS_IS_UNIX)

# ifdef _UNIXSTL_NO_NAMESPACE
    using ::readdir_sequence;
# else /* ? _UNIXSTL_NO_NAMESPACE */
    using ::unixstl::readdir_sequence;
# endif /* _UNIXSTL_NO_NAMESPACE */

#elif defined(PLATFORMSTL_OS_IS_WINDOWS)

    class readdir_sequence
    {
    public:
        // This class
        typedef readdir_sequence                                    class_type;
    private:
        typedef winstl_ns_qual(ws_char_a_t)                         char_type;
        typedef winstl_ns_qual(basic_findfile_sequence)<char_type>  underlying_sequence_type;
        typedef winstl_ns_qual(filesystem_traits)<char_type>        traits_type;
    public:
        typedef underlying_sequence_type::const_iterator            underlying_sequence_const_iterator_type;
        typedef underlying_sequence_type::value_type                underlying_sequence_value_type;
    public:
        // The size type
        typedef winstl_ns_qual(ws_size_t)                           size_type;
        // The non-mutating (const) iterator type
        class                                                       const_iterator;
        // The value type
        typedef char_type const*                                    value_type;
        typedef winstl_ns_qual(ws_int_t)                            flags_type;
        typedef winstl_ns_qual(ws_bool_t)                           bool_type;

    public:

    public:
        enum search_flags
        {
                includeDots     =   0x0008  
            ,   directories     =   0x0010  
            ,   files           =   0x0020  
            ,   fullPath        =   0x0100  
            ,   absolutePath    =   0x0200  
        };

    public:
        template <ss_typename_param_k S>
        ss_explicit_k readdir_sequence(S const& directory)
            : m_ffs(stlsoft_ns_qual(c_str_ptr)(directory), "*.*", translate_flags_(directories | files))
            , m_flags(validate_flags_(directories | files))
        {}

        template <ss_typename_param_k S>
        readdir_sequence(S const& directory, flags_type flags)
            : m_ffs(stlsoft_ns_qual(c_str_ptr)(directory), "*.*", translate_flags_(flags))
            , m_flags(validate_flags_(flags))
        {}

        template <ss_typename_param_k S>
        readdir_sequence(S const& directory, search_flags flags)
            : m_ffs(stlsoft_ns_qual(c_str_ptr)(directory), "*.*", translate_flags_(flags))
            , m_flags(validate_flags_(flags))
        {}

    public:
        const_iterator  begin() const;
        const_iterator  end() const;

    public:
        bool_type           empty() const;

        char_type const     *get_directory() const;

        flags_type          get_flags() const;

    private:
        static flags_type   validate_flags_(flags_type flags);

        static flags_type   translate_flags_(flags_type flags);

    private:
        const underlying_sequence_type  m_ffs;
        const flags_type                m_flags;

    private:
        readdir_sequence(class_type const&);
        class_type& operator =(class_type const&);
    };


    class readdir_sequence::const_iterator
        : public stlsoft_ns_qual(iterator_base)<platformstl_ns_qual_std(input_iterator_tag)
                                            ,   readdir_sequence::value_type
                                            ,   ss_ptrdiff_t
                                            ,   void
                                            ,   readdir_sequence::value_type
                                            >
    {
    public:
        typedef const_iterator                          class_type;
        typedef readdir_sequence::value_type            value_type;
        typedef readdir_sequence::flags_type            flags_type;

    private:
        friend class readdir_sequence;

        const_iterator(underlying_sequence_const_iterator_type it, flags_type flags)
            : m_it(it)
            , m_flags(flags)
        {}
    public:
        const_iterator()
            : m_it()
            , m_flags(0)
        {}
        const_iterator(class_type const& rhs)
            : m_it(rhs.m_it)
            , m_flags(rhs.m_flags)
        {}
        ~const_iterator() stlsoft_throw_0()
        {}

        class_type const& operator =(class_type const& rhs)
        {
            m_it    =   rhs.m_it;
            m_flags =   rhs.m_flags;

            return *this;
        }

    public:
        value_type operator *() const
        {
            remove_const(m_value)   =   *m_it;

            return (fullPath & m_flags) ? m_value.get_path() : m_value.get_filename();
        }

        class_type& operator ++()
        {
            ++m_it;

            return *this;
        }

        class_type operator ++(int)
        {
            class_type  r(*this);

            operator ++();

            return r;
        }

        bool equal(class_type const& rhs) const
        {
            return m_it == rhs.m_it;
        }

    private:
        underlying_sequence_const_iterator_type m_it;
        underlying_sequence_value_type          m_value;
        flags_type                              m_flags;
    };

    inline /* static */ readdir_sequence::flags_type readdir_sequence::validate_flags_(readdir_sequence::flags_type flags)
    {
        const flags_type    validFlags  =   0
                                        |   includeDots
                                        |   directories
                                        |   files
                                        |   fullPath
                                        |   absolutePath
                                        |   0;

        WINSTL_MESSAGE_ASSERT("Specification of unrecognised/unsupported flags", flags == (flags & validFlags));
        STLSOFT_SUPPRESS_UNUSED(validFlags);

        if(0 == (flags & (directories | files)))
        {
            flags |= (directories | files);
        }

        return flags;
    }

    inline /* static */ readdir_sequence::flags_type readdir_sequence::translate_flags_(readdir_sequence::flags_type flags)
    {
        flags_type  translatedFlags =   0;

        if(underlying_sequence_type::includeDots & flags)
        {
            translatedFlags |= underlying_sequence_type::includeDots;
        }

        if(directories & flags)
        {
            translatedFlags |= underlying_sequence_type::directories;
        }

        if(files & flags)
        {
            translatedFlags |= underlying_sequence_type::files;
        }

        if(fullPath == ((fullPath | absolutePath) & flags))
        {
            translatedFlags |= underlying_sequence_type::relativePath;
        }

        return translatedFlags;
    }


    inline readdir_sequence::const_iterator readdir_sequence::begin() const
    {
        return const_iterator(m_ffs.begin(), m_flags);
    }

    inline readdir_sequence::const_iterator readdir_sequence::end() const
    {
        return const_iterator(m_ffs.end(), m_flags);
    }

    inline readdir_sequence::bool_type readdir_sequence::empty() const
    {
        return m_ffs.empty();
    }

    inline readdir_sequence::char_type const* readdir_sequence::get_directory() const
    {
        return m_ffs.get_directory();
    }

    inline readdir_sequence::flags_type readdir_sequence::get_flags() const
    {
        return m_flags;
    }

    inline ss_bool_t operator ==(   readdir_sequence::const_iterator const& lhs
                                ,   readdir_sequence::const_iterator const& rhs)
    {
        return lhs.equal(rhs);
    }

    inline ss_bool_t operator !=(   readdir_sequence::const_iterator const& lhs
                                ,   readdir_sequence::const_iterator const& rhs)
    {
        return !lhs.equal(rhs);
    }

#else /* ? operating system */
# error Operating system not discriminated
#endif /* operating system */

/* ////////////////////////////////////////////////////////////////////// */

#if defined(_STLSOFT_NO_NAMESPACE) || \
    defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
} // namespace platformstl
#else
} // namespace platformstl_project
} // namespace stlsoft
#endif /* _STLSOFT_NO_NAMESPACE */

#if defined(PLATFORMSTL_OS_IS_WINDOWS) && \
    (   defined(STLSOFT_COMPILER_IS_BORLAND) || \
        defined(STLSOFT_COMPILER_IS_DMC))

inline int operator ==( platformstl::readdir_sequence::const_iterator const& lhs
                    ,   platformstl::readdir_sequence::const_iterator const& rhs)
{
    return lhs.equal(rhs);
}

inline int operator !=( platformstl::readdir_sequence::const_iterator const& lhs
                    ,   platformstl::readdir_sequence::const_iterator const& rhs)
{
    return !lhs.equal(rhs);
}

#endif /* WIN32 && compiler */

/* ////////////////////////////////////////////////////////////////////// */

#endif /* !PLATFORMSTL_INCL_PLATFORMSTL_FILESYSTEM_HPP_READDIR_SEQUENCE */

/* ///////////////////////////// end of file //////////////////////////// */

---