?? path.hpp
字號:
if(NULL != path)
{
size_type cch = traits_type::str_len(path);
UNIXSTL_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)
{
UNIXSTL_ASSERT((NULL != path) || (0 == cch));
if(0 != cch)
{
UNIXSTL_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, us_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, us_bool_t bAddPathNameSeparator /* = false */)
{
UNIXSTL_ASSERT(NULL != rhs);
if('\0' != *rhs)
{
if(traits_type::is_path_rooted(rhs))
{
class_type newPath(rhs);
swap(newPath);
}
else
{
class_type newPath(*this);
newPath.push_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, us_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, us_bool_t bAddPathNameSeparator /* = false */)
{
UNIXSTL_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()
{
if(0 != m_len)
{
if(traits_type::path_name_separator() != m_buffer[m_len - 1])
{
#ifdef _WIN32
if(path_name_separator_alt() != m_buffer[m_len - 1])
#endif /* _WIN32 */
{
UNIXSTL_ASSERT(m_len + 1 < m_buffer.size());
m_buffer[m_len] = traits_type::path_name_separator();
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(us_bool_t bRemoveTrailingPathNameSeparator /* = true */)
{
char_type *slash = traits_type::str_rchr(stlsoft_ns_qual(c_str_ptr)(m_buffer), traits_type::path_name_separator());
#ifdef _WIN32
char_type *slash_a = traits_type::str_rchr(stlsoft_ns_qual(c_str_ptr)(m_buffer), path_name_separator_alt());
if(slash_a > slash)
{
slash = slash_a;
}
#endif /* _WIN32 */
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
}
#ifdef _WIN32
else if(3 == m_len &&
':' == m_buffer[1] &&
traits_type::is_path_name_separator(m_buffer[2]))
{
// It's drive rooted - ignore
}
#endif /* _WIN32 */
else
{
char_type *last = &m_buffer[m_len - 1];
if(*last == traits_type::path_name_separator())
{
m_buffer[m_len-- - 1] = '\0';
}
#ifdef _WIN32
else if(*last == path_name_separator_alt())
{
m_buffer[m_len-- - 1] = '\0';
}
#endif /* _WIN32 */
}
}
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(us_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(us_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
, part_ator_type
> part_buffer_t;
part_buffer_t parts(this->length() / 2); // Uncanonicalised directory parts
char_type *dest = &newPath.m_buffer[0];
char_type const *p1 = this->c_str();
char_type const *p2;
if(this->is_absolute())
{
#ifdef _WIN32
if(traits_type::is_path_UNC(this->c_str()))
{
UNIXSTL_ASSERT('\\' == m_buffer[0]);
UNIXSTL_ASSERT('\\' == m_buffer[1]);
UNIXSTL_ASSERT('\\' != m_buffer[2]);
char_type const *slash0 = next_slash_or_end(&m_buffer[3]);
char_type const *slash1 = next_slash_or_end(slash0);
for(us_size_t i = 0, n = slash1 - &m_buffer[0]; i < n; ++i)
{
*dest++ = *p1++;
}
}
else if( isalpha(m_buffer[0]) &&
':' == m_buffer[1])
{
// Copy over the drive letter, colon and slash
*dest++ = *p1++;
*dest++ = *p1++;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -