findfile_sequence.hpp

新版本TR1的stl

{
    INETSTL_ASSERT(NULL != p0);
    INETSTL_ASSERT(NULL != p1);
    INETSTL_ASSERT(p0 <= p1);

    return stlsoft_ns_qual(find_next_token)(p0, p1, delim);
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline /* static */ HINTERNET basic_findfile_sequence_const_input_iterator<C, T, X, V>::find_first_file_(  HINTERNET                                                                                   hconn
#ifdef STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED
    ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const*  pattern
    ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::flags_type        flags
    ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::find_data_type*   findData)
#else /* ? STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED */
    ,   char_type const*    pattern
    ,   flags_type          flags
    ,   find_data_type*     findData)
#endif /* STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED */
{
    HINTERNET   hSrch = traits_type::find_first_file(hconn, pattern, findData);

    if(hSrch != NULL)
    {
        // Now need to validate against the flags
        for(; hSrch != NULL; )
        {
            if(0 == (findData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            {
                // A file, and files requested, so break
                if(flags & sequence_type::files)
                {
                    break;
                }
            }
            else
            {
                if(traits_type::is_dots(findData->cFileName))
                {
                    if(flags & sequence_type::includeDots)
                    {
                        // A dots file, and dots are requested
                        break;
                    }
                }
                else if(flags & sequence_type::directories)
                {
                    // A directory, and directories requested
                    break;
                }
            }

            if(!traits_type::find_next_file(hSrch, findData))
            {
                traits_type::find_close(hSrch);

                hSrch = NULL;

                break;
            }
        }
    }

    return hSrch;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::basic_findfile_sequence_const_input_iterator()
    : m_list(NULL)
    , m_handle(NULL)
    , m_rootDir(NULL)
    , m_pattern0(NULL)
    , m_pattern1(NULL)
    , m_delim('\0')
    , m_flags(0)
{}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::basic_findfile_sequence_const_input_iterator( sequence_type const&                                                                         l
#ifdef STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED
    ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const*   rootDir
    ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const*   patterns
    ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type          delim
    ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::flags_type         flags)
#else /* ? STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED */
    ,   char_type const*    rootDir
    ,   char_type const*    patterns
    ,   char_type           delim
    ,   flags_type          flags)
#endif /* STLSOFT_CF_FUNCTION_SIGNATURE_FULL_ARG_QUALIFICATION_REQUIRED */
    : m_list(&l)
    , m_handle(NULL)
    , m_rootDir(rootDir)
    , m_pattern0(patterns)
    , m_pattern1(patterns)
    , m_delim(delim)
    , m_flags(flags)
{
    operator ++();
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::basic_findfile_sequence_const_input_iterator(sequence_type const& l)
    : m_list(&l)
    , m_handle(NULL)
    , m_rootDir(NULL)
    , m_pattern0(NULL)
    , m_pattern1(NULL)
    , m_delim('\0')
    , m_flags(0)
{}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::basic_findfile_sequence_const_input_iterator(class_type const& rhs)
    : m_list(rhs.m_list)
    , m_handle(rhs.m_handle)
    , m_data(rhs.m_data)
    , m_rootDir(rhs.m_rootDir)
    , m_pattern0(rhs.m_pattern0)
    , m_pattern1(rhs.m_pattern1)
    , m_delim(rhs.m_delim)
    , m_flags(rhs.m_flags)
{
    if(NULL != m_handle)
    {
        m_handle->AddRef();
    }
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
#ifndef STLSOFT_COMPILER_IS_WATCOM
inline ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::class_type &basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator =(ss_typename_param_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::class_type const& rhs)
#else /* ? compiler */
inline basic_findfile_sequence_const_input_iterator<C, T, X, V> &basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator =(basic_findfile_sequence_const_input_iterator<C, T, X, V> const& rhs)
#endif /* compiler */
{
    INETSTL_MESSAGE_ASSERT("Assigning iterators from separate sequences", NULL == m_list || NULL == rhs.m_list || m_list == rhs.m_list);    // Should only be comparing iterators from same container

    shared_handle   *this_handle    =   m_handle;

    m_handle    =   rhs.m_handle;
    m_data      =   rhs.m_data;
    m_rootDir   =   rhs.m_rootDir;
    m_pattern0  =   rhs.m_pattern0;
    m_pattern1  =   rhs.m_pattern1;
    m_delim     =   rhs.m_delim;
    m_flags     =   rhs.m_flags;

    if(NULL != m_handle)
    {
        m_handle->AddRef();
    }

    if(NULL != this_handle)
    {
        this_handle->Release();
    }

    return *this;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline basic_findfile_sequence_const_input_iterator<C, T, X, V>::~basic_findfile_sequence_const_input_iterator() stlsoft_throw_0()
{
    if(NULL != m_handle)
    {
        m_handle->Release();
    }
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::class_type &basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator ++()
{
    INETSTL_ASSERT(NULL != m_pattern0);
    INETSTL_ASSERT(NULL != m_pattern1);

    INETSTL_MESSAGE_ASSERT("Attempting to increment an invalid iterator!", '\0' != *m_pattern0);

    // Possible call states:
    //
    //  1. starting out
    //  2.

    for(; '\0' != *m_pattern0 || '\0' != *m_pattern1;)
    {
        if(NULL == m_handle)
        {
            // Need to work through the

            while(find_next_pattern_(m_pattern0, m_pattern1, m_delim))
            {
                if(m_pattern1 != m_pattern0)    // Will return m_pattern0 == m_pattern1 for empty tokens
                {
                    string_type     pattern(m_pattern0, m_pattern1);
                    string_type     search  =   m_rootDir;

                    if(search.back() != '/')
                    {
                        static const char_type  slash[] = { '/', '\0' };

                        search += slash;
                    }
                    search += pattern;

//printf("[%s]\n", search.c_str());
                    HINTERNET       hSrch   =   find_first_file_(m_list->m_hconn, stlsoft_ns_qual(c_str_ptr)(search), m_flags, &m_data);

                    if(NULL != hSrch)
                    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
                        try
                        {
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
                            m_handle = new shared_handle(hSrch);

                            if(NULL == m_handle)
                            {
                                ::FindClose(hSrch);
                            }
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
                        }
                        catch(...)
                        {
                            ::FindClose(hSrch);

                            throw;
                        }
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */

                        return *this;
                    }
                }
            }
        }

        if(NULL != m_handle)
        {
            for(; m_handle->hSrch != NULL; )
            {
                if(!traits_type::find_next_file(m_handle->hSrch, &m_data))
                {
                    m_handle->Release();

                    m_handle = NULL;

                    break;
                }
                else
                {
                    if((m_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
                    {
                        // A file, and files requested, so break
                        if(m_flags & sequence_type::files)
                        {
                            return *this;
                        }
                    }
                    else
                    {
                        if(traits_type::is_dots(m_data.cFileName))
                        {
                            if(m_flags & sequence_type::includeDots)
                            {
                                // A dots file, and dots are requested
                                return *this;
                            }
                        }
                        else if(m_flags & sequence_type::directories)
                        {
                            // A directory, and directories requested
                            return *this;
                        }
                    }
                }
            }
        }
    }

    return *this;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::class_type basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator ++(int)
{
    class_type  ret(*this);

    operator ++();

    return ret;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline const ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::value_type basic_findfile_sequence_const_input_iterator<C, T, X, V>::operator *() const
{
    if(NULL != m_handle)
    {
        return value_type(m_data, m_list->get_directory());
    }
    else
    {
        INETSTL_MESSAGE_ASSERT("Dereferencing end()-valued iterator", 0);

        return value_type();
    }
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X, ss_typename_param_k V>
inline is_bool_t basic_findfile_sequence_const_input_iterator<C, T, X, V>::equal(class_type const& rhs) const
{
    // Should only be comparing iterators from same container
    INETSTL_MESSAGE_ASSERT("Comparing iterators from separate sequences", m_list == rhs.m_list || NULL == m_list || NULL == rhs.m_list);

    return m_handle == rhs.m_handle;
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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

#ifndef _INETSTL_NO_NAMESPACE
# if defined(_STLSOFT_NO_NAMESPACE) || \
     defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
} // namespace inetstl
# else
} // namespace inetstl_project
} // namespace stlsoft
# endif /* _STLSOFT_NO_NAMESPACE */
#endif /* !_INETSTL_NO_NAMESPACE */

/* /////////////////////////////////////////////////////////////////////////
 * Namespace
 *
 * The string access shims exist either in the stlsoft namespace, or in the
 * global namespace. This is required by the lookup rules.
 *
 */

#ifndef _INETSTL_NO_NAMESPACE
# if !defined(_STLSOFT_NO_NAMESPACE) && \
     !defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
namespace stlsoft
{
# else /* ? _STLSOFT_NO_NAMESPACE */
/* There is no stlsoft namespace, so must define in the global namespace */
# endif /* !_STLSOFT_NO_NAMESPACE */

using ::inetstl::c_str_data;
using ::inetstl::c_str_data_a;
using ::inetstl::c_str_data_w;

using ::inetstl::c_str_len;
using ::inetstl::c_str_len_a;
using ::inetstl::c_str_len_w;

using ::inetstl::c_str_ptr;
using ::inetstl::c_str_ptr_a;
using ::inetstl::c_str_ptr_w;

using ::inetstl::c_str_ptr_null;
using ::inetstl::c_str_ptr_null_a;
using ::inetstl::c_str_ptr_null_w;

# if !defined(_STLSOFT_NO_NAMESPACE) && \
     !defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
} // namespace stlsoft
# else /* ? _STLSOFT_NO_NAMESPACE */
/* There is no stlsoft namespace, so must define in the global namespace */
# endif /* !_STLSOFT_NO_NAMESPACE */
#endif /* !_INETSTL_NO_NAMESPACE */

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

#endif /* INETSTL_INCL_INETSTL_FILESYSTEM_HPP_FINDFILE_SEQUENCE */

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