/*

* Copyright (c) 2007-2009 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: 

* Note: This file may contain code to generate corrupt files for test purposes.

* Such code is excluded from production builds by use of compiler defines;

* it is recommended that such code should be removed if this code is ever published publicly.

* smart pointers; used as elements in SIS arrays and elsewhere

*

*/

/**

 @file 

 @internalComponent

 @released

*/

#ifndef __ELEMENT_H__

#define __ELEMENT_H__

#include <string>

#include <iostream>

#include "sharedcount.h"

template<class T> struct shared_ptr_traits

	{

	typedef T& reference;

	};

template<> struct shared_ptr_traits<void>

	{

	typedef void reference;

	};

template <class T> class CElement

	{

public:

	typedef T*											TPtr;

	typedef typename shared_ptr_traits<T>::reference	TRef;

	CElement ();

	template <class Y> explicit CElement (Y* ay) :

			iPtr (ay), 

			iCount (ay)									{ } 

	template <class Y>

	CElement& operator = (CElement<Y> const& r)

		{

		iPtr = r.iPtr;

		iCount = r.iCount;

		return *this;

		}

	template <class Y> void reset (Y* ay)

		{

		assert (ay == 0 || ay != iPtr);	// can't self reset

		this_type (ay).swap (*this);

		}

	template <class Y>

	bool _internal_less (CElement<Y> const& rhs) const

		{

		return iCount < rhs.iCount;

		}

	void reset ();

	TRef operator* () const

		{

		assert (iPtr != NULL);

		return *iPtr;

		}

	T* operator -> () const;

	T* get () const;

	bool operator! () const;

	long UseCount () const;

	void swap (CElement<T>& aOther);

	void Verify (const TUint32 aLanguages) const;

	TUint32 ByteCount (const bool aInArray) const;

	bool WasteOfSpace () const;

	void MakeNeat ();

	std::string Name () const;

	void Dump (std::ostream& aStream, const int aLevel) const;

	TUint32 ByteCountWithHeader (const bool aInArray) const;

	void CalculateCrc (TCRC& aCRC, const bool aIsArrayElement) const;

	std::string NoteIfOptional () const;

#ifdef GENERATE_ERRORS

	virtual void CreateDefects ();

#endif // GENERATE_ERRORS

	void SkipOldWriteNew (TSISStream& aFile) const;

private:

	T*				iPtr;

	CSharedCount	iCount;

	};

template <class T> inline CElement <T>::CElement () :

		iPtr (NULL) 

	{ 

	}

template<class T> inline void CElement <T>::reset ()

	{ 

	this_type ().swap (*this);

	}

template<class T> T* CElement <T>::operator -> () const

	{

	assert (iPtr != NULL);

	return iPtr;

	}

template<class T> inline T* CElement <T>::get () const

	{ 

	return iPtr; 

	}

template<class T> inline bool CElement <T>::operator! () const

	{

	return iPtr == 0;

	}

template<class T> inline long CElement <T>::UseCount () const

	{ 

	return iCount.UseCount (); 

	}

template<class T> inline void CElement <T>::swap (CElement<T>& aOther)

	{

	std::swap (iPtr, aOther.iPtr);

	iCount.swap (aOther.iCount);

	}	

template<class T> inline

		void CElement <T>::Verify (const TUint32 aLanguages) const

	{ 

	iPtr -> Verify (aLanguages); 

	}

template<class T> inline TUint32 CElement <T>::ByteCount (const bool aInArray) const

	{ 

	return iPtr -> ByteCount (aInArray);

	}

template<class T> inline bool CElement <T>::WasteOfSpace () const

	{

	return iPtr -> WasteOfSpace ();

	}

template<class T> inline void CElement <T>::MakeNeat ()

	{

	iPtr -> MakeNeat (); 

	}

template<class T> inline std::string CElement <T>::Name () const

	{

	return iPtr -> Name (); 

	}

template<class T> inline

		void CElement <T>::Dump (std::ostream& aStream, const int aLevel) const

	{

	iPtr -> Dump (aStream, aLevel);

	}

template<class T> inline

		TUint32 CElement <T>::ByteCountWithHeader (const bool aInArray) const

	{

	return iPtr -> ByteCountWithHeader (aInArray);

	}

template <class T> inline

		void CElement <T>::CalculateCrc (TCRC& aCRC, const bool aIsArrayElement) const

	{

	iPtr -> CalculateCrc (aCRC, aIsArrayElement);

	}

template <class T> inline std::string CElement <T>::NoteIfOptional () const

	{

	return iPtr -> NoteIfOptional ();

	}

#ifdef GENERATE_ERRORS

template <class T> inline void CElement <T>::CreateDefects ()

	{

	iPtr -> CreateDefects ();

	}

#endif // GENERATE_ERRORS

template <class T> inline void CElement <T>::SkipOldWriteNew (TSISStream& aFile) const

	{

	iPtr -> SkipOldWriteNew (aFile);

	}

template <class T, class U> inline bool operator == (CElement<T> const& a, CElement<U> const& b)

	{

	return a.get () == b.get ();

	}

template<class T, class U> inline bool operator != (CElement<T> const& a, CElement<U> const& b)

	{

	return a.get () != b.get ();

	}

template<class T, class U> inline bool operator < (CElement<T> const& a, CElement<U> const& b)

	{

	return a._internal_less (b);

	}

template<class T> inline void swap (CElement<T>& a, CElement<T>& b)

	{

	a.swap (b);

	}

template<class T> inline T* get_pointer (CElement<T> const& p)

	{

	return p.get ();

	}

#endif // __ELEMENT_H__