/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:   wrapper on top of C array with C++ STL interface
*
*/

/*
* %version: 3 %
*/

#ifndef WLANCARRAY_H
#define WLANCARRAY_H

#include "algorithm.h"

#include "osacarraypolicy.h"

/**
 *  wrapper on top of C array with C++ STL interface
 *
 *
 *  @lib wlanosa.lib
 *  @since S60 v3.2
 */
template
<
    class T, 
    TInt the_size,
    // check out osacarraypolicy.h 4 these
    class CopyingPolicy = NoCopy<T>
> 
class Carray : protected CopyingPolicy, public DBase
    {

	typedef Carray<T, the_size, CopyingPolicy> Self;

public:

	// type definitions
	typedef T		    value_type;
	typedef T*		    iterator;
	typedef const T*	const_iterator;
	typedef T&		    reference;
	typedef const T&	const_reference;
	typedef TInt	    size_type;
	
    /**
     * Constructor.
     *
     * @since S60 v3.2
     */
	Carray() {};

    /**
     * Constructor. Construct with inital data
     *
     * @since S60 v3.2
     * @param aP initial data
     */
	explicit inline Carray( T* aP ) { copy( aP, aP + the_size, begin()); }

    /**
     * returns iterator to begin of the sequence
     *
     * @since S60 v3.2
     * @return iterator to begin of the sequence
     */
    inline iterator begin() { return v; }

    /**
     * returns const iterator to begin of the sequence
     *
     * @since S60 v3.2
     * @return const iterator to begin of the sequence
     */
    inline const_iterator begin() const { return v; }

    /**
     * returns iterator to end of the sequence
     *
     * @since S60 v3.2
     * @return iterator to end of the sequence
     */
    inline iterator end() { return v + the_size; }

    /**
     * returns const iterator to end of the sequence
     *
     * @since S60 v3.2
     * @return const iterator to end of the sequence
     */
    inline const_iterator end() const { return v + the_size; }

    /**
     * returns size of the storage
     *
     * @since S60 v3.2
     * @return size of the storage
     */
    inline size_type size() const { return the_size; }

    /**
     * returns max size of the storage
     *
     * @since S60 v3.2
     * @return max size of the storage
     */
    inline size_type max_size() const { return the_size; }

    /**
     * non const [] operator access
     *
     * @since S60 v3.2
     * @return non const reference to element
     */
    inline reference operator[](TInt i) { return v[i]; } 

    /**
     * const [] operator access
     *
     * @since S60 v3.2
     * @return const reference to element
     */
    inline const_reference operator[](TInt i) const { return v[i]; } 

    /**
     * return non const reference to front of sequence
     *
     * @since S60 v3.2
     * @return non const reference to front of sequence
     */
    inline reference front() { return v[0]; }

    /**
     * return const reference to front of sequence
     *
     * @since S60 v3.2
     * @return const reference to front of sequence
     */
    inline const_reference front() const { return v[0]; }

    /**
     * return non const reference to back of sequence
     *
     * @since S60 v3.2
     * @return non const reference to back of sequence
     */
    inline reference back() { return v[the_size-1]; }

    /**
     * return const reference to back of sequence
     *
     * @since S60 v3.2
     * @return const reference to back of sequence
     */
    inline const_reference back() const { return v[the_size-1]; }

    /**
     * conversion to ordinary array
     *
     * @since S60 v3.2
     * @return const pointer to begin of the sequence
     */
    inline const T* data() const { return v; }

    /**
     * conversion to ordinary array
     *
     * @since S60 v3.2
     * @return non const pointer to begin of the sequence
     */
    inline T* data() { return v; }

    /**
     * assignment operator
     *
     * @since S60 v3.2
     */
	Self& operator=( const Self& );

    /**
     * copy constructor
     *
     * @since S60 v3.2
     */
    inline Carray( const Self& o ) 
        { 
        Copy( 
            const_cast<iterator>(o.begin()), 
            const_cast<iterator>(o.end()), 
            begin() ); 
        }

private:

	T v[the_size];
};

#include "osacarray.inl"

#endif // WLANCARRAY_H