environment_sequence.hpp

新版本TR1的stl

// Not to be implemented
private:
    basic_environment_sequence(class_type const&);
    class_type const& operator =(class_type const&);
};

/* /////////////////////////////////////////////////////////////////////////
 * Typedefs for commonly encountered types
 */

/** \brief Specialisation of the basic_environment_sequence template for the ANSI character type \c char
 *
 * \ingroup group__library__system
 */
typedef basic_environment_sequence<ws_char_a_t>     environment_sequence_a;
/** \brief Specialisation of the basic_environment_sequence template for the Unicode character type \c wchar_t
 *
 * \ingroup group__library__system
 */
typedef basic_environment_sequence<ws_char_w_t>     environment_sequence_w;
/** \brief Specialisation of the basic_environment_sequence template for the Win32 character type \c TCHAR
 *
 * \ingroup group__library__system
 */
typedef basic_environment_sequence<TCHAR>           environment_sequence;

////////////////////////////////////////////////////////////////////////////
// Implementation

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template <ss_typename_param_k C>
inline /* static */ ss_typename_type_k basic_environment_sequence<C>::size_type basic_environment_sequence<C>::calc_items_(ss_typename_type_k basic_environment_sequence<C>::char_type const* p, ss_typename_type_k basic_environment_sequence<C>::char_type const** q, ws_int_t flags)
{
    size_type           c;
    char_type const*    v;

    for(c = 0, v = p;; ++p)
    {
        if(*p == 0) // End of an environment variable?
        {
            if( showHidden == (showHidden & flags) ||
                '=' != v[0])
            {
                ++c;
            }

            v = p + 1;

            if(*(p + 1) == 0) // End of all environment variable
            {
                *q = p + 1;
                break;
            }
        }
    }

    return c;
}


template <ss_typename_param_k C>
inline /* static */ void basic_environment_sequence<C>::prepare_items_(ss_typename_type_k basic_environment_sequence<C>::symbols_buffer_type &symbols, ss_typename_type_k basic_environment_sequence<C>::environment_buffer_type &environment, ss_typename_type_k basic_environment_sequence<C>::char_type *p, ss_typename_type_k basic_environment_sequence<C>::char_type* q, ws_int_t flags)
{
    ss_typename_type_k environment_buffer_type::iterator    env_begin   =   environment.begin();
    ss_typename_type_k symbols_buffer_type::iterator        sym_begin   =   symbols.begin();
    char_type*                                              begin       =   p;
    char_type *const                                        end         =   q;
    char_type*                                              last_src    =   begin;
    char_type*                                              last_dest   =   &*env_begin; // Need this because may be using VC7.0 style pointer iterators

    // This loop does two things in one go (for efficiency).
    //
    // Firstly, it copies the source (which is read-only) to the m_environment
    // buffer.
    //
    // Secondly, it processes the source, and adjusts the m_symbols and
    // m_environment contents accordingly.
    for(; begin != end;)
    {
        *env_begin = *begin;

        if(*begin == 0)
        {
            const ws_bool_t bHidden =   ('=' == last_dest[0]);

            sym_begin->name  =   last_dest;
            for(; last_src != begin; ++last_src, ++last_dest)
            {
                if( *last_src == '=' &&
                    (   !bHidden ||
                        sym_begin->name != last_dest))
                {
                    *last_dest = '\0';
//                      ++last_src;
                    ++last_dest;
                    break;
                }
            }
            sym_begin->value    =   last_dest;
            last_src            =   ++begin;
            last_dest           =   &*++env_begin;

            if( showHidden == (showHidden & flags) ||
                !bHidden)
            {
                ++sym_begin;
            }
        }
        else
        {
            ++begin;
            ++env_begin;
        }
    }

    if(0 == (noSort & flags))
    {
        winstl_ns_qual_std(sort)(symbols.begin(), symbols.end(), compare_symbol());
    }
}

template <ss_typename_param_k C>
inline /* static */ ws_int_t basic_environment_sequence<C>::validate_flags_(ws_int_t flags)
{
    const ws_int_t  validFlags  =   0
                                |   showHidden
                                |   noSort
                                |   ignoreCase
                                |   0;

    WINSTL_MESSAGE_ASSERT("Specification of unrecognised/unsupported flags", flags == (flags & validFlags));
    STLSOFT_SUPPRESS_UNUSED(validFlags);

    return flags;
}

STLSOFT_TEMPLATE_SPECIALISATION
inline /* static */ basic_environment_sequence<ws_char_a_t>::char_type const* basic_environment_sequence<ws_char_a_t>::get_environment_strings_()
{
    return static_cast<ws_char_a_t const*>(::GetEnvironmentStringsA());
}

STLSOFT_TEMPLATE_SPECIALISATION
inline /* static */ basic_environment_sequence<ws_char_w_t>::char_type const* basic_environment_sequence<ws_char_w_t>::get_environment_strings_()
{
    return static_cast<ws_char_w_t const*>(::GetEnvironmentStringsW());
}

STLSOFT_TEMPLATE_SPECIALISATION
inline /* static */ void basic_environment_sequence<ws_char_a_t>::free_environment_strings_(basic_environment_sequence<ws_char_a_t>::char_type *s)
{
    ::FreeEnvironmentStringsA(s);
}

STLSOFT_TEMPLATE_SPECIALISATION
inline /* static */ void basic_environment_sequence<ws_char_w_t>::free_environment_strings_(basic_environment_sequence<ws_char_w_t>::char_type *s)
{
    ::FreeEnvironmentStringsW(s);
}

