/*

* Copyright (c) 2005-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:   Policies for constant size arrays class template 

*                (see umaccarray.h). 

*

*/

/*

* %version: 10 %

*/

#ifndef _POLICYCARRAY_H

#define _POLICYCARRAY_H

/*

 *

 * Copy ctor and assignment operator policies 4 Carray

 *

 * @usage examples:

 *

 *       Carray<int* , 2, true, DeepCopy<int> > obj;

 *       Carray<int* , 2, true, DeepCopy<int> > obj2;

 *       obj[0] = new int(1);

 *       obj[1] = new int(2); 

 *       // test deep copy

 *       Carray<int* , 2, true, DeepCopy<int> > obj6(obj);

 *       // test deep assignment

 *       obj2 = obj6;

 *

 *       Carray<int , 2> obj3;

 *       Carray<int , 2> obj4;

 *       obj3[0] = 1;

 *       obj3[1] = 2;

 *       // test shallow copy

 *       Carray<int , 2> obj5(obj3);

 *       // test shallow assignment

 *      obj4 = obj3;

 *

 *       Carray<clonable* , 2, true, CloneCopy<clonable> > obj7;

 *       Carray<clonable* , 2, true, CloneCopy<clonable> > obj9;

 *       obj7[0] = new clonable(1);

 *       obj7[1] = new clonable(2);

 *       // test clone copy

 *       Carray<clonable* , 2, true, CloneCopy<clonable> > obj8(obj7);

 *       // test clone assignment

 *       obj9 = obj7;

 *

 *       Carray<int , 2, false, NoCopy<int> > obj10;

 *       Carray<int , 2, false, NoCopy<int> > obj11;

 *       // does not compile as it should not

 *       obj10 = obj11;

 */

#include "algorithm.h"

// normal shallow copy

template <class T>

struct ShallowCopy

{

typedef T* iterator;

        static void Copy(iterator srcbegin, iterator srcend, iterator trgbegin)

        {

                copy(srcbegin, srcend, trgbegin);

        }

};

// calls Clone() 4 copy

template <class T>

struct CloneCopy

{

typedef T** iterator;

        static void Copy(iterator srcbegin, iterator srcend, iterator trgbegin)

        {

                while(srcbegin != srcend)

                {

                        *trgbegin = (*srcbegin)->Clone();

                        ++srcbegin;

                        ++trgbegin;

                }

        }

};

// just what name states copying and assignment are not allowed

template <class T>

struct NoCopy {};

// global new and delete operators

struct OpNewAlloc

{

        static void* operator new(size_t size)

        {

                return ::operator new(size);

        }

        static void operator delete(void* p , size_t /*size*/)

        {

                ::operator delete(p);

        }

};

#endif //_POLICYCARRAY_H