special_string_instance.hpp

新版本TR1的stl

/* /////////////////////////////////////////////////////////////////////////
 * File:        stlsoft/string/special_string_instance.hpp
 *
 * Purpose:     Special string instance class template.
 *
 * Created:     3rd June 2006
 * Updated:     22nd March 2007
 *
 * Thanks to:   Pablo Aguilar for spotting my omission of string access shims
 *              for special_string_instance_1.
 *
 * Home:        http://stlsoft.org/
 *
 * Copyright (c) 2006-2007, 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 stlsoft/string/special_string_instance.hpp
 *
 * \brief [C++ only] Definition of the stlsoft::special_string_instance
 *  class template
 *   (\ref group__library__string "String" Library).
 */

#ifndef STLSOFT_INCL_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE
#define STLSOFT_INCL_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
# define STLSOFT_VER_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE_MAJOR       1
# define STLSOFT_VER_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE_MINOR       2
# define STLSOFT_VER_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE_REVISION    3
# define STLSOFT_VER_STLSOFT_STRING_HPP_SPECIAL_STRING_INSTANCE_EDIT        15
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////
 * Compatibility
 */

/*
[Incompatibilies-start]
STLSOFT_COMPILER_IS_MSVC:       _MSC_VER<1200
[Incompatibilies-end]
 */

/* Compatibility
[<[STLSOFT-AUTO:NO-DOCFILELABEL]>]
[<[STLSOFT-AUTO:NO-UNITTEST]>]
*/

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

#ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
# include <stlsoft/stlsoft.h>
#endif /* !STLSOFT_INCL_STLSOFT_H_STLSOFT */
#ifndef STLSOFT_INCL_STLSOFT_MEMORY_HPP_AUTO_BUFFER
# include <stlsoft/memory/auto_buffer.hpp>
#endif /* !STLSOFT_INCL_STLSOFT_MEMORY_HPP_AUTO_BUFFER */
#ifndef STLSOFT_INCL_STLSOFT_META_HPP_IS_SAME_TYPE
# include <stlsoft/meta/is_same_type.hpp>
#endif /* !STLSOFT_INCL_STLSOFT_META_HPP_IS_SAME_TYPE */
#ifndef STLSOFT_INCL_STLSOFT_META_HPP_SELECT_FIRST_TYPE_IF
# include <stlsoft/meta/select_first_type_if.hpp>
#endif /* !STLSOFT_INCL_STLSOFT_META_HPP_SELECT_FIRST_TYPE_IF */
#ifndef STLSOFT_INCL_STLSOFT_SYNCH_HPP_LOCK_SCOPE
# include <stlsoft/synch/lock_scope.hpp>
#endif /* !STLSOFT_INCL_STLSOFT_SYNCH_HPP_LOCK_SCOPE */

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

#ifndef _STLSOFT_NO_NAMESPACE
namespace stlsoft
{
#endif /* _STLSOFT_NO_NAMESPACE */

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

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

template<   ss_typename_param_k C
        ,   ss_size_t           N
        ,   ss_typename_param_k A
        ,   ss_typename_param_k A0
        >
struct ssi_buffer
{
/// \name Member Types
/// @{
public:
    typedef C                                                   char_type;
    typedef A                                                   allocator_type;
    typedef ss_size_t                                           size_type;
    typedef A0                                                  argument_0_type;
#if defined(STLSOFT_COMPILER_IS_BORLAND)
    typedef stlsoft::auto_buffer<char_type, 128, allocator_type>  buffer_type;
#else /* ? compiler */
    typedef stlsoft::auto_buffer<char_type, N, allocator_type>  buffer_type;
#endif /* compiler */
/// @}

/// \name Construction
/// @{
public:
    ssi_buffer()
        : m_len(0)
        , m_buffer(0)
    {}

    void init(size_type (*pfn)(char_type *, size_type))
    {
        size_type   cch =   pfn(NULL, 0);   // We don't pass NULL here, just in case

        if(m_buffer.resize(1 + cch))
        {
            for(;;)
            {
                cch = pfn(&m_buffer[0], m_buffer.size());

                if(cch < m_buffer.size())
                {
                    m_len = cch;
                    break;
                }
                else
                {
                    if(!m_buffer.resize(2 * m_buffer.size()))
                    {
                        m_buffer.resize(0);
                        break;
                    }
                }
            }
        }

        m_buffer[m_len] = '\0';
    }

