/* /////////////////////////////////////////////////////////////////////////
 * File:        winstl/system/system_traits.hpp
 *
 * Purpose:     Contains the system_traits template class, and ANSI and
 *              Unicode specialisations thereof.
 *
 * Created:     15th November 2002
 * Updated:     10th September 2011
 *
 * Thanks to:   Austin Ziegler for spotting the defective pre-condition
 *              enforcement of expand_environment_strings().
 *
 * Home:        http://stlsoft.org/
 *
 * Copyright (c) 2002-2011, Matthew Wilson and Synesis Software
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - Neither the name(s) of Matthew Wilson and Synesis Software nor the
 *   names of any contributors may be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * ////////////////////////////////////////////////////////////////////// */


/** \file winstl/system/system_traits.hpp
 *
 * \brief [C++ only] Definition of the winstl::system_traits traits
 *  class
 *   (\ref group__library__system "System" Library).
 */

#ifndef WINSTL_INCL_WINSTL_SYSTEM_HPP_SYSTEM_TRAITS
#define WINSTL_INCL_WINSTL_SYSTEM_HPP_SYSTEM_TRAITS

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
# define WINSTL_VER_WINSTL_SYSTEM_HPP_SYSTEM_TRAITS_MAJOR       5
# define WINSTL_VER_WINSTL_SYSTEM_HPP_SYSTEM_TRAITS_MINOR       6
# define WINSTL_VER_WINSTL_SYSTEM_HPP_SYSTEM_TRAITS_REVISION    1
# define WINSTL_VER_WINSTL_SYSTEM_HPP_SYSTEM_TRAITS_EDIT        131
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////
 * Includes
 */

#ifndef WINSTL_INCL_WINSTL_H_WINSTL
# include <winstl/winstl.h>
#endif /* !WINSTL_INCL_WINSTL_H_WINSTL */
#ifndef STLSOFT_INCL_STLSOFT_INTERNAL_H_SAFESTR
# include <stlsoft/internal/safestr.h>
#endif /* !STLSOFT_INCL_STLSOFT_INTERNAL_H_SAFESTR */

#if defined(WINSTL_OS_IS_WIN64) || \
    defined(_Wp64)
# define _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
#endif /* _WIN64 || _M_IA64 */

#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
#  ifndef STLSOFT_INCL_STLSOFT_CONVERSION_HPP_TRUNCATION_CAST
#   include <stlsoft/conversion/truncation_cast.hpp>
#  endif /* !STLSOFT_INCL_STLSOFT_CONVERSION_HPP_TRUNCATION_CAST */
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
#  ifndef STLSOFT_INCL_STLSOFT_CONVERSION_HPP_TRUNCATION_TEST
#   include <stlsoft/conversion/truncation_test.hpp>
#  endif /* !STLSOFT_INCL_STLSOFT_CONVERSION_HPP_TRUNCATION_TEST */
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */

#ifndef STLSOFT_INCL_H_STRING
# define STLSOFT_INCL_H_STRING
# include <string.h>
#endif /* !STLSOFT_INCL_H_STRING */
#ifndef STLSOFT_INCL_H_WCHAR
# define STLSOFT_INCL_H_WCHAR
# include <wchar.h>
#endif /* !STLSOFT_INCL_H_WCHAR */

/* /////////////////////////////////////////////////////////////////////////
 * Namespace
 */

#ifndef _WINSTL_NO_NAMESPACE
# if defined(_STLSOFT_NO_NAMESPACE) || \
     defined(STLSOFT_DOCUMENTATION_SKIP_SECTION)
