findfile_sequence.hpp

新版本TR1的stl

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

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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



#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T, ss_typename_param_k X>
inline is_size_t c_str_len_a(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_a_t, T, X> const& v)
{
    return stlsoft_ns_qual(c_str_len_a(v.get_path()));
}
template <ss_typename_param_k T, ss_typename_param_k X>
inline is_size_t c_str_len_w(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_w_t, T, X> const& v)
{
    return stlsoft_ns_qual(c_str_len_w(v.get_path()));
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/** \brief \ref group__concept__shim__string_access__c_str_len for inetstl::basic_findfile_sequence_value_type
 *
 * \ingroup group__concept__shim__string_access
 */
template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
inline is_size_t c_str_len(inetstl_ns_qual(basic_findfile_sequence_value_type)<C, T, X> const& v)
{
    return stlsoft_ns_qual(c_str_len(v.get_path()));
}



#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T, ss_typename_param_k X>
inline is_char_a_t const* c_str_ptr_a(inetstl_ns_qual(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(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_w_t, T, X> const& v)
{
    return v.get_path();
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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



#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k T, ss_typename_param_k X>
inline is_char_a_t const* c_str_ptr_null_a(inetstl_ns_qual(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(inetstl_ns_qual(basic_findfile_sequence_value_type)<is_char_w_t, T, X> const& v)
{
    return stlsoft_ns_qual(c_str_ptr_null(v.get_path()));
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

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



////////////////////////////////////////////////////////////////////////////
// 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, ss_typename_param_k T, ss_typename_param_k X>
inline ss_typename_type_k basic_findfile_sequence<C, T, X>::const_iterator basic_findfile_sequence<C, T, X>::begin() const
{
    INETSTL_ASSERT(is_valid());

    return const_input_iterator(*this, stlsoft_ns_qual(c_str_ptr)(m_rootDir), stlsoft_ns_qual(c_str_ptr)(m_patterns), m_delim, m_flags);
}

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

    return const_input_iterator(*this);
}

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

    return m_rootDir.c_str();
}

// State
#ifdef STLSOFT_OBSOLETE
template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
inline ss_typename_type_k basic_findfile_sequence<C, T, X>::size_type basic_findfile_sequence<C, T, X>::size() const
{
    INETSTL_ASSERT(is_valid());

    return stlsoft_ns_qual_std(distance)(begin(), end());
}
#endif /* STLSOFT_OBSOLETE */

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
inline is_bool_t basic_findfile_sequence<C, T, X>::empty() const
{
    INETSTL_ASSERT(is_valid());

    return begin() == end();
}

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>::size_type basic_findfile_sequence<C, T, X>::max_size()
{
    return static_cast<size_type>(-1);
}

// basic_findfile_sequence_value_type

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

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

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

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

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
inline ss_typename_type_k basic_findfile_sequence_value_type<C, T, X>::char_type const* basic_findfile_sequence_value_type<C, T, X>::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, ss_typename_param_k X>
inline ss_typename_type_k basic_findfile_sequence_value_type<C, T, X>::char_type const* basic_findfile_sequence_value_type<C, T, X>::get_path() const
{
    return &m_path[0];
}

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

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

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::is_directory() const
{
    return traits_type::is_directory(&m_data);
}
template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::is_file() const
{
    return traits_type::is_file(&m_data);
}
template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::is_read_only() const
{
    return 0 != (m_data.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::equal(char_type const* rhs) const
{
    INETSTL_ASSERT(NULL != rhs);

    return 0 == traits_type::str_compare(this->get_path(), rhs);
}

template <ss_typename_param_k C, ss_typename_param_k T, ss_typename_param_k X>
inline is_bool_t basic_findfile_sequence_value_type<C, T, X>::equal(basic_findfile_sequence_value_type<C, T, X> 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 X, ss_typename_param_k V>
inline /* static */ int basic_findfile_sequence_const_input_iterator<C, T, X, V>::find_next_pattern_(  ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const*& p0
                                                                                                ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type const*& p1
                                                                                                ,   ss_typename_type_k basic_findfile_sequence_const_input_iterator<C, T, X, V>::char_type delim)