/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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: 

*

*/

/*

 * cpixmemorytools.h

 *

 *  Created on: 23.4.2009

 *      Author: arau

 */

#ifndef CPIXMEMORYTOOLS_H_

#define CPIXMEMORYTOOLS_H_

#include <list>

#include <vector>

#include <memory>

namespace Cpt

{

    /**

     * Stripped down implementation of the std::vector, 

     * which holds ownership to members and releases the owned instances,

     * when destroyed. 

     */

    template<typename T>

    class auto_vector : public std::vector<T*> {

    private: 

    	// pure copy constructor is not supported.

    	// copy method will empty the given vector from all members

		auto_vector(const auto_vector &vector);

        auto_vector& operator=(const auto_vector &vector);

    public: 

    	// transfers all the objects to 

        auto_vector(auto_vector &vector);

        auto_vector& operator=(auto_vector &vector);

    	auto_vector(); 

    	/**

    	 * Destructor. Destroys all contained members

    	 */

    	~auto_vector(); 

    	/**

    	 * Like push_back, except that it transfers ownership throught auto_ptr

    	 */

    	void donate_back(std::auto_ptr<T> ptr); 

    	/**

    	 * Like pop_back, except that it transfers ownership throught auto_ptr

    	 */

    	std::auto_ptr<T> release_back(); 

    };

    template<typename T>

    class poly_forward_iterator {

    public: 

    	virtual ~poly_forward_iterator() {}

		virtual T operator++(int) = 0; 

		virtual operator bool() = 0;

    };

    template<typename T, typename I>

	class auto_iterator_ref {

	public: 

		auto_iterator_ref(I* p) : p_(p) {} 

		I* p_;

	};

	template<typename T, typename I>

	class auto_iterator {

	public: 

		inline explicit auto_iterator(I* iterator) : iterator_(iterator) {}; 

		inline ~auto_iterator() 			{}

		inline T operator++(int) 			{ return (*iterator_)++; }

		inline operator bool()  			{ return *iterator_; } 

		// special conversions enabling returning as return value

		inline auto_iterator(auto_iterator_ref<T, I> ref) throw()

		  : iterator_(ref.p_) {}

		operator auto_iterator_ref<T, I>() throw() {

			return auto_iterator_ref<T, I>(iterator_.release());

	    }

	private: 

		std::auto_ptr<I> iterator_;

	};

}

/**************************************************************

 *

 *  IMPLEMENTATION OF TEMPLATES

 *

 */

namespace Cpt

{

	template<typename T>

	auto_vector<T>::auto_vector() {}

	template<typename T>

	auto_vector<T>::~auto_vector() 

	{

		for (int i = 0; i < this->size(); i++) delete (*this)[i]; 

	}

	template<typename T>

	auto_vector<T>::auto_vector(auto_vector<T> &vector) 

	{

		// without using fororder, the order would be inversed

		operator=(vector); 

	}

	template<typename T>

	auto_vector<T>& auto_vector<T>::operator=(auto_vector<T> &vector) 

	{

		auto_vector<T> fororder; 

		while (!vector.empty()) fororder.donate_back(vector.release_back()); 

		while (!fororder.empty()) donate_back(fororder.release_back()); 

		return *this;

	}

	/**

	 * Grants the ownership of the item for this vector

	 */

	template<typename T>

	void auto_vector<T>::donate_back(std::auto_ptr<T> ptr) 

	{

		this->push_back(ptr.release()); 

	}

	/**

	 * Releases the ownership of the item

	 */

	template<typename T>

	std::auto_ptr<T> auto_vector<T>::release_back() 

	{

		T* v = this->back();

		std::auto_ptr<T> ret(v); 

		this->pop_back(); 

		return ret;

	}

}

#endif /* CPIXMEMORYTOOLS_H_ */