/* There is no stlsoft namespace, so must define ::winstl */
namespace winstl
{
# else
/* Define stlsoft::winstl_project */

namespace stlsoft
{

namespace winstl_project
{

# endif /* _STLSOFT_NO_NAMESPACE */
#endif /* !_WINSTL_NO_NAMESPACE */

/* /////////////////////////////////////////////////////////////////////////
 * Classes
 */

#ifdef STLSOFT_DOCUMENTATION_SKIP_SECTION
/** Traits for accessing the correct system functions for a given
 *   character type.
 *
 * \ingroup group__library__system
 *
 * system_traits is a traits class for determining the correct system
 * structures and functions for a given character type.
 *
 * \param C The character type (e.g. \c char, \c wchar_t)
 */
template <ss_typename_param_k C>
struct system_traits
{
/// \name Types
/// @{
public:
    /// The character type
    typedef C                                       char_type;
    /// The size type
    typedef ws_size_t                               size_type;
    /// The difference type
    typedef ws_ptrdiff_t                            difference_type;
    /// The current instantion of the type
    typedef system_traits<C>                        class_type;
    /// The (signed) integer type
    typedef ws_int_t                                int_type;
    /// The Boolean type
    typedef ws_bool_t                               bool_type;
    /// The type of a handle to a dynamically loaded module
    typedef HMODULE                                 module_type;
    /// The type of a handle to a kernel object
    typedef HANDLE                                  handle_type;
    /// The type of system result codes
    typedef DWORD                                   result_code_type;
    /// The type of system error codes
    typedef DWORD                                   error_type;
/// @}

/// \name General string handling
/// @{
public:
    /// Copies a specific number of characters from the source to the destination
    static char_type*   char_copy(char_type* dest, char_type const* src, size_type n);
#if !defined(STLSOFT_USING_SAFE_STR_FUNCTIONS) || \
    defined(_CRT_SECURE_NO_DEPRECATE)
    /// Copies the contents of \c src to \c dest
    static char_type*   str_copy(char_type* dest, char_type const* src);
    /// Copies the contents of \c src to \c dest, up to cch \c characters
    static char_type*   str_n_copy(char_type* dest, char_type const* src, size_type cch);
    /// Appends the contents of \c src to \c dest
    static char_type*   str_cat(char_type* dest, char_type const* src);
    /// Appends the contents of \c src to \c dest, up to cch \c characters
    static char_type*   str_n_cat(char_type* dest, char_type const* src, size_type cch);
#endif /* !STLSOFT_USING_SAFE_STR_FUNCTIONS || _CRT_SECURE_NO_DEPRECATE */
    /// Compares the contents of \c src and \c dest
    static int_type     str_compare(char_type const* s1, char_type const* s2);
    /// Compares the contents of \c src and \c dest in a case-insensitive fashion
    static int_type     str_compare_no_case(char_type const* s1, char_type const* s2);
    /// Compares the contents of \c src and \c dest up to \c cch characters
    static int_type     str_n_compare(char_type const* s1, char_type const* s2, size_type cch);
    /// Compares the contents of \c src and \c dest up to \c cch characters
    static int_type     str_n_compare_no_case(char_type const* s1, char_type const* s2, size_type cch);
    /// Evaluates the length of \c src
    static size_type    str_len(char_type const* src);
    /// Finds the given character \c ch in \c s
    static char_type*   str_chr(char_type const* s, char_type ch);
    /// Finds the rightmost instance \c ch in \c s
    static char_type*   str_rchr(char_type const* s, char_type ch);
    /// Finds the given substring \c sub in \c s
    static char_type*   str_str(char_type const* s, char_type const* sub);
    /// Finds one of a set of characters in \c s
    static char_type*   str_pbrk(char_type const* s, char_type const* charSet);
    /// Returns a pointer to the end of the string
    static char_type*   str_end(char_type const* s);
    /// Sets each character in \c s to the character \c c
    ///
    /// \return s + n
    static char_type*   str_set(char_type* s, size_type n, char_type c);
/// @}

/// \name Locale management
/// @{
public:
    /// Returns the locale information
#ifndef NONLS
    static int_type     get_locale_info(LCID locale, LCTYPE type, char_type* data, int_type cchData);
#endif /* !NONLS */
/// @}

/// \name Module Paths
/// @{
public:
    /// Gets the full path name of the given module
    static size_type    get_module_filename(HMODULE hModule, char_type* buffer, size_type cchBuffer);
    /// Gets the full path name of the directory of the given module
    static size_type    get_module_directory(HMODULE hModule, char_type* buffer, size_type cchBuffer);
    /// Gets the full path name of the system directory
    static size_type    get_system_directory(char_type* buffer, size_type cchBuffer);
    /// Gets the full path name of the windows directory
    static size_type    get_windows_directory(char_type* buffer, size_type cchBuffer);
/// @}

/// \name Dynamic Loading
/// @{
public:
    /// Loads the given executable module
    static module_type  load_library(char_type const* name);
    /// Closes the given executable module
    static bool_type    free_library(module_type hModule);
    /// Retrieves the given symbol from the library
    static FARPROC      find_symbol(module_type hModule, char const* symbolName);
/// @}

/// \name Kernel object control
/// @{
public:
    /// Closes the given operating system handle
    static bool_type    close_handle(handle_type h);
/// @}

/// \name Error
/// @{
public:
    /// Gives the last error
    static error_type   get_last_error();
    /// Sets the last error
    static void         set_last_error(error_type er);
/// @}

/// \name Environment
/// @{
public:
    /// Gets an environment variable into the given buffer
    ///
    /// \param name The name of the variable to find
    /// \param buffer The buffer in which to write the variable. If this is NULL, then the required length is returned
    /// \param cchBuffer The size of the buffer, in characters
    ///
    /// \pre NULL != name
    static size_type    get_environment_variable(char_type const* name, char_type* buffer, size_type cchBuffer);
    /// Expands environment strings in \c src into \c buffer, up to a maximum \c cchDest characters
    static size_type    expand_environment_strings(char_type const* src, char_type* buffer, size_type cchBuffer);
/// @}
};

#else /* ? STLSOFT_DOCUMENTATION_SKIP_SECTION */

template <ss_typename_param_k C>
struct system_traits;

struct system_traits_
{
public:
    typedef ws_size_t                   size_type;
    typedef ws_ptrdiff_t                difference_type;
    typedef system_traits_              class_type;
    typedef ws_int_t                    int_type;
    typedef ws_bool_t                   bool_type;
    typedef HMODULE                     module_type;
    typedef HANDLE                      handle_type;
    typedef DWORD                       result_code_type;
    typedef DWORD                       error_type;

