---

/include/recls/stl/root_sequence.hpp

Go to the documentation of this file.

/* 
 * File:        recls/stl/root_sequence.hpp
 *
 * Purpose:     Contains the basic_root_sequence template class, and ANSI
 *              and Unicode specialisations thereof.
 *
 * Created:     25th March 2004
 * Updated:     11th March 2005
 *
 * Home:        http://recls.org/
 *
 * Copyright 2004-2005, 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.
 *
 * 


#ifndef RECLS_INCL_RECLSTL_STL_HPP_ROOT_SEQUENCE
#define RECLS_INCL_RECLSTL_STL_HPP_ROOT_SEQUENCE

#ifndef RECLS_DOCUMENTATION_SKIP_SECTION
# define RECLS_VER_RECLSTL_STL_HPP_ROOT_SEQUENCE_MAJOR      3
# define RECLS_VER_RECLSTL_STL_HPP_ROOT_SEQUENCE_MINOR      0
# define RECLS_VER_RECLSTL_STL_HPP_ROOT_SEQUENCE_REVISION   1
# define RECLS_VER_RECLSTL_STL_HPP_ROOT_SEQUENCE_EDIT       11
#endif /* !RECLS_DOCUMENTATION_SKIP_SECTION */

/* 
 * Includes
 */

#ifndef RECLS_INCL_RECLS_STL_HPP_RECLS
# include <recls/stl/recls.hpp>
#endif /* !RECLS_INCL_RECLS_STL_HPP_RECLS */
#ifndef RECLS_INCL_RECLS_STL_HPP_TRAITS
# include <recls/stl/traits.hpp>
#endif /* !RECLS_INCL_RECLS_STL_HPP_TRAITS */
#ifndef STLSOFT_INCL_H_STLSOFT_NEW_ALLOCATOR
# include <stlsoft_new_allocator.h>
#endif /* !STLSOFT_INCL_H_STLSOFT_NEW_ALLOCATOR */
#ifndef STLSOFT_INCL_H_STLSOFT_PROXY_SEQUENCE
# include <stlsoft_proxy_sequence.h>
#endif /* !STLSOFT_INCL_H_STLSOFT_PROXY_SEQUENCE */

/* 
 * Namespace
 */

#if !defined(RECLS_NO_NAMESPACE)
namespace recls
{

namespace stl
{
#endif /* !RECLS_NO_NAMESPACE */

/* 
 * Classes
 */

// class basic_root_sequence
template<   typename C
#ifdef __STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
        ,   typename T = reclstl_traits<C>
        ,   typename A = stlsoft::new_allocator<C>
#else
        ,   typename T /* = reclstl_traits<C> */
        ,   typename A /* = stlsoft::new_allocator<C> */
#endif /* __STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT */
        >
class basic_root_sequence
{
public:
    typedef C                                                       char_type;
    typedef T                                                       traits_type;
    typedef A                                                       allocator_type;
    typedef basic_root_sequence<C, T, A>                            class_type;
    typedef char_type const                                         *value_type;
private:
    struct proxy_traits_type
    {
        static recls_char_t const *make_value(recls_root_t const &root)
        {
            return root.name;
        }
    };

    typedef stlsoft::proxy_sequence<    const recls_root_t
                                    ,   recls_char_t const*
                                    ,   proxy_traits_type
                                    >                               sequence_type;
public:
    typedef typename sequence_type::const_iterator                  const_iterator;
    typedef value_type                                              &reference;
    typedef value_type const                                        &const_reference;
    typedef size_t                                                  size_type;

public:
    basic_root_sequence();
    ~basic_root_sequence();

public:
    const_iterator  begin() const;
    const_iterator  end() const;

public:
    size_type           size() const;
    recls_bool_t        empty() const;
    static size_type    max_size();

private:
    recls_root_t    *m_roots;
    size_type       m_cRoots;

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

/* 
 * Typedefs for commonly encountered types
 */

typedef basic_root_sequence<recls_char_a_t, reclstl_traits<recls_char_a_t>, stlsoft::new_allocator<recls_char_a_t> >    root_sequence_a;
typedef basic_root_sequence<recls_char_w_t, reclstl_traits<recls_char_w_t>, stlsoft::new_allocator<recls_char_w_t> >    root_sequence_w;
typedef basic_root_sequence<recls_char_t,   reclstl_traits<recls_char_t>,   stlsoft::new_allocator<recls_char_t> >      root_sequence;

// Shims

template <typename C, typename T, typename A>
inline recls_bool_t is_empty(basic_root_sequence<C, T, A> const &s)
{
    return s.empty();
}

// Implementation

#ifndef RECLS_DOCUMENTATION_SKIP_SECTION

// basic_root_sequence

// Construction

template <typename C, typename T, typename A>
inline basic_root_sequence<C, T, A>::basic_root_sequence()
#ifdef RECLS_COMPILER_IS_BORLAND
    : m_cRoots(26) // It fails to "see" Recls_GetRoots()
#else /* ? compiler */
    : m_cRoots(Recls_GetRoots(NULL, 0))
#endif /* compiler */
{
    m_roots = new recls_root_t[m_cRoots];

    m_cRoots = Recls_GetRoots(m_roots, m_cRoots);
}

template <typename C, typename T, typename A>
inline basic_root_sequence<C, T, A>::~basic_root_sequence()
{
    delete [] m_roots;
}

// Iteration

template <typename C, typename T, typename A>
inline typename basic_root_sequence<C, T, A>::const_iterator basic_root_sequence<C, T, A>::begin() const
{
    return const_iterator(&m_roots[0], &m_roots[m_cRoots]);
}

template <typename C, typename T, typename A>
inline typename basic_root_sequence<C, T, A>::const_iterator basic_root_sequence<C, T, A>::end() const
{
    return const_iterator();
}

// State

template <typename C, typename T, typename A>
inline typename basic_root_sequence<C, T, A>::size_type basic_root_sequence<C, T, A>::size() const
{
    return m_cRoots;
}

template <typename C, typename T, typename A>
inline recls_bool_t basic_root_sequence<C, T, A>::empty() const
{
    return 0 == m_cRoots;
}

template <typename C, typename T, typename A>
inline /* static */ typename basic_root_sequence<C, T, A>::size_type basic_root_sequence<C, T, A>::max_size()
{
    return static_cast<size_type>(-1) / sizeof(value_type);
}

#endif /* !RECLS_DOCUMENTATION_SKIP_SECTION */

/* 

#if !defined(RECLS_NO_NAMESPACE)
} /* namespace stl */
} /* namespace recls */
#endif /* !RECLS_NO_NAMESPACE */

/* 

#endif /* RECLS_INCL_RECLSTL_STL_HPP_ROOT_SEQUENCE */

/* 

recls Library documentation © Synesis Software Pty Ltd, 2001-2005