    void init(argument_0_type arg0, size_type (*pfn)(argument_0_type, char_type *, size_type))
    {
        size_type   cch =   pfn(arg0, NULL, 0);   // We don't pass NULL here, just in case

        if(m_buffer.resize(1 + cch))
        {
            for(;;)
            {
                cch = pfn(arg0, &m_buffer[0], m_buffer.size());

                if(cch < m_buffer.size())
                {
                    m_len = cch;
                    break;
                }
                else
                {
                    if(!m_buffer.resize(2 * m_buffer.size()))
                    {
                        m_buffer.resize(0);
                        break;
                    }
                }
            }
        }

        m_buffer[m_len] = '\0';
    }
/// @}

/// \name Accessors
/// @{
public:
    char_type const* data() const
    {
        return m_buffer.data();
    }
    size_type       length() const
    {
        return m_len;
    }
/// @}

/// \name Members
/// @{
private:
    size_type       m_len;
    buffer_type     m_buffer;
/// @}
};

template<   ss_typename_param_k C
        ,   ss_size_t           N
        ,   ss_typename_param_k A
        ,   ss_typename_param_k A0
        >
struct ssi_buffer_non_static
    : public ssi_buffer<C, N, A, A0>
{
/// \name Member Types
/// @{
public:
    typedef ssi_buffer<C, N, A, A0>                         ssi_buffer_type;
    typedef ssi_buffer<C, N, A, A0>                         parent_class_type;
    typedef ssi_buffer_non_static<C, N, A, A0>              class_type;

    typedef ss_typename_type_k ssi_buffer_type::char_type   char_type;
    typedef ss_typename_type_k ssi_buffer_type::size_type   size_type;
/// @}

/// \name Construction
/// @{
public:
    ssi_buffer_non_static(size_type (*pfn)(char_type *, size_type))
    {
        parent_class_type::init(pfn);
    }
    ssi_buffer_non_static(A0 a0, size_type (*pfn)(A0, char_type *, size_type))
    {
        parent_class_type::init(a0, pfn);
    }
/// @}

/// \name Accessors
/// @{
public:
    char_type const* data() const
    {
        return parent_class_type::data();
    }
    size_type       length() const
    {
        return parent_class_type::length();
    }
/// @}

/// \name Not to be implemented
/// @{
private:
    ssi_buffer_non_static(class_type const&);
    class_type& operator =(class_type const&);
/// @}
};

template<   ss_typename_param_k C
        ,   ss_size_t           N
        ,   ss_typename_param_k A
        ,   ss_typename_param_k A0
        ,   ss_typename_param_k P   // Passes policy type, from which spin_mutex_type is elicited, so non-statics do not need to specify it
        >
struct ssi_buffer_static
{
/// \name Member Types
/// @{
public:
    typedef ssi_buffer<C, N, A, A0>                         ssi_buffer_type;
    typedef ssi_buffer_static<C, N, A, A0, P>               class_type;

    typedef ss_typename_type_k ssi_buffer_type::char_type   char_type;
    typedef ss_typename_type_k ssi_buffer_type::size_type   size_type;
private:
    typedef P                                               policy_type;
    typedef ss_typename_type_k policy_type::spin_mutex_type spin_mutex_type;
/// @}

/// \name Construction
/// @{
public:
    ssi_buffer_static(size_type (*pfn)(char_type *, size_type))
        : m_buffer(get_buffer(pfn))
    {}
    ssi_buffer_static(A0 a0, size_type (*pfn)(A0, char_type *, size_type))
        : m_buffer(a0, get_buffer(a0, pfn))
    {}
/// @}

/// \name Accessors
/// @{
public:
    char_type const* data() const
    {
        return m_buffer.data();
    }
    size_type       length() const
    {
        return m_buffer.length();
    }
/// @}

/// \name Implementation
/// @{