    class scoped_mem_block
    {
    public:
        ss_explicit_k scoped_mem_block(void* block)
            : m_block(block)
        {}
        ~scoped_mem_block() stlsoft_throw_0()
        {
            ::HeapFree(::GetProcessHeap(), 0, m_block);
        }
    private:
        scoped_mem_block(scoped_mem_block const&);
        scoped_mem_block& operator =(scoped_mem_block const&);

    public:
        static ws_char_a_t* allocate_string_buffer_a(size_type n)
        {
            return static_cast<ws_char_a_t*>(::HeapAlloc(::GetProcessHeap(), 0, sizeof(ws_char_a_t) * (1 + n)));
        }

        static ws_char_w_t* allocate_string_buffer_w(size_type n)
        {
            return static_cast<ws_char_w_t*>(::HeapAlloc(::GetProcessHeap(), 0, sizeof(ws_char_w_t) * (1 + n)));
        }

    public:
        void*   get() const
        {
            return m_block;
        }

    private:
        void*   m_block;
    };

public:
    static bool_type close_handle(handle_type h)
    {
        return FALSE != ::CloseHandle(h);
    }

public:
    static bool_type free_library(module_type hModule)
    {
        return FALSE != ::FreeLibrary(hModule);
    }

    static FARPROC find_symbol(module_type hModule, char const* symbolName)
    {
        return ::GetProcAddress(hModule, symbolName);
    }

public:
    static error_type get_last_error()
    {
        return ::GetLastError();
    }

    static void set_last_error(error_type er)
    {
        ::SetLastError(er);
    }
};

STLSOFT_TEMPLATE_SPECIALISATION
struct system_traits<ws_char_a_t>
{
public:
    typedef ws_char_a_t                 char_type;
    typedef ws_size_t                   size_type;
    typedef ws_ptrdiff_t                difference_type;
    typedef system_traits<char_type>    class_type;
    typedef ws_int_t                    int_type;
    typedef ws_bool_t                   bool_type;
    typedef HMODULE                     module_type;
    typedef HANDLE                      handle_type;
    typedef DWORD                       result_code_type;
    typedef DWORD                       error_type;

public:
    static char_type* char_copy(char_type* dest, char_type const* src, size_type n)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(0 == n || NULL != src);

        return static_cast<char_type*>(::memcpy(dest, src, sizeof(char_type) * n));
    }

#if !defined(STLSOFT_USING_SAFE_STR_FUNCTIONS) || \
    defined(_CRT_SECURE_NO_DEPRECATE)
    static char_type* str_copy(char_type* dest, char_type const* src)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(NULL != src);

# ifdef STLSOFT_MIN_CRT
        return ::lstrcpyA(dest, src);
# else /*? STLSOFT_MIN_CRT */
        return ::strcpy(dest, src);
# endif /* STLSOFT_MIN_CRT */
    }

    static char_type* str_n_copy(char_type* dest, char_type const* src, size_type cch)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(0 == cch || NULL != src);

        return ::strncpy(dest, src, cch);
    }

    static char_type* str_cat(char_type* dest, char_type const* src)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(NULL != src);

# ifdef STLSOFT_MIN_CRT
        return ::lstrcatA(dest, src);
# else /*? STLSOFT_MIN_CRT */
        return ::strcat(dest, src);
# endif /* STLSOFT_MIN_CRT */
    }

    static char_type* str_n_cat(char_type* dest, char_type const* src, size_type cch)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(NULL != src);

        return ::strncat(dest, src, cch);
    }
#endif /* !STLSOFT_USING_SAFE_STR_FUNCTIONS || _CRT_SECURE_NO_DEPRECATE */

    static int_type str_compare(char_type const* s1, char_type const* s2)
    {
        WINSTL_ASSERT(NULL != s1);
        WINSTL_ASSERT(NULL != s2);

#ifdef STLSOFT_MIN_CRT
        return ::lstrcmpA(s1, s2);
#else /*? STLSOFT_MIN_CRT */
        return ::strcmp(s1, s2);
#endif /* STLSOFT_MIN_CRT */
    }

    static int_type str_compare_no_case(char_type const* s1, char_type const* s2)
    {
        WINSTL_ASSERT(NULL != s1);
        WINSTL_ASSERT(NULL != s2);

        return ::lstrcmpiA(s1, s2);
    }

    static int_type str_n_compare(char_type const* s1, char_type const* s2, size_type cch)
    {
        WINSTL_ASSERT(NULL != s1);
        WINSTL_ASSERT(NULL != s2);

        return ::strncmp(s1, s2, cch);
    }

