findfile_sequence.hpp

用STL的方式封装了WindowsAPI、COM调用、ACE、ATL、MFC、WTL等多种组件

{
    return lhs.equal(rhs);
}

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 operator !=(   basic_findfile_sequence_const_input_iterator<C, T, X, V> const &lhs
                            ,   basic_findfile_sequence_const_input_iterator<C, T, X, V> const &rhs)
{
    return !lhs.equal(rhs);
}

// basic_findfile_sequence_value_type

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_bool_t operator == (  basic_findfile_sequence_value_type<C, T, X> const  &lhs
                            ,   basic_findfile_sequence_value_type<C, T, X> const  &rhs)
{
    return lhs.equal(rhs);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_bool_t operator == (  basic_findfile_sequence_value_type<C, T, X> const  &lhs
                            ,   C const                                         *rhs)
{
    return lhs.equal(rhs);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_bool_t operator == (  C const *lhs, basic_findfile_sequence_value_type<C, T, X> const &rhs)
{
    return rhs.equal(lhs);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_bool_t operator != (  basic_findfile_sequence_value_type<C, T, X> const  &lhs
                            ,   basic_findfile_sequence_value_type<C, T, X> const  &rhs)
{
    return !lhs.equal(rhs);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_bool_t operator != (  basic_findfile_sequence_value_type<C, T, X> const  &lhs
                            ,   C const                                         *rhs)
{
    return !lhs.equal(rhs);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_bool_t operator != (  C const *lhs, basic_findfile_sequence_value_type<C, T, X> const &rhs)
{
    return !rhs.equal(lhs);
}

////////////////////////////////////////////////////////////////////////////
// Shims

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline C const *c_str_ptr_null(basic_findfile_sequence_value_type<C, T, X> const &v)
{
    return stlsoft_ns_qual(c_str_ptr_null(v.get_path()));
}
template<   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_char_a_t const *c_str_ptr_null_a(basic_findfile_sequence_value_type<is_char_a_t, T, X> const &v)
{
    return stlsoft_ns_qual(c_str_ptr_null(v.get_path()));
}
template<   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_char_w_t const *c_str_ptr_null_w(basic_findfile_sequence_value_type<is_char_w_t, T, X> const &v)
{
    return stlsoft_ns_qual(c_str_ptr_null(v.get_path()));
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline C const *c_str_ptr(basic_findfile_sequence_value_type<C, T, X> const &v)
{
    return v.get_path();
}
template<   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_char_a_t const *c_str_ptr_a(basic_findfile_sequence_value_type<is_char_a_t, T, X> const &v)
{
    return v.get_path();
}
template<   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_char_w_t const *c_str_ptr_w(basic_findfile_sequence_value_type<is_char_w_t, T, X> const &v)
{
    return v.get_path();
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline C const *c_str_data(basic_findfile_sequence_value_type<C, T, X> const &v)
{
    return v.get_path();
}
template<   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_char_a_t const *c_str_data_a(basic_findfile_sequence_value_type<is_char_a_t, T, X> const &v)
{
    return v.get_path();
}
template<   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_char_w_t const *c_str_data_w(basic_findfile_sequence_value_type<is_char_w_t, T, X> const &v)
{
    return v.get_path();
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_size_t c_str_len(basic_findfile_sequence_value_type<C, T, X> const &v)
{
    return stlsoft_ns_qual(c_str_len(v.get_path()));
}

#if 0
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_size_t c_str_size(basic_findfile_sequence_value_type<C, T, X> const &v)
{
    return stlsoft_ns_qual(c_str_size(v.get_path()));
}
#endif /* 0 */

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline is_bool_t is_empty(basic_findfile_sequence<C, T, X> const &s)
{
    return s.empty();
}

////////////////////////////////////////////////////////////////////////////
// Unit-testing

#ifdef STLSOFT_UNITTEST
# include "./unittest/findfile_sequence_unittest_.h"
#endif /* STLSOFT_UNITTEST */

////////////////////////////////////////////////////////////////////////////
// Implementation

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

// basic_findfile_sequence

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline /* static */ HINTERNET basic_findfile_sequence<C, T, X>::find_first_file_(HINTERNET                                                             hconn
                                                                            ,   ss_typename_type_k basic_findfile_sequence<C, T, X>::char_type const   *spec
                                                                            ,   ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type        /* flags */
                                                                            ,   ss_typename_type_k basic_findfile_sequence<C, T, X>::find_data_type    *findData)
{
    HINTERNET   hSrch   =   traits_type::find_first_file(hconn, spec, findData);

    if(NULL == hSrch)
    {
        DWORD       dwErr   =   ::GetLastError();

        if(ERROR_FTP_TRANSFER_IN_PROGRESS == dwErr)
        {
            exception_policy_type()("Already enumerating using current connection", dwErr);
        }
        else
        {
            exception_policy_type()("Search failed", dwErr);
        }
    }

    return hSrch;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline /* static */ ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type basic_findfile_sequence<C, T, X>::validate_flags_(ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type flags)
{
    const flags_type    validFlags  =   0
                                    |   includeDots
                                    |   directories
                                    |   files
#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
                                    |   noSort
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
                                    |   0;

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

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

    return flags;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline /* static */ is_bool_t basic_findfile_sequence<C, T, X>::is_valid() const
{
    return true;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline /* static */ void basic_findfile_sequence<C, T, X>::extract_subpath_(HINTERNET hconn, char_type *dest, char_type const *pattern)
{
    char_type   *pFile;

    traits_type::get_full_path_name(hconn, pattern, _MAX_PATH, dest, &pFile);

    if(NULL != pFile)
    {
        *pFile = '\0';
    }
}

// Construction
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline basic_findfile_sequence<C, T, X>::basic_findfile_sequence(HINTERNET hconn, char_type const *pattern, ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type flags /* = directories | files */)
    : m_hconn(hconn)
    , m_delim('\0')
    , m_flags(validate_flags_(flags))
    , m_rootDir()
    , m_patterns(pattern)
{
    INETSTL_ASSERT(is_valid());
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline basic_findfile_sequence<C, T, X>::basic_findfile_sequence(HINTERNET hconn, char_type const *directory, char_type const * pattern, ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type flags /* = directories | files */)
    : m_hconn(hconn)
    , m_delim('\0')
    , m_flags(validate_flags_(flags))
    , m_rootDir(directory)
    , m_patterns(pattern)
{
    INETSTL_ASSERT(is_valid());
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline basic_findfile_sequence<C, T, X>::basic_findfile_sequence(  HINTERNET                                                       hconn
                                                            ,   char_type const                                                 *directory
                                                            ,   char_type const                                                 *patterns
                                                            ,   char_type                                                       delim
                                                            ,   ss_typename_type_k basic_findfile_sequence<C, T, X>::flags_type    flags /* = directories | files */)
    : m_hconn(hconn)
    , m_delim(delim)
    , m_flags(validate_flags_(flags))
    , m_rootDir(directory)
    , m_patterns(patterns)
{
    INETSTL_ASSERT(is_valid());
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k X
        >
inline basic_findfile_sequence<C, T, X>::~basic_findfile_sequence() stlsoft_throw_0()
{
    INETSTL_ASSERT(is_valid());
}

// Iteration
template<   ss_typename_param_k C