path.hpp

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

    return *this;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline ss_typename_param_k basic_path<C, T, A>::class_type &basic_path<C, T, A>::concat_(basic_path<C, T, A> const &rhs)
{
    m_len = traits_type::str_len(traits_type::str_cat(&m_buffer[0], rhs.c_str()));

    return *this;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A>::basic_path()
    : m_len(0)
{
    m_buffer[0] = '\0';
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline /* ss_explicit_k */ basic_path<C, T, A>::basic_path(ss_typename_type_k basic_path<C, T, A>::char_type const *path)
    : m_len(0)
{
    if(NULL != path)
    {
        size_type   cch =   traits_type::str_len(path);

        WINSTL_ASSERT(cch < m_buffer.size());

        traits_type::str_copy(&m_buffer[0], path);

        m_len = cch;
    }
    else
    {
        m_buffer[0] = '\0';
    }
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A>::basic_path(ss_typename_type_k basic_path<C, T, A>::char_type const *path, ss_typename_type_k basic_path<C, T, A>::size_type cch)
    : m_len(cch)
{
    WINSTL_ASSERT((NULL != path) || (0 == cch));

    if(0 != cch)
    {
        WINSTL_ASSERT(cch < m_buffer.size());

        traits_type::str_n_copy(&m_buffer[0], path, cch);
    }
    m_buffer[cch] = '\0';
}

#ifndef STLSOFT_CF_NO_COPY_CTOR_AND_COPY_CTOR_TEMPLATE_OVERLOAD
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A>::basic_path(basic_path<C, T, A> const &rhs)
    : m_len(rhs.m_len)
{
    traits_type::str_copy(&m_buffer[0], stlsoft_ns_qual(c_str_ptr)(rhs.m_buffer));
}
#endif /* !STLSOFT_CF_NO_COPY_CTOR_AND_COPY_CTOR_TEMPLATE_OVERLOAD */

#ifndef STLSOFT_CF_NO_COPY_CTOR_AND_COPY_CTOR_TEMPLATE_OVERLOAD
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::operator =(basic_path<C, T, A> const &path)
{
    class_type  newPath(path);

    swap(newPath);

    return *this;
}
#endif /* !STLSOFT_CF_NO_COPY_CTOR_AND_COPY_CTOR_TEMPLATE_OVERLOAD */

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::operator =(ss_typename_type_k basic_path<C, T, A>::char_type const *path)
{
    class_type  newPath(path);

    swap(newPath);

    return *this;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline /* static */ ss_typename_type_k basic_path<C, T, A>::class_type basic_path<C, T, A>::root(ss_typename_type_k basic_path<C, T, A>::char_type const *s)
{
    return class_type(s);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::push(class_type const &rhs, ws_bool_t bAddPathNameSeparator /* = false */)
{
    return push(rhs.c_str(), bAddPathNameSeparator);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::push(char_type const *rhs, ws_bool_t bAddPathNameSeparator /* = false */)
{
    WINSTL_ASSERT(NULL != rhs);

    if('\0' != *rhs)
    {
        if(traits_type::is_path_rooted(rhs))
        {
            class_type  newPath(rhs);

            swap(newPath);
        }
        else
        {
            // In an attempt to maintain slash/backslash consistency, we
            // locate the next slash to help guide the push_sep_() method.

            class_type      newPath(*this);
            char_type const *psep   =   next_slash_or_end(c_str());
            char_type       sep     =   ('\0' == *psep) ? char_type(0) : psep[-1];

            newPath.push_sep_(sep);
            newPath.concat_(rhs);
            if(bAddPathNameSeparator)
            {
                newPath.push_sep();
            }

            swap(newPath);
        }
    }

    return *this;
}

#if 0
template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::push_ext(class_type const &rhs, ws_bool_t bAddPathNameSeparator /* = false */)
{
}
#endif /* 0 */

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::push_ext(char_type const *rhs, ws_bool_t bAddPathNameSeparator /* = false */)
{
    WINSTL_ASSERT(NULL != rhs);

    class_type  newPath(*this);

    newPath.pop_sep();
    if('.' != *rhs)
    {
        newPath.concat_(".");
    }
    newPath.concat_(rhs);
    if(bAddPathNameSeparator)
    {
        newPath.push_sep();
    }

    swap(newPath);

    return *this;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::push_sep()
{
    return push_sep_(traits_type::path_name_separator());
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::push_sep_(ss_typename_type_k basic_path<C, T, A>::char_type sep)
{
    if(0 == sep)
    {
        sep = traits_type::path_name_separator();
    }

    WINSTL_ASSERT(sep == traits_type::path_name_separator() || sep == path_name_separator_alt());

    if(0 != m_len)
    {
        if(traits_type::path_name_separator() != m_buffer[m_len - 1])
        {
            if(path_name_separator_alt() != m_buffer[m_len - 1])
            {
                WINSTL_ASSERT(m_len + 1 < m_buffer.size());

                m_buffer[m_len]     =   sep;
                m_buffer[m_len + 1] =   '\0';
                ++m_len;
            }
        }
    }

    return *this;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::pop(ws_bool_t bRemoveTrailingPathNameSeparator /* = true */)
{
    char_type   *slash      =   traits_type::str_rchr(c_str_ptr(m_buffer), traits_type::path_name_separator());
    char_type   *slash_a    =   traits_type::str_rchr(c_str_ptr(m_buffer), path_name_separator_alt());

    if(slash_a > slash)
    {
        slash = slash_a;
    }

    if(NULL != slash)
    {
        *(slash + 1) = '\0';
        m_len = static_cast<size_type>((slash + 1) - stlsoft_ns_qual(c_str_ptr)(m_buffer));
    }
    else
    {
        clear();
    }

    if(bRemoveTrailingPathNameSeparator)
    {
        this->pop_sep();
    }

    return *this;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::pop_sep()
{
    if(0 != m_len)
    {
        if( 1 == m_len &&
            traits_type::is_path_name_separator(m_buffer[0]))
        {
            // It's / or \ - ignore
        }
        else if(3 == m_len &&
                ':' == m_buffer[1] &&
                traits_type::is_path_name_separator(m_buffer[2]))
        {
            // It's drive rooted - ignore
        }
        else
        {
            // We can pop a separator off anything else, including a UNC host
            char_type *last = &m_buffer[m_len - 1];

            if(*last == traits_type::path_name_separator())
            {
                m_buffer[m_len-- - 1] = '\0';
            }
            else if(*last == path_name_separator_alt())
            {
                m_buffer[m_len-- - 1] = '\0';
            }
        }
    }

    return *this;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::pop_ext()
{
    { for(size_t len = m_len; 0 != len; --len)
    {
        char_type   *last = &m_buffer[len - 1];

        if(traits_type::is_path_name_separator(*last))
        {
            break;
        }
        else if('.' == *last)
        {
            m_len = len - 1;

            m_buffer[m_len] = '\0';

            break;
        }
    }}

    return *this;
}


#if !defined(STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT) || \
    defined(STLSOFT_CF_MEMBER_TEMPLATE_OVERLOAD_DISCRIMINATED)

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::operator /=(basic_path<C, T, A> const &path)
{
    return push(path);
}

#endif /* !STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT || STLSOFT_CF_MEMBER_TEMPLATE_OVERLOAD_DISCRIMINATED */

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::operator /=(ss_typename_type_k basic_path<C, T, A>::char_type const *path)
{
    return push(path);
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline void basic_path<C, T, A>::clear()
{
    m_buffer[0] =   '\0';
    m_len       =   0;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::make_absolute(ws_bool_t bRemoveTrailingPathNameSeparator /* = true */)
{
    buffer_type buffer;
    size_type   cch = traits_type::get_full_path_name(c_str(), buffer.size(), &buffer[0]);
    class_type  newPath(stlsoft_ns_qual(c_str_ptr)(buffer), cch);

    if(bRemoveTrailingPathNameSeparator)
    {
        newPath.pop_sep();
    }

    swap(newPath);

    return *this;
}

template<   ss_typename_param_k C
        ,   ss_typename_param_k T
        ,   ss_typename_param_k A
        >
inline basic_path<C, T, A> &basic_path<C, T, A>::canonicalise(ws_bool_t bRemoveTrailingPathNameSeparator /* = true */)
{
    class_type  newPath(*this);

#ifdef _DEBUG
    memset(&newPath.m_buffer[0], '~', newPath.m_buffer.size());
#endif /* _DEBUG */

    // Basically we scan through the path looking for ./ .\ ..\ and ../

#ifdef STLSOFT_LF_ALLOCATOR_REBIND_SUPPORT
    typedef ss_typename_type_k A::ss_template_qual_k rebind<part>::other    part_ator_type;
#else /* ? STLSOFT_LF_ALLOCATOR_REBIND_SUPPORT */
    typedef ss_typename_type_k allocator_selector<part>::allocator_type     part_ator_type;
#endif /* STLSOFT_LF_ALLOCATOR_REBIND_SUPPORT */

    typedef stlsoft_ns_qual(auto_buffer_old)<   part