// TODO: move all these into internal, C-compatible, service files
//
// #include <stlsoft/system/apis/string/strnicmp.h

#ifdef WINSTL_SYSTEM_TRAITS_HAS_strnicmp_
# undef WINSTL_SYSTEM_TRAITS_HAS_strnicmp_
#endif /* WINSTL_SYSTEM_TRAITS_HAS_strnicmp_ */

#ifdef WINSTL_SYSTEM_TRAITS_HAS__strnicmp_
# undef WINSTL_SYSTEM_TRAITS_HAS__strnicmp_
#endif /* WINSTL_SYSTEM_TRAITS_HAS__strnicmp_ */

#if defined(STLSOFT_COMPILER_IS_BORLAND)
# if !defined(__STDC__)
#  define WINSTL_SYSTEM_TRAITS_HAS_strnicmp_
# endif
# if !defined(__MFC_COMPAT__)
#  define WINSTL_SYSTEM_TRAITS_HAS__strnicmp_
# endif
#elif defined(STLSOFT_COMPILER_IS_DMC)
# define WINSTL_SYSTEM_TRAITS_HAS__strnicmp_
#elif defined(STLSOFT_COMPILER_IS_GCC)
# if !defined(__STRICT_ANSI__)
#  define WINSTL_SYSTEM_TRAITS_HAS__strnicmp_
# endif
#elif defined(STLSOFT_COMPILER_IS_INTEL) || \
      defined(STLSOFT_COMPILER_IS_MSVC)
# if !defined(__STDC__) && \
     !defined(STLSOFT_USING_SAFE_STR_FUNCTIONS)
#  define WINSTL_SYSTEM_TRAITS_HAS_strnicmp_
# endif
# define WINSTL_SYSTEM_TRAITS_HAS__strnicmp_
#elif defined(STLSOFT_COMPILER_IS_MWERKS)
# define WINSTL_SYSTEM_TRAITS_HAS_strnicmp_
# define WINSTL_SYSTEM_TRAITS_HAS__strnicmp_
#elif defined(STLSOFT_COMPILER_IS_WATCOM)
# define WINSTL_SYSTEM_TRAITS_HAS__strnicmp_
#endif /* compiler */

#if defined(WINSTL_SYSTEM_TRAITS_HAS_strnicmp_) || \
    defined(WINSTL_SYSTEM_TRAITS_HAS__strnicmp_)
    static int_type str_n_compare_no_case(char_type const* s1, char_type const* s2, size_type cch)
    {
        WINSTL_ASSERT(NULL != s1);
        WINSTL_ASSERT(NULL != s2);

# if defined(WINSTL_SYSTEM_TRAITS_HAS_strnicmp_)
        return ::strnicmp(s1, s2, cch);
# elif defined(WINSTL_SYSTEM_TRAITS_HAS__strnicmp_)
        return ::_strnicmp(s1, s2, cch);
# else
#  error
# endif
    }
#else /* ? compiler */
    static int_type str_n_compare_no_case(char_type const* s1, char_type const* s2, size_type cch);
#endif /* compiler */

    static size_type str_len(char_type const* src)
    {
        WINSTL_ASSERT(NULL != src);

#ifdef STLSOFT_MIN_CRT
        return static_cast<size_type>(::lstrlenA(src));
#else /*? STLSOFT_MIN_CRT */
        return ::strlen(src);
#endif /* STLSOFT_MIN_CRT */
    }

    static char_type* str_chr(char_type const* s, char_type ch)
    {
        WINSTL_ASSERT(NULL != s);

        return const_cast<char_type*>(::strchr(s, ch));
    }

    static char_type* str_rchr(char_type const* s, char_type ch)
    {
        WINSTL_ASSERT(NULL != s);

        return const_cast<char_type*>(::strrchr(s, ch));
    }

    static char_type* str_str(char_type const* s, char_type const* sub)
    {
        WINSTL_ASSERT(NULL != s);
        WINSTL_ASSERT(NULL != sub);

        return const_cast<char_type*>(::strstr(s, sub));
    }

    static char_type* str_pbrk(char_type const* s, char_type const* charSet)
    {
        WINSTL_ASSERT(NULL != s);
        WINSTL_ASSERT(NULL != charSet);

        return const_cast<char_type*>(::strpbrk(s, charSet));
    }

    static char_type* str_end(char_type const* s)
    {
        WINSTL_ASSERT(NULL != s);

        for(; *s != '\0'; ++s)
        {}

        return const_cast<char_type*>(s);
    }

    static char_type* str_set(char_type* s, size_type n, char_type c)
    {
        WINSTL_ASSERT(NULL != s || 0u == n);

        for(; 0u != n; --n, ++s)
        {
            *s = c;
        }

        return s;
    }

public:
#ifndef NONLS
    static int_type get_locale_info(LCID locale, LCTYPE type, char_type* data, int cchData)
    {
        return ::GetLocaleInfoA(locale, type, data, cchData);
    }
