findfile_sequence.hpp

新版本TR1的stl

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

// c_str_data

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T>
inline ws_char_a_t const* c_str_data_a(winstl_ns_qual(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_w(winstl_ns_qual(basic_findfile_sequence_value_type)<ws_char_w_t, T> const& v)
{
    return v.get_path();
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/** \brief \ref group__concept__shim__string_access__c_str_data for winstl::basic_findfile_sequence_value_type
 *
 * \ingroup group__concept__shim__string_access
 */
template <ss_typename_param_k C, ss_typename_param_k T>
inline C const* c_str_data(winstl_ns_qual(basic_findfile_sequence_value_type)<C, T> const& v)
{
    return v.get_path();
}

// c_str_len

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T>
inline ws_size_t c_str_len_a(winstl_ns_qual(basic_findfile_sequence_value_type)<ws_char_a_t, T> const& v)
{
    return v.length();
}
template <ss_typename_param_k T>
inline ws_size_t c_str_len_w(winstl_ns_qual(basic_findfile_sequence_value_type)<ws_char_w_t, T> const& v)
{
    return v.length();
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/** \brief \ref group__concept__shim__string_access__c_str_len for winstl::basic_findfile_sequence_value_type
 *
 * \ingroup group__concept__shim__string_access
 */
template <ss_typename_param_k C, ss_typename_param_k T>
inline ws_size_t c_str_len(winstl_ns_qual(basic_findfile_sequence_value_type)<C, T> const& v)
{
    return v.length();
}

// c_str_ptr

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T>
inline ws_char_a_t const* c_str_ptr_a(winstl_ns_qual(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_w(winstl_ns_qual(basic_findfile_sequence_value_type)<ws_char_w_t, T> const& v)
{
    return v.get_path();
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/** \brief \ref group__concept__shim__string_access__c_str_ptr for winstl::basic_findfile_sequence_value_type
 *
 * \ingroup group__concept__shim__string_access
 */
template <ss_typename_param_k C, ss_typename_param_k T>
inline C const* c_str_ptr(winstl_ns_qual(basic_findfile_sequence_value_type)<C, T> const& v)
{
    return v.get_path();
}

// c_str_ptr_null

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T>
inline ws_char_a_t const* c_str_ptr_null_a(winstl_ns_qual(basic_findfile_sequence_value_type)<ws_char_a_t, T> const& v)
{
    return stlsoft_ns_qual(c_str_ptr_null_a(v.get_path()));
}
template <ss_typename_param_k T>
inline ws_char_w_t const* c_str_ptr_null_w(winstl_ns_qual(basic_findfile_sequence_value_type)<ws_char_w_t, T> const& v)
{
    return stlsoft_ns_qual(c_str_ptr_null_w(v.get_path()));
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/** \brief \ref group__concept__shim__string_access__c_str_ptr_null for winstl::basic_findfile_sequence_value_type
 *
 * \ingroup group__concept__shim__string_access
 */
template <ss_typename_param_k C, ss_typename_param_k T>
inline C const* c_str_ptr_null(winstl_ns_qual(basic_findfile_sequence_value_type)<C, T> const& v)
{
    return stlsoft_ns_qual(c_str_ptr_null(v.get_path()));
}

/* /////////////////////////////////////////////////////////////////////////
 * Deprecated Shims
 */

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

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();
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

////////////////////////////////////////////////////////////////////////////
// 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
                                    |   relativePath
                                    |   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 */ ws_bool_t basic_findfile_sequence<C, T>::is_valid() const
{
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
    if('\0' == m_directory[0])
    {
# ifdef STLSOFT_UNITTEST
        fprintf(err, "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(err, "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, flags_type flags)
{
    if( NULL == directory ||
        '\0' == *directory)
    {
        static const char_type  s_cwd[] = { '.', '\0' };

        directory = &s_cwd[0];
    }

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

        return;
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
    }

    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, m_flags);

    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, m_flags);

    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, m_flags);

    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, m_flags);

    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);