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

// basic_findfile_sequence_value_type

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

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

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

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

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

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

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

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

template <ss_typename_param_k C, ss_typename_param_k T>
inline C const *c_str_ptr(basic_findfile_sequence_value_type<C, T> const &v)
{
    return v.get_path();
}
template <ss_typename_param_k T>
inline ws_char_a_t const *c_str_ptr(basic_findfile_sequence_value_type<ws_char_a_t, T> const &v)
{
    return v.get_path();
}
template <ss_typename_param_k T>
inline ws_char_w_t const *c_str_ptr(basic_findfile_sequence_value_type<ws_char_w_t, T> const &v)
{
    return v.get_path();
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline C const *c_str_data(basic_findfile_sequence_value_type<C, T> const &v)
{
    return v.get_path();
}
template <ss_typename_param_k T>
inline ws_char_a_t const *c_str_data(basic_findfile_sequence_value_type<ws_char_a_t, T> const &v)
{
    return v.get_path();
}
template <ss_typename_param_k T>
inline ws_char_w_t const *c_str_data(basic_findfile_sequence_value_type<ws_char_w_t, T> const &v)
{
    return v.get_path();
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_size_t c_str_len(basic_findfile_sequence_value_type<C, T> const &v)
{
    return v.length();
}

#if 0
template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_size_t c_str_size(basic_findfile_sequence_value_type<C, T> const &v)
{
    return v.length() * sizeof(C);
}
#endif /* 0 */

template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_bool_t is_empty(basic_findfile_sequence<C, T> 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>
inline /* static */ ss_typename_type_k basic_findfile_sequence<C, T>::flags_type basic_findfile_sequence<C, T>::validate_flags_(ss_typename_type_k basic_findfile_sequence<C, T>::flags_type flags)
{
    const flags_type    validFlags  =   0
                                    |   includeDots
                                    |   directories
                                    |   files
                                    |   skipReparseDirs
                                    |   skipHiddenFiles
                                    |   skipHiddenDirs
                                    |   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;
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline /* static */ ss_typename_type_k basic_findfile_sequence<C, T>::bool_type basic_findfile_sequence<C, T>::is_valid() const
{
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
    if('\0' == m_directory[0])
    {
# ifdef STLSOFT_UNITTEST
        fprintf(stderr, "m_directory is empty when exception handling is enabled\n");
# endif /* STLSOFT_UNITTEST */

        return false;
    }
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */

    // m_directory should either be empty, or should end with a slash
    if( '\0' != m_directory[0] &&
        !traits_type::has_dir_end(m_directory.c_str()))
    {
#ifdef STLSOFT_UNITTEST
        fprintf(stderr, "m_directory is not empty and does not have a trailing path name separator; m_directory=%s\n", m_directory.c_str());
#endif /* STLSOFT_UNITTEST */

        return false;
    }

    return true;
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline /* static */ void basic_findfile_sequence<C, T>::validate_directory_(char_type const *directory, file_path_buffer_type_ &dir)
{
    if( NULL == directory ||
        '\0' == *directory)
    {
        static char_type    s_cwd[] = { '.', '\0' };

        directory = &s_cwd[0];
    }

    if(0 == traits_type::get_full_path_name(directory, dir.size(), &dir[0]))
    {
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        throw windows_exception(::GetLastError());
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        dir[0] = '\0';
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }
    else
    {
        traits_type::ensure_dir_end(&dir[0]);
    }
}

// Construction
template <ss_typename_param_k C, ss_typename_param_k T>
inline basic_findfile_sequence<C, T>::basic_findfile_sequence(char_type const *pattern, flags_type flags /* = directories | files */)
    : m_delim(0)
    , m_flags(validate_flags_(flags))
    , m_patterns(1 + traits_type::str_len(pattern))
{
    validate_directory_(NULL, m_directory);

    traits_type::str_n_copy(&m_patterns[0], pattern, m_patterns.size());

    WINSTL_ASSERT(is_valid());
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline basic_findfile_sequence<C, T>::basic_findfile_sequence(  char_type const *patterns
                                                            ,   char_type       delim
                                                            ,   flags_type      flags /* = directories | files */)
    : m_delim(delim)
    , m_flags(validate_flags_(flags))
    , m_patterns(1 + traits_type::str_len(patterns))
{
    validate_directory_(NULL, m_directory);

    traits_type::str_n_copy(&m_patterns[0], patterns, m_patterns.size());

    WINSTL_ASSERT(is_valid());
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline basic_findfile_sequence<C, T>::basic_findfile_sequence(  char_type const *directory
                                                            ,   char_type const *pattern
                                                            ,   flags_type      flags /* = directories | files */)
    : m_delim(0)
    , m_flags(validate_flags_(flags))
    , m_patterns(1 + traits_type::str_len(pattern))
{
    validate_directory_(directory, m_directory);

    traits_type::str_n_copy(&m_patterns[0], pattern, m_patterns.size());

    WINSTL_ASSERT(is_valid());
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline basic_findfile_sequence<C, T>::basic_findfile_sequence(  char_type const *directory
                                                            ,   char_type const *patterns
                                                            ,   char_type       delim
                                                            ,   flags_type      flags /* = directories | files */)
    : m_delim(delim)
    , m_flags(validate_flags_(flags))
    , m_patterns(1 + traits_type::str_len(patterns))
{
    validate_directory_(directory, m_directory);

    traits_type::str_n_copy(&m_patterns[0], patterns, m_patterns.size());

    WINSTL_ASSERT(is_valid());
}

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

#ifdef _DEBUG
    m_directory[0]  =   '\0';
    m_patterns[0]     =   '\0';
#endif /* _DEBUG */
}

// Iteration
template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence<C, T>::const_iterator basic_findfile_sequence<C, T>::begin() const
{
    WINSTL_ASSERT(is_valid());

#ifndef STLSOFT_CF_EXCEPTION_SUPPORT
    if('\0' == m_directory[0])
    {
        ::SetLastError(ERROR_INVALID_NAME);

        return const_iterator(*this);
    }
#endif /* !STLSOFT_CF_EXCEPTION_SUPPORT */

    return const_iterator(*this, m_patterns.data(), m_delim, m_flags);
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence<C, T>::const_iterator basic_findfile_sequence<C, T>::end() const
{
    WINSTL_ASSERT(is_valid());

    return const_iterator(*this);
}

// Attributes
template <ss_typename_param_k C, ss_typename_param_k T>
ss_typename_type_k basic_findfile_sequence<C, T>::char_type const *basic_findfile_sequence<C, T>::get_directory() const
{
    WINSTL_ASSERT(is_valid());

    return m_directory.c_str();
}

// State

template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence<C, T>::bool_type basic_findfile_sequence<C, T>::empty() const
{
    WINSTL_ASSERT(is_valid());

    return begin() == end();
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline /* static */ ss_typename_type_k basic_findfile_sequence<C, T>::size_type basic_findfile_sequence<C, T>::max_size()
{
    return static_cast<size_type>(-1);
}