#endif /* !NONLS */

public:
    static size_type get_module_filename(HMODULE hModule, char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        if(0 == cchBuffer)
        {
            char_type   buff[1 + WINSTL_CONST_MAX_PATH];

            return get_module_filename(hModule, &buff[0], STLSOFT_NUM_ELEMENTS(buff));
        }

        return class_type::GetModuleFileNameA(hModule, buffer, cchBuffer);
    }

    static size_type get_module_directory(HMODULE hModule, char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        size_type cch = get_module_filename(hModule, buffer, cchBuffer);

        if( 0 != cch &&
            cch < cchBuffer)
        {
            buffer[cch] = '\0';

            char_type *s = str_rchr(buffer, '\\');

            if(NULL != s)
            {
                *s = '\0';

                cch = static_cast<size_type>(s - buffer);
            }
        }

        return cch;
    }

    static size_type get_system_directory(char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        return class_type::GetSystemDirectoryA(buffer, cchBuffer);
    }

    static size_type get_windows_directory(char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        return class_type::GetWindowsDirectoryA(buffer, cchBuffer);
    }

public:
    static module_type load_library(char_type const* name)
    {
        WINSTL_ASSERT(NULL != name);

        return ::LoadLibraryA(name);
    }

    static bool_type free_library(module_type hModule)
    {
        return system_traits_::free_library(hModule);
    }

    static FARPROC find_symbol(module_type hModule, char const* symbolName)
    {
        WINSTL_ASSERT(NULL != symbolName);

        return system_traits_::find_symbol(hModule, symbolName);
    }

    static bool_type close_handle(handle_type h)
    {
        return system_traits_::close_handle(h);
    }

public:
    static error_type get_last_error()
    {
        return system_traits_::get_last_error();
    }

    static void set_last_error(error_type er = error_type())
    {
        system_traits_::set_last_error(er);
    }

public:
    static size_type get_environment_variable(char_type const* name, char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != name);
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        char_type   dummy[1];

        // If the buffer is NULL, we set it to a local buffer and cchBuffer
        // to 0, which will cause the API function to return the required
        // number of variables
        if(NULL == buffer)
        {
            buffer      =   &dummy[0];
            cchBuffer   =   0u;
        }

        size_type n = class_type::GetEnvironmentVariableA(name, buffer, cchBuffer);

        if(n > cchBuffer)
        {
            --n;    // GetEnvironmentVariable always gives size of string + nul terminator
        }

        if( 0u != cchBuffer &&
            n >= cchBuffer)
        {
            typedef system_traits_::scoped_mem_block scoped_mem_block;

            char_type*  buffer2 = scoped_mem_block::allocate_string_buffer_a(n);

            if(NULL == buffer2)
            {
                return 0;
            }
            else
            {
                scoped_mem_block    block(buffer2);
                size_type           n2 = class_type::GetEnvironmentVariableA(name, buffer2, 1 + n);

                if(n2 > cchBuffer)
                {
                    n2 = cchBuffer;
                }

                char_copy(buffer, buffer2, n2);

                return n2;
            }
        }

        return n;
    }

    static size_type expand_environment_strings(char_type const* src, char_type* dest, size_type cch_dest)
    {
        WINSTL_ASSERT(NULL != src);
        WINSTL_ASSERT(NULL != dest || 0 == cch_dest);

        return class_type::ExpandEnvironmentStringsA(src, dest, cch_dest);
    }

private:
    static size_type GetModuleFileNameA(HMODULE hModule, char_type* buffer, size_type cchBuffer)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::GetModuleFileNameA(hModule, buffer, stlsoft_ns_qual(truncation_cast)<DWORD>(cchBuffer));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cchBuffer));

        return ::GetModuleFileNameA(hModule, buffer, static_cast<DWORD>(cchBuffer));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::GetModuleFileNameA(hModule, buffer, cchBuffer);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }

    static size_type GetSystemDirectoryA(char_type* buffer, size_type cchBuffer)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::GetSystemDirectoryA(buffer, stlsoft_ns_qual(truncation_cast)<DWORD>(cchBuffer));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cchBuffer));

        return ::GetSystemDirectoryA(buffer, static_cast<DWORD>(cchBuffer));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::GetSystemDirectoryA(buffer, cchBuffer);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }

    static size_type GetWindowsDirectoryA(char_type* buffer, size_type cchBuffer)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::GetWindowsDirectoryA(buffer, stlsoft_ns_qual(truncation_cast)<DWORD>(cchBuffer));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cchBuffer));

        return ::GetWindowsDirectoryA(buffer, static_cast<DWORD>(cchBuffer));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::GetWindowsDirectoryA(buffer, cchBuffer);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }

    static size_type GetEnvironmentVariableA(char_type const* name, char_type* buffer, size_type cchBuffer)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::GetEnvironmentVariableA(name, buffer, stlsoft_ns_qual(truncation_cast)<DWORD>(cchBuffer));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cchBuffer));

        return ::GetEnvironmentVariableA(name, buffer, static_cast<DWORD>(cchBuffer));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::GetEnvironmentVariableA(name, buffer, cchBuffer);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }

    static size_type ExpandEnvironmentStringsA(char_type const* src, char_type* dest, size_type cch_dest)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::ExpandEnvironmentStringsA(src, dest, stlsoft_ns_qual(truncation_cast)<DWORD>(cch_dest));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cch_dest));

        return ::ExpandEnvironmentStringsA(src, dest, static_cast<DWORD>(cch_dest));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::ExpandEnvironmentStringsA(src, dest, cch_dest);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }
};

