---

/Mappings/STL/reclstl_root_sequence.h

Go to the documentation of this file.

/* 
 * File:        reclstl_root_sequence.h
 *
 * Purpose:     Contains the basic_root_sequence template class, and ANSI
 *              and Unicode specialisations thereof.
 *
 * Created:     25th March 2004
 * Updated:     24th April 2004
 *
 * Author:      Matthew Wilson, Synesis Software Pty Ltd.
 *
 * License:     (Licensed under the Synesis Software Standard Source License)
 *
 *              Copyright (C) 2002-2004, Synesis Software Pty Ltd.
 *
 *              All rights reserved.
 *
 *              www:        http://www.synesis.com.au/software
 *                          http://www.recls.org/
 *
 *              email:      submissions@recls.org  for submissions
 *                          admin@recls.org        for other enquiries
 *
 *              Redistribution and use in source and binary forms, with or
 *              without modification, are permitted provided that the following
 *              conditions are met:
 *
 *              (i) Redistributions of source code must retain the above
 *              copyright notice and contact information, this list of
 *              conditions and the following disclaimer.
 *
 *              (ii) Any derived versions of this software (howsoever modified)
 *              remain the sole property of Synesis Software.
 *
 *              (iii) Any derived versions of this software (howsoever modified)
 *              remain subject to all these conditions.
 *
 *              (iv) Neither the name of Synesis Software nor the names of any
 *              subdivisions, employees or agents of Synesis Software, nor the
 *              names of any other contributors to this software may be used to
 *              endorse or promote products derived from this software without
 *              specific prior written permission.
 *
 *              This source code is provided by Synesis Software "as is" and any
 *              warranties, whether expressed or implied, including, but not
 *              limited to, the implied warranties of merchantability and
 *              fitness for a particular purpose are disclaimed. In no event
 *              shall the Synesis Software 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_H_RECLSTL_ROOT_SEQUENCE
#define RECLS_INCL_H_RECLSTL_ROOT_SEQUENCE

#ifndef RECLS_DOCUMENTATION_SKIP_SECTION
# define RECLS_VER_H_RECLSTL_ROOT_SEQUENCE_MAJOR    1
# define RECLS_VER_H_RECLSTL_ROOT_SEQUENCE_MINOR    0
# define RECLS_VER_H_RECLSTL_ROOT_SEQUENCE_REVISION 4
# define RECLS_VER_H_RECLSTL_ROOT_SEQUENCE_EDIT     4
#endif /* !RECLS_DOCUMENTATION_SKIP_SECTION */

/* 
 * Includes
 */

#ifndef RECLS_INCL_H_RECLSTL
# include "reclstl.h"
#endif /* !RECLS_INCL_H_RECLSTL */
#ifndef RECLS_INCL_H_RECLSTL_TRAITS
# include "reclstl_traits.h"
#endif /* !RECLS_INCL_H_RECLSTL_TRAITS */
#ifndef _STLSOFT_INCL_H_STLSOFT_NEW_ALLOCATOR
# include <stlsoft_new_allocator.h>
#endif /* !_STLSOFT_INCL_H_STLSOFT_NEW_ALLOCATOR */

/* 
 * 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 sequence_type(&m_roots[0], &m_roots[m_cRoots]).begin();
}

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 sequence_type(&m_roots[0], &m_roots[m_cRoots]).end();
}

// 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_H_RECLSTL_ROOT_SEQUENCE */

/* 

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