/*
* Copyright (c) 2005-2008 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: Class template for constant size arrays.
*
*/
/*
* %version: 8 %
*/
#ifndef _CARRAY_H
#define _CARRAY_H
/*
*
* The following code declares class array,
* an STL container (as wrapper) for arrays of constant size.
*
* compile time modifiable polies:
* - to call delete or not to 4 members of array
* - copy ctor and assignment operator policies; see umaccarraypolicy.h
*/
#include "algorithm.h"
typedef TUint size_t;
#include "umactypemanip.h"
#include "umaccarraypolicy.h"
template
<
class T,
size_t the_size,
bool deletepointees = EFalse, // call delete or not 4 members of array
class CopyingPolicy = ShallowCopy<T>, // check out policyCarray.h 4 these
class HeapAllocationPolicy = OpNewAlloc // our allocation policy 4 a heap allocated Carray
>
class Carray : protected CopyingPolicy,
public HeapAllocationPolicy
{
typedef Carray<T, the_size, deletepointees, CopyingPolicy, HeapAllocationPolicy> Self;
private:
T v[the_size];
// compile time function selectives
void delete_pointees( Int2Type<ETrue> );
void delete_pointees( Int2Type<EFalse> ) {};
public:
// type definitions
typedef T value_type;
typedef T* iterator;
typedef const T* const_iterator;
typedef T& reference;
typedef const T& const_reference;
typedef size_t size_type;
typedef size_t TUint;
// default constructor
Carray() {};
// construct with inital data
// do not allow to be used in explicit conversations
explicit
Carray(T* p) { copy(p, p + the_size, begin()); }
~Carray() { delete_pointees( Int2Type<deletepointees>() ); }
// iterator support
iterator begin() {return v;}
const_iterator begin() const {return v;}
iterator end() {return v + the_size;}
const_iterator end() const {return v + the_size;}
// size is constant
size_type size() const {return the_size;}
size_type max_size() const {return the_size;}
// direct element access
reference operator[](size_t i) {return v[i];}
const_reference operator[](size_t i) const {return v[i];}
// front() and back()
reference front() {return v[0]; }
const_reference front() const {return v[0]; }
reference back() {return v[the_size-1]; }
const_reference back() const {return v[the_size-1];}
//swap
void swap(Self& r) { swap_ranges(begin(), end(), r.begin()); }
// conversion to ordinary array
const T* data() const {return v;}
T* data() {return v;}
// assignment
Self& operator=(const Self&);
// copy ctor
Carray(const Self& o)
{ Copy(const_cast<iterator>(o.begin()), const_cast<iterator>(o.end()), begin()); }
};
template<class T, size_t the_size, bool deletepointees,
class CopyingPolicy, class HeapAllocationPolicy>
inline
void Carray<T, the_size, deletepointees, CopyingPolicy,
HeapAllocationPolicy>::delete_pointees(Int2Type<ETrue>)
{
for( size_t i = 0 ; i < size() ; ++i )
{
delete v[i];
}
}
// asignment operator
template<class T, size_t the_size, bool deletepointees, class CopyingPolicy, class HeapAllocationPolicy>
inline
Carray<T, the_size, deletepointees, CopyingPolicy, HeapAllocationPolicy>&
Carray<T, the_size, deletepointees, CopyingPolicy, HeapAllocationPolicy>::operator=(const Self& o)
{
// use policy chosen at compile time
Copy(const_cast<iterator>(o.begin()), const_cast<iterator>(o.end()), begin());
return (*this);
}
// comparisons
template<class T, size_t the_size, bool deletepointees, class CopyingPolicy, class HeapAllocationPolicy>
inline
bool operator == (const Carray<T, the_size, deletepointees, CopyingPolicy, HeapAllocationPolicy>& x,
const Carray<T, the_size, deletepointees, CopyingPolicy, HeapAllocationPolicy>& y)
{
return equal(x.begin(), x.end(), y.begin());
}
// global swap()
template<class T, size_t the_size, bool deletepointees, class CopyingPolicy, class HeapAllocationPolicy>
inline void swap (Carray<T, the_size, deletepointees, CopyingPolicy, HeapAllocationPolicy>& x,
Carray<T, the_size, deletepointees, CopyingPolicy, HeapAllocationPolicy>& y)
{
x.swap(y);
}
#endif //_CARRAY_H