STLSOFT_TEMPLATE_SPECIALISATION
struct system_traits<ws_char_w_t>
{
public:
    typedef ws_char_w_t                 char_type;
    typedef ws_size_t                   size_type;
    typedef ws_ptrdiff_t                difference_type;
    typedef system_traits<char_type>    class_type;
    typedef ws_int_t                    int_type;
    typedef ws_bool_t                   bool_type;
    typedef HMODULE                     module_type;
    typedef HANDLE                      handle_type;
    typedef DWORD                       result_code_type;
    typedef DWORD                       error_type;

public:
    static char_type* char_copy(char_type* dest, char_type const* src, size_type n)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(0 == n || NULL != src);

        return static_cast<char_type*>(::memcpy(dest, src, sizeof(char_type) * n));
    }

#if !defined(STLSOFT_USING_SAFE_STR_FUNCTIONS) || \
    defined(_CRT_SECURE_NO_DEPRECATE)
    static char_type* str_copy(char_type* dest, char_type const* src)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(NULL != src);

# ifdef STLSOFT_MIN_CRT
        return ::lstrcpyW(dest, src);
# else /*? STLSOFT_MIN_CRT */
        return ::wcscpy(dest, src);
# endif /* STLSOFT_MIN_CRT */
    }

    static char_type* str_n_copy(char_type* dest, char_type const* src, size_type cch)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(0 == cch || NULL != src);

        return ::wcsncpy(dest, src, cch);
    }

    static char_type* str_cat(char_type* dest, char_type const* src)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(NULL != src);

# ifdef STLSOFT_MIN_CRT
        return ::lstrcatW(dest, src);
# else /*? STLSOFT_MIN_CRT */
        return ::wcscat(dest, src);
# endif /* STLSOFT_MIN_CRT */
    }

    static char_type* str_n_cat(char_type* dest, char_type const* src, size_type cch)
    {
        WINSTL_ASSERT(NULL != dest);
        WINSTL_ASSERT(NULL != src);

        return ::wcsncat(dest, src, cch);
    }
#endif /* !STLSOFT_USING_SAFE_STR_FUNCTIONS || _CRT_SECURE_NO_DEPRECATE */

    static int_type str_compare(char_type const* s1, char_type const* s2)
    {
        WINSTL_ASSERT(NULL != s1);
        WINSTL_ASSERT(NULL != s2);

#ifdef STLSOFT_MIN_CRT
        return ::lstrcmpW(s1, s2);
#else /*? STLSOFT_MIN_CRT */
        return ::wcscmp(s1, s2);
#endif /* STLSOFT_MIN_CRT */
    }

    static int_type str_compare_no_case(char_type const* s1, char_type const* s2)
    {
        WINSTL_ASSERT(NULL != s1);
        WINSTL_ASSERT(NULL != s2);

        return ::lstrcmpiW(s1, s2);
    }

    static int_type str_n_compare(char_type const* s1, char_type const* s2, size_type cch)
    {
        WINSTL_ASSERT(NULL != s1);
        WINSTL_ASSERT(NULL != s2);

        return ::wcsncmp(s1, s2, cch);
    }

// TODO: move all these into internal, C-compatible, service files
//
// #include <stlsoft/system/apis/string/wcsnicmp.h

#ifdef WINSTL_SYSTEM_TRAITS_HAS_wcsnicmp_
# undef WINSTL_SYSTEM_TRAITS_HAS_wcsnicmp_
#endif /* WINSTL_SYSTEM_TRAITS_HAS_wcsnicmp_ */

#ifdef WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_
# undef WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_
#endif /* WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_ */

#if defined(STLSOFT_COMPILER_IS_BORLAND)
# if !defined(__STDC__)
#  define WINSTL_SYSTEM_TRAITS_HAS_wcsnicmp_
# endif
# if !defined(__MFC_COMPAT__)
#  define WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_
# endif
#elif defined(STLSOFT_COMPILER_IS_DMC)
# define WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_
#elif defined(STLSOFT_COMPILER_IS_GCC)
# if !defined(__STRICT_ANSI__)
#  define WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_
# endif
#elif defined(STLSOFT_COMPILER_IS_INTEL) || \
      defined(STLSOFT_COMPILER_IS_MSVC)
