findfile_sequence.hpp

新版本TR1的stl

        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 ws_bool_t 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 */ ws_size_t basic_findfile_sequence<C, T>::max_size()
{
    return static_cast<ws_size_t>(-1);
}

// basic_findfile_sequence_value_type

template <ss_typename_param_k C, ss_typename_param_k T>
inline basic_findfile_sequence_value_type<C, T>::basic_findfile_sequence_value_type()
{
    m_data.dwFileAttributes         =   0xFFFFFFFF;
    m_data.cFileName[0]             =   '\0';
    m_data.cAlternateFileName[0]    =   '\0';
    m_path[0]                       =   '\0';
    m_pathLen                       =   0;
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence_value_type<C, T>::class_type &basic_findfile_sequence_value_type<C, T>::operator =(ss_typename_type_k basic_findfile_sequence_value_type<C, T>::class_type const& rhs)
{
    m_data      =   rhs.m_data;
    m_path      =   rhs.m_path;
    m_pathLen   =   rhs.m_pathLen;

    return *this;
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence_value_type<C, T>::find_data_type const& basic_findfile_sequence_value_type<C, T>::get_find_data() const
{
    return m_data;
}

#ifdef STLSOFT_OBSOLETE
template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence_value_type<C, T>::find_data_type const& basic_findfile_sequence_value_type<C, T>::GetFindData() const
{
    return get_find_data();
}
#endif /* STLSOFT_OBSOLETE */

template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence_value_type<C, T>::char_type const* basic_findfile_sequence_value_type<C, T>::get_filename() const
{
    return m_data.cFileName;
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence_value_type<C, T>::char_type const* basic_findfile_sequence_value_type<C, T>::get_short_filename() const
{
    return m_data.cAlternateFileName[0] != '\0' ? m_data.cAlternateFileName : m_data.cFileName;
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence_value_type<C, T>::char_type const* basic_findfile_sequence_value_type<C, T>::get_path() const
{
    return m_path.c_str();
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_typename_type_k basic_findfile_sequence_value_type<C, T>::char_type const* basic_findfile_sequence_value_type<C, T>::c_str() const
{
    return get_path();
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ss_size_t basic_findfile_sequence_value_type<C, T>::length() const
{
    WINSTL_ASSERT(traits_type::str_len(this->c_str()) == m_pathLen);

    return m_pathLen;
}

template <ss_typename_param_k C, ss_typename_param_k T>
#if defined(STLSOFT_COMPILER_IS_GCC) || \
    (   defined(STLSOFT_COMPILER_IS_MSVC) && \
        _MSC_VER < 1100)
inline basic_findfile_sequence_value_type<C, T>::operator C const* () const
#else /* ? compiler */
inline basic_findfile_sequence_value_type<C, T>::operator ss_typename_type_k basic_findfile_sequence_value_type<C, T>::char_type const* () const
#endif /* compiler */
{
    return get_path();
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_bool_t basic_findfile_sequence_value_type<C, T>::is_directory() const
{
    return traits_type::is_directory(&m_data);
}
template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_bool_t basic_findfile_sequence_value_type<C, T>::is_file() const
{
    return traits_type::is_file(&m_data);
}
template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_bool_t basic_findfile_sequence_value_type<C, T>::is_compressed() const
{
    return 0 != (m_data.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED);
}
#ifdef FILE_ATTRIBUTE_REPARSE_POINT
template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_bool_t basic_findfile_sequence_value_type<C, T>::is_reparse_point() const
{
    return 0 != (m_data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT);
}
#endif /* FILE_ATTRIBUTE_REPARSE_POINT */
template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_bool_t basic_findfile_sequence_value_type<C, T>::is_read_only() const
{
    return 0 != (m_data.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
}
template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_bool_t basic_findfile_sequence_value_type<C, T>::is_system() const
{
    return 0 != (m_data.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM);
}
template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_bool_t basic_findfile_sequence_value_type<C, T>::is_hidden() const
{
    return 0 != (m_data.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN);
}

template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_bool_t basic_findfile_sequence_value_type<C, T>::equal(char_type const* rhs) const
{
    return 0 == traits_type::str_compare_no_case(this->get_path(), rhs);
}

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

// basic_findfile_sequence_const_input_iterator

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
inline /* static */ HANDLE basic_findfile_sequence_const_input_iterator<C, T, V>::find_first_file_( ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, V>::char_type const* searchSpec
                                                                                                ,   flags_type flags
                                                                                                ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, V>::find_data_type* findData)
{
    HANDLE      hSrch = INVALID_HANDLE_VALUE;

    // A constant makes Borland weep the tears of unfathomable sadness, so an enum is used instead
//    const DWORD reparsePointConstant    =   0x00000400;

    enum
    {
#ifdef FILE_ATTRIBUTE_REPARSE_POINT
        reparsePointConstant    =   FILE_ATTRIBUTE_REPARSE_POINT
#else /* ? FILE_ATTRIBUTE_REPARSE_POINT */
        reparsePointConstant    =   0x00000400
#endif /* FILE_ATTRIBUTE_REPARSE_POINT */
    };

#if defined(_WIN32_WINNT) && \
    _WIN32_WINNT >= 0x0400
    if( (sequence_type::directories == (flags & (sequence_type::directories | sequence_type::files))) &&
        system_version::winnt() &&
        system_version::major() >= 4)
    {
        hSrch = traits_type::find_first_file_ex(searchSpec, FindExSearchLimitToDirectories, findData);
    }
    else
#endif /* _WIN32_WINNT >= 0x0400 */

    if(INVALID_HANDLE_VALUE == hSrch)
    {
        hSrch = traits_type::find_first_file(searchSpec, findData);
    }

#ifdef _DEBUG
    if(INVALID_HANDLE_VALUE == hSrch)
    {
        ::GetLastError();
    }
#endif /* _DEBUG */

    // Now need to validate against the flags
    for(; INVALID_HANDLE_VALUE != hSrch; )
    {
        if( traits_type::is_file(findData) &&
            (   0 == (flags & sequence_type::skipHiddenFiles) ||
                0 == (findData->dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)))
        {
            // A file, and files requested, so break
            if(flags & sequence_type::files)
            {
                break;
            }
        }
        else
        {
            if( 0 == (flags & sequence_type::skipHiddenDirs) ||
                0 == (findData->dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
            {
                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
                    if( 0 == (flags & sequence_type::skipReparseDirs) ||
                        0 == (findData->dwFileAttributes & reparsePointConstant))
                    {
                        // Either not requested to skip reparse points, or not a reparse point
                        break;
                    }
                }
            }
        }

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

            hSrch = INVALID_HANDLE_VALUE;

            break;
        }
    }

    return hSrch;
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
inline basic_findfile_sequence_const_input_iterator<C, T, V>::basic_findfile_sequence_const_input_iterator()
    : m_list(NULL)
    , m_handle(NULL)
    , m_subpath()
    , m_subPathLen(0)
    , m_pattern0(NULL)
    , m_pattern1(NULL)
    , m_delim('\0')
    , m_flags(0)
{
    m_subpath[0] = '\0';
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
inline basic_findfile_sequence_const_input_iterator<C, T, V>::basic_findfile_sequence_const_input_iterator( sequence_type const                                                                         &l
#if 0
                                                                                                        ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, V>::char_type const   *rootDir
#endif /* 0 */
                                                                                                        ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, V>::char_type const   *patterns
                                                                                                        ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, V>::char_type         delim
                                                                                                        ,   flags_type                                                                                  flags)
    : m_list(&l)
    , m_handle(NULL)
    , m_subpath()
    , m_subPathLen(0)
    , m_pattern0(patterns)
    , m_pattern1(patterns)
    , m_delim(delim)
    , m_flags(flags)
{
    m_subpath[0] = '\0';

    operator ++();
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k V>
inline basic_findfile_sequence_const_input_iterator<C, T, V>::basic_findfile_sequence_const_input_iterator(sequence_type const& l)
    : m_list(&l)
    , m_handle(NULL)
    , m_subpath()
    , m_subPathLen(0)
    , m_pattern0(NULL)
    , m_pattern1(NULL)
    , m_delim('\0')
    , m_flags(0)
{
    m_subpath[0] = '\0';
}


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