STLSOFT_TEMPLATE_SPECIALISATION
inline /* static */ ws_int_t basic_environment_sequence<ws_char_a_t>::compare_strings_(ws_char_a_t const* s1, ws_char_a_t const* s2, ws_int_t flags)
{
    return (ignoreCase & flags) ? ::lstrcmpiA(s1, s2) : ::lstrcmpA(s1, s2);
}

STLSOFT_TEMPLATE_SPECIALISATION
inline /* static */ ws_int_t basic_environment_sequence<ws_char_w_t>::compare_strings_(ws_char_w_t const* s1, ws_char_w_t const* s2, ws_int_t flags)
{
    return (ignoreCase & flags) ? ::lstrcmpiW(s1, s2) : ::lstrcmpW(s1, s2);
}

template <ss_typename_param_k C>
inline /* ss_explicit_k */ basic_environment_sequence<C>::basic_environment_sequence(ws_int_t flags)
    : m_flags(validate_flags_(flags))
    , m_p(get_environment_strings_())
    , m_symbols(calc_items_(m_p, &m_q, m_flags))
    , m_environment(static_cast<ss_size_t>(m_q - m_p))
{
    prepare_items_(m_symbols, m_environment, const_cast<char_type*>(m_p), const_cast<char_type*>(m_q), flags);
}

template <ss_typename_param_k C>
inline basic_environment_sequence<C>::~basic_environment_sequence() stlsoft_throw_0()
{
    // The documentation for FreeEnvironmentStrings does not explicitly state
    // that it is legal to free a null string, so we must do the test.
    if(0 != m_p)
    {
        free_environment_strings_(const_cast<char_type*>(m_p));
    }
}

template <ss_typename_param_k C>
inline ss_typename_type_k basic_environment_sequence<C>::const_iterator basic_environment_sequence<C>::begin() const
{
    return &*m_symbols.begin();
}

template <ss_typename_param_k C>
inline ss_typename_type_k basic_environment_sequence<C>::const_iterator basic_environment_sequence<C>::end() const
{
    return &*m_symbols.end();
}

#if defined(STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT)
template <ss_typename_param_k C>
inline ss_typename_type_k basic_environment_sequence<C>::const_reverse_iterator basic_environment_sequence<C>::rbegin() const
{
    return const_reverse_iterator(end());
}

template <ss_typename_param_k C>
inline ss_typename_type_k basic_environment_sequence<C>::const_reverse_iterator basic_environment_sequence<C>::rend() const
{
    return const_reverse_iterator(begin());
}
#endif /* STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT */

template <ss_typename_param_k C>
inline ss_typename_type_k basic_environment_sequence<C>::const_iterator basic_environment_sequence<C>::find(ss_typename_type_k basic_environment_sequence<C>::char_type const* name) const
{
    const_iterator  b   =   this->begin();
    const_iterator  e   =   this->end();

    for(; b != e; ++b)
    {
        if(0 == compare_strings_(name, (*b).name, m_flags))
        {
            break;
        }
    }

    return b;
}

template <ss_typename_param_k C>
inline ss_typename_type_k basic_environment_sequence<C>::const_iterator basic_environment_sequence<C>::find(ss_typename_type_k basic_environment_sequence<C>::char_type const* name, ss_typename_type_k basic_environment_sequence<C>::char_type const* value) const
{
    const_iterator  b   =   this->begin();
    const_iterator  e   =   this->end();

    for(; b != e; ++b)
    {
        if( 0 == compare_strings_(name, (*b).name, m_flags) &&
            (   NULL == value ||
                0 == compare_strings_(value, (*b).value, m_flags)))
        {
            break;
        }
    }

    return b;
}


template <ss_typename_param_k C>
inline ss_typename_type_k basic_environment_sequence<C>::size_type basic_environment_sequence<C>::size() const
{
    return m_symbols.size();
}

template <ss_typename_param_k C>
inline ws_bool_t basic_environment_sequence<C>::empty() const
{
    return size() == 0;
}

template <ss_typename_param_k C>
inline ss_typename_type_k basic_environment_sequence<C>::value_type basic_environment_sequence<C>::operator [](ss_typename_type_k basic_environment_sequence<C>::size_type index) const
{
    WINSTL_MESSAGE_ASSERT("index access out of range in basic_environment_sequence", index < size() + 1);   // Has to be +1, since legitimate to take address of one-past-the-end

    return m_symbols.data()[index];
}

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

////////////////////////////////////////////////////////////////////////////
// Unit-testing

#ifdef STLSOFT_UNITTEST
# include "./unittest/environment_sequence_unittest_.h"
#endif /* STLSOFT_UNITTEST */

/* ////////////////////////////////////////////////////////////////////// */

#ifndef _WINSTL_NO_NAMESPACE
# if defined(_STLSOFT_NO_NAMESPACE) || \
     defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
} // namespace winstl
# else
} // namespace winstl_project
} // namespace stlsoft
# endif /* _STLSOFT_NO_NAMESPACE */
#endif /* !_WINSTL_NO_NAMESPACE */

/* ////////////////////////////////////////////////////////////////////// */

#endif /* WINSTL_INCL_WINSTL_SYSTEM_HPP_ENVIRONMENT_SEQUENCE */

/* ////////////////////////////////////////////////////////////////////// */