# if !defined(__STDC__)
#  define WINSTL_SYSTEM_TRAITS_HAS_wcsnicmp_
# endif
# define WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_
#elif defined(STLSOFT_COMPILER_IS_MWERKS)
# define WINSTL_SYSTEM_TRAITS_HAS_wcsnicmp_
# define WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_
#elif defined(STLSOFT_COMPILER_IS_WATCOM)
# define WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_
#endif /* compiler */

#if defined(WINSTL_SYSTEM_TRAITS_HAS_wcsnicmp_) || \
    defined(WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_)
    static int_type str_n_compare_no_case(char_type const* s1, char_type const* s2, size_type cch)
    {
        WINSTL_ASSERT(NULL != s1);
        WINSTL_ASSERT(NULL != s2);

# if defined(WINSTL_SYSTEM_TRAITS_HAS__wcsnicmp_)
        return ::_wcsnicmp(s1, s2, cch);
# elif defined(WINSTL_SYSTEM_TRAITS_HAS_wcsnicmp_)
        return ::wcsnicmp(s1, s2, cch);
# else
#  error
# endif
    }
#else /* ? compiler */
    static int_type str_n_compare_no_case(char_type const* s1, char_type const* s2, size_type cch);
#endif /* compiler */

    static size_type str_len(char_type const* src)
    {
        WINSTL_ASSERT(NULL != src);

#ifdef STLSOFT_MIN_CRT
        return static_cast<size_type>(::lstrlenW(src));
#else /*? STLSOFT_MIN_CRT */
        return ::wcslen(src);
#endif /* STLSOFT_MIN_CRT */
    }

    static char_type* str_chr(char_type const* s, char_type ch)
    {
        WINSTL_ASSERT(NULL != s);

        return const_cast<char_type*>(::wcschr(s, ch));
    }

    static char_type* str_rchr(char_type const* s, char_type ch)
    {
        WINSTL_ASSERT(NULL != s);

        return const_cast<char_type*>(::wcsrchr(s, ch));
    }

    static char_type* str_str(char_type const* s, char_type const* sub)
    {
        WINSTL_ASSERT(NULL != s);
        WINSTL_ASSERT(NULL != sub);

        return const_cast<char_type*>(::wcsstr(s, sub));
    }

    static char_type* str_pbrk(char_type const* s, char_type const* charSet)
    {
        WINSTL_ASSERT(NULL != s);
        WINSTL_ASSERT(NULL != charSet);

        return const_cast<char_type*>(::wcspbrk(s, charSet));
    }

    static char_type* str_end(char_type const* s)
    {
        WINSTL_ASSERT(NULL != s);

        for(; *s != L'\0'; ++s)
        {}

        return const_cast<char_type*>(s);
    }

    static char_type* str_set(char_type* s, size_type n, char_type c)
    {
        WINSTL_ASSERT(NULL != s || 0u == n);

        for(; 0u != n; --n, ++s)
        {
            *s = c;
        }

        return s;
    }

public:
#ifndef NONLS
    static int_type get_locale_info(LCID locale, LCTYPE type, char_type* data, int cchData)
    {
        return ::GetLocaleInfoW(locale, type, data, cchData);
    }
#endif /* !NONLS */

public:
    static size_type get_module_filename(HMODULE hModule, char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        if(0 == cchBuffer)
        {
            char_type   buff[1 + WINSTL_CONST_MAX_PATH];
            size_type   cch =   get_module_filename(hModule, &buff[0], STLSOFT_NUM_ELEMENTS(buff));

            if(0 == str_compare(L"\\\\?\\", buff))
            {
                return CONST_NT_MAX_PATH;
            }
            else
            {
                return cch;
            }
        }

        return class_type::GetModuleFileNameW(hModule, buffer, cchBuffer);
    }

    static size_type get_module_directory(HMODULE hModule, char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        size_type   cch =   get_module_filename(hModule, buffer, cchBuffer);

        if( 0 != cch &&
            cch < cchBuffer)
        {
            buffer[cch] = '\0';

            char_type *s = str_rchr(buffer, '\\');

            if(NULL != s)
            {
                *s = '\0';

                cch = static_cast<size_type>(s - buffer);
            }
        }

        return cch;
    }

    static size_type get_system_directory(char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        return class_type::GetSystemDirectoryW(buffer, cchBuffer);
    }

    static size_type get_windows_directory(char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        return class_type::GetWindowsDirectoryW(buffer, cchBuffer);
    }

public:
    static module_type load_library(char_type const* name)
    {
        WINSTL_ASSERT(NULL != name);

        return ::LoadLibraryW(name);
    }

    static bool_type free_library(module_type hModule)
    {
        return system_traits_::free_library(hModule);
    }

    static FARPROC find_symbol(module_type hModule, char const* symbolName)
    {
        WINSTL_ASSERT(NULL != symbolName);

        return system_traits_::find_symbol(hModule, symbolName);
    }

