include/array - stdcxx - Git at Google

 // -*- C++ -*-
 /***************************************************************************
  *
  * array - definition of class template array
  *
  * $Id$
  *
  ***************************************************************************
  *
  * Licensed to the Apache Software  Foundation (ASF) under one or more
  * contributor  license agreements.  See  the NOTICE  file distributed
  * with  this  work  for  additional information  regarding  copyright
  * ownership.   The ASF  licenses this  file to  you under  the Apache
  * License, Version  2.0 (the  "License"); you may  not use  this file
  * except in  compliance with the License.   You may obtain  a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the  License is distributed on an  "AS IS" BASIS,
  * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
  * implied.   See  the License  for  the  specific language  governing
  * permissions and limitations under the License.
  *
  * Copyright 1994-2006 Rogue Wave Software.
  *
  **************************************************************************/

 #ifndef _RWSTD_ARRAY_INCLUDED
 #define _RWSTD_ARRAY_INCLUDED

 #include <rw/_defs.h>

 #ifdef _RWSTD_NO_EXT_CXX_0X
 #  error _RWSTD_NO_EXT_CXX_0X defined and C++0x header included
 #endif   // _RWSTD_NO_EXT_CXX_0X

 #include <rw/_algobase.h>
 #include <rw/_error.h>
 #include <rw/_iterator.h>


 _RWSTD_NAMESPACE (std) {

 // [array] -- class template array
 template <class _TypeT, _RWSTD_SIZE_T _Size>
 struct array
 {
     // types:
     typedef _TypeT            value_type;
     typedef value_type&       reference;
     typedef const value_type& const_reference;
     typedef value_type*       pointer;
     typedef const value_type* const_pointer;
     typedef _RWSTD_SIZE_T     size_type;
     typedef _RWSTD_PTRDIFF_T  difference_type;

 #ifndef _RWSTD_NO_DEBUG_ITER

     typedef _RW::__rw_debug_iter <array, pointer, pointer> iterator;

     typedef _RW::__rw_debug_iter <array, const_pointer, pointer> const_iterator;

     iterator _C_make_iter (pointer __ptr) {
         return iterator (*this, __ptr);
     }

     const_iterator _C_make_iter (const_pointer __ptr) const {
         return const_iterator (*this, __ptr);
     }

 #else   // if defined (_RWSTD_NO_DEBUG_ITER)

     typedef pointer         iterator;
     typedef const_pointer   const_iterator;

     iterator _C_make_iter (pointer __ptr) {
         return __ptr;
     }

     const_iterator _C_make_iter (const_pointer __ptr) const {
         return __ptr;
     }

 #endif   // _RWSTD_NO_DEBUG_ITER

     typedef _RWSTD_REVERSE_ITERATOR (iterator,
                                      reference,
                                      pointer,
                                      random_access_iterator_tag)
         reverse_iterator;

     typedef _RWSTD_REVERSE_ITERATOR (const_iterator,
                                      const_reference,
                                      const_pointer,
                                      random_access_iterator_tag)
         const_reverse_iterator;

     // No explicit construct/copy/destroy for aggregate type
     void assign (const_reference);
     void swap (array&);

     // iterators:
     iterator begin () {
         return _C_make_iter (data ());
     }

     const_iterator begin () const {
         return _C_make_iter (data ());
     }

     iterator end () {
         return _C_make_iter (data () + size ());
     }

     const_iterator end () const {
         return _C_make_iter (data () + size ());
     }

     reverse_iterator rbegin () {
         return reverse_iterator (end ());
     }

     const_reverse_iterator rbegin () const {
         return const_reverse_iterator (end ());
     }

     reverse_iterator rend () {
         return reverse_iterator (begin ());
     }

     const_reverse_iterator rend () const {
         return const_reverse_iterator (begin ());
     }

     // capacity:
     size_type size () const {
         return _Size;
     }

     size_type max_size () const {
         return _Size;
     }

     bool empty () const {
         return 0 == size ();
     }

     // element access:
     reference operator[] (size_type);
     const_reference operator[] (size_type) const;

     const_reference at (size_type) const;
     reference at (size_type);

     reference front () {
         _RWSTD_ASSERT (!empty ());
         return *data ();
     }

     const_reference front () const {
         _RWSTD_ASSERT (!empty ());
         return *data ();
     }

     reference back () {
         _RWSTD_ASSERT (!empty ());
         return data () [size () - 1];
     }

     const_reference back () const {
         _RWSTD_ASSERT (!empty ());
         return data () [size () - 1];
     }

     pointer data () {
         return _C_elems;
     }

     const_pointer data () const {
         return _C_elems;
     }

     // private: (no public/protected/private in aggregate types)
     value_type _C_elems [_Size];
 };


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline void
 array<_TypeT, _Size>::
 assign (const_reference __val)
 {
     const pointer __end = data () + size ();

     for (pointer __ptr = data (); __ptr != __end; ++__ptr)
         *__ptr = __val;
 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline void
 array<_TypeT, _Size>::
 swap (array<_TypeT, _Size> &__other)
 {
     _RWSTD_ASSERT (size () == __other.size ());

     const array __tmp (*this);
     *this = __other;
     __other = __tmp;
 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline typename array<_TypeT, _Size>::reference
 array<_TypeT, _Size>::
 operator[] (size_type __inx)
 {
 #ifdef _RWSTD_BOUNDS_CHECKING

     _RWSTD_REQUIRES (__inx < size (),
                      (_RWSTD_ERROR_OUT_OF_RANGE,
                       _RWSTD_FUNC ("array::operator[](size_type)"),
                       __inx, size ()));

 #endif   // _RWSTD_BOUNDS_CHECKING

     return data ()[__inx];
 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline typename array<_TypeT, _Size>::const_reference
 array<_TypeT, _Size>::
 operator[] (size_type __inx) const
 {
 #ifdef _RWSTD_BOUNDS_CHECKING

     _RWSTD_REQUIRES (__inx < size (),
                      (_RWSTD_ERROR_OUT_OF_RANGE,
                       _RWSTD_FUNC ("array::operator[](size_type) const"),
                       __inx, size ()));

 #endif   // _RWSTD_BOUNDS_CHECKING

     return data ()[__inx];
 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline typename array<_TypeT, _Size>::reference
 array<_TypeT, _Size>::
 at (size_type __inx)
 {
     _RWSTD_REQUIRES (__inx < size (),
                      (_RWSTD_ERROR_OUT_OF_RANGE,
                       _RWSTD_FUNC ("array::at (size_type)"),
                       __inx, size ()));

     return data ()[__inx];
 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline typename array<_TypeT, _Size>::const_reference
 array<_TypeT, _Size>::
 at (size_type __inx)  const
 {
     _RWSTD_REQUIRES (__inx < size (),
                      (_RWSTD_ERROR_OUT_OF_RANGE,
                       _RWSTD_FUNC ("array::at(size_type) const"),
                       __inx, size ()));
     return data ()[__inx];
 }


 // array comparisons
 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline bool
 operator== (const array<_TypeT, _Size> &__lhs,
             const array<_TypeT, _Size> &__rhs)
 {
     _RWSTD_ASSERT (__lhs.size () == __rhs.size ());

     return _STD::equal (__lhs.begin (), __lhs.end (), __rhs.begin ());

 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline bool
 operator< (const array<_TypeT, _Size> &__lhs,
            const array<_TypeT, _Size> &__rhs)
 {
     _RWSTD_ASSERT (__lhs.size () == __rhs.size ());

     return _STD::lexicographical_compare (__lhs.begin (), __lhs.end (),
                                           __rhs.begin (), __rhs.end ());
 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline bool
 operator!= (const array<_TypeT, _Size> &__lhs,
             const array<_TypeT, _Size> &__rhs)
 {
     return !(__lhs == __rhs);
 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline bool
 operator> (const array<_TypeT, _Size> &__lhs,
            const array<_TypeT, _Size> &__rhs)
 {
     return __rhs < __lhs;
 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline bool
 operator>= (const array<_TypeT, _Size> &__lhs,
             const array<_TypeT, _Size> &__rhs)
 {
     return !(__lhs < __rhs);
 }


 template <class _TypeT, _RWSTD_SIZE_T _Size>
 inline bool
 operator<= (const array<_TypeT, _Size> &__lhs,
             const array<_TypeT, _Size> &__rhs)
 {
     return !(__rhs <  __lhs);
 }


 // [array.special] -- specialized algorithms
 template <class _TypeT, _RWSTD_SIZE_T _Size >
 inline void
 swap (array<_TypeT, _Size> &__lhs, array<_TypeT, _Size> &__rhs)
 {
     __lhs.swap (__rhs);
 }


 // [array.tuple] -- tuple interface to class template array
 template <class _TypeT>
 class tuple_size;   // defined in <tuple>

 template <int I, class _TypeT>
 class tuple_element;   // defined in <tuple>

 template <class _TypeT, _RWSTD_SIZE_T _Size>
 struct tuple_size<array<_TypeT, _Size> >;

 template <int I, class _TypeT, _RWSTD_SIZE_T _Size>
 struct tuple_element<I, array<_TypeT, _Size> >;

 template <int I, class _TypeT, _RWSTD_SIZE_T _Size>
 _TypeT& get (array<_TypeT, _Size>&);

 template <int I, class _TypeT, _RWSTD_SIZE_T _Size>
 const _TypeT& get (const array<_TypeT, _Size>&);

 }   // namespace std

 #endif   // _RWSTD_ARRAY_INCLUDED
	// -- C++ --
	/***************************************************************************
	*
	* array - definition of class template array
	*
	* $Id$
	*
	***************************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed
	* with this work for additional information regarding copyright
	* ownership. The ASF licenses this file to you under the Apache
	* License, Version 2.0 (the "License"); you may not use this file
	* except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
	* implied. See the License for the specific language governing
	* permissions and limitations under the License.
	*
	* Copyright 1994-2006 Rogue Wave Software.
	*
	**************************************************************************/

	#ifndef _RWSTD_ARRAY_INCLUDED
	#define _RWSTD_ARRAY_INCLUDED

	#include <rw/_defs.h>

	#ifdef _RWSTD_NO_EXT_CXX_0X
	# error _RWSTD_NO_EXT_CXX_0X defined and C++0x header included
	#endif // _RWSTD_NO_EXT_CXX_0X

	#include <rw/_algobase.h>
	#include <rw/_error.h>
	#include <rw/_iterator.h>


	_RWSTD_NAMESPACE (std) {

	// [array] -- class template array
	template <class _TypeT, _RWSTD_SIZE_T _Size>
	struct array
	{
	// types:
	typedef _TypeT value_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef value_type* pointer;
	typedef const value_type* const_pointer;
	typedef _RWSTD_SIZE_T size_type;
	typedef _RWSTD_PTRDIFF_T difference_type;

	#ifndef _RWSTD_NO_DEBUG_ITER

	typedef _RW::__rw_debug_iter <array, pointer, pointer> iterator;

	typedef _RW::__rw_debug_iter <array, const_pointer, pointer> const_iterator;

	iterator _C_make_iter (pointer __ptr) {
	return iterator (*this, __ptr);
	}

	const_iterator _C_make_iter (const_pointer __ptr) const {
	return const_iterator (*this, __ptr);
	}

	#else // if defined (_RWSTD_NO_DEBUG_ITER)

	typedef pointer iterator;
	typedef const_pointer const_iterator;

	iterator _C_make_iter (pointer __ptr) {
	return __ptr;
	}

	const_iterator _C_make_iter (const_pointer __ptr) const {
	return __ptr;
	}

	#endif // _RWSTD_NO_DEBUG_ITER

	typedef _RWSTD_REVERSE_ITERATOR (iterator,
	reference,
	pointer,
	random_access_iterator_tag)
	reverse_iterator;

	typedef _RWSTD_REVERSE_ITERATOR (const_iterator,
	const_reference,
	const_pointer,
	random_access_iterator_tag)
	const_reverse_iterator;

	// No explicit construct/copy/destroy for aggregate type
	void assign (const_reference);
	void swap (array&);

	// iterators:
	iterator begin () {
	return _C_make_iter (data ());
	}

	const_iterator begin () const {
	return _C_make_iter (data ());
	}

	iterator end () {
	return _C_make_iter (data () + size ());
	}

	const_iterator end () const {
	return _C_make_iter (data () + size ());
	}

	reverse_iterator rbegin () {
	return reverse_iterator (end ());
	}

	const_reverse_iterator rbegin () const {
	return const_reverse_iterator (end ());
	}

	reverse_iterator rend () {
	return reverse_iterator (begin ());
	}

	const_reverse_iterator rend () const {
	return const_reverse_iterator (begin ());
	}

	// capacity:
	size_type size () const {
	return _Size;
	}

	size_type max_size () const {
	return _Size;
	}

	bool empty () const {
	return 0 == size ();
	}

	// element access:
	reference operator[] (size_type);
	const_reference operator[] (size_type) const;

	const_reference at (size_type) const;
	reference at (size_type);

	reference front () {
	_RWSTD_ASSERT (!empty ());
	return *data ();
	}

	const_reference front () const {
	_RWSTD_ASSERT (!empty ());
	return *data ();
	}

	reference back () {
	_RWSTD_ASSERT (!empty ());
	return data () [size () - 1];
	}

	const_reference back () const {
	_RWSTD_ASSERT (!empty ());
	return data () [size () - 1];
	}

	pointer data () {
	return _C_elems;
	}

	const_pointer data () const {
	return _C_elems;
	}

	// private: (no public/protected/private in aggregate types)
	value_type _C_elems [_Size];
	};


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline void
	array<_TypeT, _Size>::
	assign (const_reference __val)
	{
	const pointer __end = data () + size ();

	for (pointer __ptr = data (); __ptr != __end; ++__ptr)
	*__ptr = __val;
	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline void
	array<_TypeT, _Size>::
	swap (array<_TypeT, _Size> &__other)
	{
	_RWSTD_ASSERT (size () == __other.size ());

	const array __tmp (*this);
	*this = __other;
	__other = __tmp;
	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline typename array<_TypeT, _Size>::reference
	array<_TypeT, _Size>::
	operator[] (size_type __inx)
	{
	#ifdef _RWSTD_BOUNDS_CHECKING

	_RWSTD_REQUIRES (__inx < size (),
	(_RWSTD_ERROR_OUT_OF_RANGE,
	_RWSTD_FUNC ("array::operator[](size_type)"),
	__inx, size ()));

	#endif // _RWSTD_BOUNDS_CHECKING

	return data ()[__inx];
	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline typename array<_TypeT, _Size>::const_reference
	array<_TypeT, _Size>::
	operator[] (size_type __inx) const
	{
	#ifdef _RWSTD_BOUNDS_CHECKING

	_RWSTD_REQUIRES (__inx < size (),
	(_RWSTD_ERROR_OUT_OF_RANGE,
	_RWSTD_FUNC ("array::operator[](size_type) const"),
	__inx, size ()));

	#endif // _RWSTD_BOUNDS_CHECKING

	return data ()[__inx];
	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline typename array<_TypeT, _Size>::reference
	array<_TypeT, _Size>::
	at (size_type __inx)
	{
	_RWSTD_REQUIRES (__inx < size (),
	(_RWSTD_ERROR_OUT_OF_RANGE,
	_RWSTD_FUNC ("array::at (size_type)"),
	__inx, size ()));

	return data ()[__inx];
	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline typename array<_TypeT, _Size>::const_reference
	array<_TypeT, _Size>::
	at (size_type __inx) const
	{
	_RWSTD_REQUIRES (__inx < size (),
	(_RWSTD_ERROR_OUT_OF_RANGE,
	_RWSTD_FUNC ("array::at(size_type) const"),
	__inx, size ()));
	return data ()[__inx];
	}


	// array comparisons
	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline bool
	operator== (const array<_TypeT, _Size> &__lhs,
	const array<_TypeT, _Size> &__rhs)
	{
	_RWSTD_ASSERT (__lhs.size () == __rhs.size ());

	return _STD::equal (__lhs.begin (), __lhs.end (), __rhs.begin ());

	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline bool
	operator< (const array<_TypeT, _Size> &__lhs,
	const array<_TypeT, _Size> &__rhs)
	{
	_RWSTD_ASSERT (__lhs.size () == __rhs.size ());

	return _STD::lexicographical_compare (__lhs.begin (), __lhs.end (),
	__rhs.begin (), __rhs.end ());
	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline bool
	operator!= (const array<_TypeT, _Size> &__lhs,
	const array<_TypeT, _Size> &__rhs)
	{
	return !(__lhs == __rhs);
	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline bool
	operator> (const array<_TypeT, _Size> &__lhs,
	const array<_TypeT, _Size> &__rhs)
	{
	return __rhs < __lhs;
	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline bool
	operator>= (const array<_TypeT, _Size> &__lhs,
	const array<_TypeT, _Size> &__rhs)
	{
	return !(__lhs < __rhs);
	}


	template <class _TypeT, _RWSTD_SIZE_T _Size>
	inline bool
	operator<= (const array<_TypeT, _Size> &__lhs,
	const array<_TypeT, _Size> &__rhs)
	{
	return !(__rhs < __lhs);
	}


	// [array.special] -- specialized algorithms
	template <class _TypeT, _RWSTD_SIZE_T _Size >
	inline void
	swap (array<_TypeT, _Size> &__lhs, array<_TypeT, _Size> &__rhs)
	{
	__lhs.swap (__rhs);
	}


	// [array.tuple] -- tuple interface to class template array
	template <class _TypeT>
	class tuple_size; // defined in <tuple>

	template <int I, class _TypeT>
	class tuple_element; // defined in <tuple>

	template <class _TypeT, _RWSTD_SIZE_T _Size>
	struct tuple_size<array<_TypeT, _Size> >;

	template <int I, class _TypeT, _RWSTD_SIZE_T _Size>
	struct tuple_element<I, array<_TypeT, _Size> >;

	template <int I, class _TypeT, _RWSTD_SIZE_T _Size>
	_TypeT& get (array<_TypeT, _Size>&);

	template <int I, class _TypeT, _RWSTD_SIZE_T _Size>
	const _TypeT& get (const array<_TypeT, _Size>&);

	} // namespace std

	#endif // _RWSTD_ARRAY_INCLUDED