public:
    static bool_type close_handle(handle_type h)
    {
        return system_traits_::close_handle(h);
    }

public:
    static error_type get_last_error()
    {
        return system_traits_::get_last_error();
    }

    static void set_last_error(error_type er = error_type())
    {
        system_traits_::set_last_error(er);
    }

public:
    static size_type get_environment_variable(char_type const* name, char_type* buffer, size_type cchBuffer)
    {
        WINSTL_ASSERT(NULL != name);
        WINSTL_ASSERT(NULL != buffer || 0 == cchBuffer);

        char_type   dummy[1];

        // If the buffer is NULL, we set it to a local buffer and cchBuffer
        // to 0, which will cause the API function to return the required
        // number of variables
        if(NULL == buffer)
        {
            buffer      =   &dummy[0];
            cchBuffer   =   0u;
        }

        size_type n = class_type::GetEnvironmentVariableW(name, buffer, cchBuffer);

        if(n > cchBuffer)
        {
            --n;    // GetEnvironmentVariable always gives size of string + nul terminator
        }

        if( 0u != cchBuffer &&
            n >= cchBuffer)
        {
            typedef system_traits_::scoped_mem_block scoped_mem_block;

            char_type*  buffer2 = scoped_mem_block::allocate_string_buffer_w(n);

            if(NULL == buffer2)
            {
                return 0;
            }
            else
            {
                scoped_mem_block    block(buffer2);
                size_type           n2 = class_type::GetEnvironmentVariableW(name, buffer2, 1 + n);

                if(n2 > cchBuffer)
                {
                    n2 = cchBuffer;
                }

                char_copy(buffer, buffer2, n2);

                return n2;
            }
        }

        return n;
    }

    static size_type expand_environment_strings(char_type const* src, char_type* dest, size_type cch_dest)
    {
        WINSTL_ASSERT(NULL != src);
        WINSTL_ASSERT(NULL != dest || 0 == cch_dest);

        return class_type::ExpandEnvironmentStringsW(src, dest, cch_dest);
    }

private:
    static size_type GetModuleFileNameW(HMODULE hModule, char_type* buffer, size_type cchBuffer)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::GetModuleFileNameW(hModule, buffer, stlsoft_ns_qual(truncation_cast)<DWORD>(cchBuffer));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cchBuffer));

        return ::GetModuleFileNameW(hModule, buffer, static_cast<DWORD>(cchBuffer));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::GetModuleFileNameW(hModule, buffer, cchBuffer);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }

    static size_type GetSystemDirectoryW(char_type* buffer, size_type cchBuffer)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::GetSystemDirectoryW(buffer, stlsoft_ns_qual(truncation_cast)<DWORD>(cchBuffer));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cchBuffer));

        return ::GetSystemDirectoryW(buffer, static_cast<DWORD>(cchBuffer));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::GetSystemDirectoryW(buffer, cchBuffer);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }

    static size_type GetWindowsDirectoryW(char_type* buffer, size_type cchBuffer)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::GetWindowsDirectoryW(buffer, stlsoft_ns_qual(truncation_cast)<DWORD>(cchBuffer));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cchBuffer));

        return ::GetWindowsDirectoryW(buffer, static_cast<DWORD>(cchBuffer));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::GetWindowsDirectoryW(buffer, cchBuffer);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }

    static size_type GetEnvironmentVariableW(char_type const* name, char_type* buffer, size_type cchBuffer)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::GetEnvironmentVariableW(name, buffer, stlsoft_ns_qual(truncation_cast)<DWORD>(cchBuffer));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cchBuffer));

        return ::GetEnvironmentVariableW(name, buffer, static_cast<DWORD>(cchBuffer));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::GetEnvironmentVariableW(name, buffer, cchBuffer);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }

    static size_type ExpandEnvironmentStringsW(char_type const* src, char_type* dest, size_type cch_dest)
    {
#ifdef _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING
# ifdef STLSOFT_CF_EXCEPTION_SUPPORT
        return ::ExpandEnvironmentStringsW(src, dest, stlsoft_ns_qual(truncation_cast)<DWORD>(cch_dest));
# else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
        WINSTL_MESSAGE_ASSERT("buffer size out of range", stlsoft_ns_qual(truncation_test)<DWORD>(cch_dest));

        return ::ExpandEnvironmentStringsW(src, dest, static_cast<DWORD>(cch_dest));
# endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
#else /* ? _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
        return ::ExpandEnvironmentStringsW(src, dest, cch_dest);
#endif /* _WINSTL_SYSTEM_TRAITS_USE_TRUNCATION_TESTING */
    }
};

#endif /* STLSOFT_DOCUMENTATION_SKIP_SECTION */

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

#ifdef STLSOFT_UNITTEST
# include "./unittest/system_traits_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_SYSTEM_TRAITS */

/* ///////////////////////////// end of file //////////////////////////// */