sl@0: // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: // Class TStreamId
sl@0: inline TStreamId::TStreamId(TUint32 aValue)
sl@0: 	: iVal(aValue)
sl@0: /** Constructs the object with the specified stream ID value.
sl@0: 
sl@0: Users of stores do not normally use this function.
sl@0: 
sl@0: In debug mode, the function checks that the supplied stream ID value is not 
sl@0: greater than the maximum permitted value, and raises a STORE-Store 2 panic 
sl@0: if it is. In release mode, no checking on the supplied value is done.
sl@0: 
sl@0: The checking of the supplied value is done by a private function implemented 
sl@0: in estor. dll. This means that in debug mode, a call is made into estor.dll, 
sl@0: but in release mode it is not.
sl@0: 
sl@0: @param aValue The stream ID value. */
sl@0: 	{
sl@0: #if defined (_DEBUG)
sl@0: 	__DbgChkRange(aValue);
sl@0: #endif
sl@0: 	}
sl@0: inline TBool TStreamId::operator==(TStreamId anId) const
sl@0: /** Equality comparison operator. Use this operator to determine whether this stream 
sl@0: id is equal to the specified stream id.
sl@0: 
sl@0: @param anId The stream id to be compared with this stream id.
sl@0: @return True, if the stream ids are equal; false otherwise */
sl@0: 	{return iVal==anId.iVal;}
sl@0: inline TBool TStreamId::operator!=(TStreamId anId) const
sl@0: /** Inequality comparison operator. Use this operator to determine whether this 
sl@0: stream id is unequal to the specified stream id.
sl@0: 
sl@0: @param anId The stream id to be compared with this stream id.
sl@0: @return True, if the two stream ids are unequal, false otherwise. */
sl@0: 	{return iVal!=anId.iVal;}
sl@0: inline void TStreamId::ExternalizeL(RWriteStream& aStream) const
sl@0: /** Externalises an object of this class to a write stream.
sl@0: 
sl@0: The presence of this function means that the standard templated operator<<() 
sl@0: can be used to externalise objects of this class.
sl@0: 
sl@0: @param aStream Stream to which the object should be externalised. */
sl@0: 	{
sl@0: #if defined (_DEBUG)
sl@0: 	__DbgChkRange(iVal);
sl@0: #endif
sl@0: 	aStream<<iVal;
sl@0: 	}
sl@0: inline TUint32 TStreamId::Value() const
sl@0: /** Gets the stream ID value encapsulated by this object.
sl@0: 
sl@0: @return The stream ID value. */
sl@0: 	{
sl@0: #if defined (_DEBUG)
sl@0: 	__DbgChkRange(iVal);
sl@0: #endif
sl@0: 	return iVal;
sl@0: 	}
sl@0: 
sl@0: // Class RStoreWriteStream
sl@0: inline RStoreWriteStream::RStoreWriteStream(const MExternalizer<TStreamRef>& anExter)
sl@0: 	: RWriteStream(anExter)
sl@0: /** Constructs an object with an externaliser. The store map CStoreMap is an example 
sl@0: of an externalizer.
sl@0: 
sl@0: @param anExter Specifies an externaliser */
sl@0: 	{}
sl@0: 
sl@0: // Class TSwizzleCBase
sl@0: inline TSwizzleCBase::TSwizzleCBase(TStreamRef aRef)
sl@0: 	: iPtr(aRef.Ptr())
sl@0: 	{
sl@0: #if defined (_DEBUG)
sl@0: 	__DbgChkRef(aRef);
sl@0: #endif
sl@0:     }
sl@0: inline TBool TSwizzleCBase::operator==(const TSwizzleCBase& aSwizzle) const
sl@0: /** Compares for equality with another swizzle.
sl@0: 
sl@0: Use this operator to determine whether this swizzle represents the same object 
sl@0: as that represented by the specified swizzle.
sl@0: 
sl@0: Both this swizzle and the specified swizzle must maintain the representation 
sl@0: of their respective objects as either pointers or stream ids.
sl@0: 
sl@0: If one swizzle maintains the representation of its object as a pointer while 
sl@0: the other swizzle maintains the representation of its object as a stream id, 
sl@0: the comparison is meaningless and always returns false.
sl@0: 
sl@0: @param aSwizzle A reference to the swizzle to be compared with this swizzle.
sl@0: @return True, if the represented objects are the same; False, otherwise. */
sl@0: 	{return iPtr==aSwizzle.iPtr;}
sl@0: inline TBool TSwizzleCBase::operator==(const TAny* aPtr) const
sl@0: /** Compares for equality with an in-memory object.
sl@0: 
sl@0: Use this operator to determine whether this swizzle represents the same in-memory 
sl@0: object as that represented by the specified pointer.
sl@0: 
sl@0: This swizzle must maintain the representation of its object as a pointer. 
sl@0: If it maintains the representation of its object as a swizzle, the comparison 
sl@0: is meaningless and always returns false.
sl@0: 
sl@0: @param aPtr A pointer to the object to be compared with this swizzle.
sl@0: @return True, if the represented objects are the same; False, otherwise. */
sl@0: 	{return iPtr==aPtr;}
sl@0: inline TBool TSwizzleCBase::operator!=(const TSwizzleCBase& aSwizzle) const
sl@0: /** Compares for inequality with another swizzle.
sl@0: 
sl@0: Use this operator to determine whether this swizzle represents a different 
sl@0: object to that represented by the specified swizzle.
sl@0: 
sl@0: Both this swizzle and the specified swizzle must maintain the representation 
sl@0: of their respective objects as either pointers or stream ids.
sl@0: 
sl@0: If one swizzle maintains the representation of its object as a pointer while 
sl@0: the other swizzle maintains the representation of its object as a stream id, 
sl@0: the comparison is meaningless and always returns true.
sl@0: 
sl@0: @param aSwizzle A reference to the swizzle to be compared with this swizzle.
sl@0: @return True, if the represented objects are not the same; False, otherwise */
sl@0: 	{return iPtr!=aSwizzle.iPtr;}
sl@0: inline TBool TSwizzleCBase::operator!=(const TAny* aPtr) const
sl@0: /** Compares for inequality with an in-memory object.
sl@0: 
sl@0: Use this operator to determine whether this swizzle represents a different 
sl@0: in-memory object to that represented by the specified pointer.
sl@0: 
sl@0: This swizzle must maintain the representation of its object as a pointer. 
sl@0: If it maintains the representation of its object as a swizzle, the comparison 
sl@0: is meaningless and always returns true.
sl@0: 
sl@0: @param aPtr A pointer to the object to be compared with this swizzle.
sl@0: @return True, if the represented objects are not the same; False, otherwise */
sl@0: 	{return iPtr!=aPtr;}
sl@0: inline TBool TSwizzleCBase::IsPtr() const
sl@0: /** Tests whether this swizzle currently represents an object as a pointer.
sl@0: 
sl@0: @return True, if this swizzle currently maintains the object representation 
sl@0: as a pointer; False, otherwise. Note that if the swizzle is uninitialised, 
sl@0: the value returned by this function is not defined. */
sl@0: 	{return IsPtrRep(iPtr);}
sl@0: inline TBool TSwizzleCBase::IsId() const
sl@0: /** Tests whether this swizzle currently represents an object as a stream id.
sl@0: 
sl@0: @return True, if this swizzle currently maintains the representation of the 
sl@0: object as a stream id; False, otherwise. Note that if the swizzle is uninitialised, 
sl@0: the value returned by this function is not defined. */
sl@0: 	{return IsIdRep(iPtr);}
sl@0: inline TSwizzleCBase::TSwizzleCBase(const TAny* aPtr)
sl@0: 	: iPtr(aPtr)
sl@0: 	{
sl@0: #if defined (_DEBUG)
sl@0: 	__DbgChkPtr(aPtr);
sl@0: #endif
sl@0:     }
sl@0: inline const TAny* TSwizzleCBase::Ptr() const
sl@0: 	{
sl@0: #if defined (_DEBUG)
sl@0: 	__DbgChkPtr(iPtr);
sl@0: #endif
sl@0: 	return iPtr;
sl@0: 	}
sl@0: inline TBool operator==(const TAny* aPtr,const TSwizzleCBase& aSwizzle)
sl@0: 	{return aSwizzle==aPtr;}
sl@0: inline TBool operator!=(const TAny* aPtr,const TSwizzleCBase& aSwizzle)
sl@0: 	{return aSwizzle!=aPtr;}
sl@0: 
sl@0: // Class TSwizzleBase
sl@0: inline TSwizzleBase::TSwizzleBase(TAny* aPtr)
sl@0: 	: TSwizzleCBase(aPtr)
sl@0: 	{}
sl@0: inline TSwizzleBase::TSwizzleBase(TStreamId anId)
sl@0: 	: TSwizzleCBase(anId)
sl@0: 	{}
sl@0: inline TAny* TSwizzleBase::Ptr() const
sl@0: 	{return (TAny*)TSwizzleCBase::Ptr();}
sl@0: 
sl@0: // Template class TSwizzle
sl@0: template <class T>
sl@0: inline TSwizzle<T>::TSwizzle(T* aPtr)
sl@0: 	: TSwizzleBase(aPtr)
sl@0: /** Constructs a swizzle for a class T type object, represented by a pointer.
sl@0: 
sl@0: @param aPtr A pointer to a class T type object. */
sl@0: 	{}
sl@0: template <class T>
sl@0: inline TSwizzle<T>::TSwizzle(TStreamId anId)
sl@0: 	: TSwizzleBase(anId)
sl@0: /** Constructs a swizzle for a class T type object, represented as a stream id.
sl@0: 
sl@0: @param anId The id of a stream containing the external representation of a 
sl@0: class T type object. */
sl@0: 	{}
sl@0: template <class T>
sl@0: inline TSwizzle<T>& TSwizzle<T>::operator=(T* aPtr)
sl@0: /** Sets this swizzle to represent the in-memory type T object, pointed to by the 
sl@0: specified T* pointer.
sl@0: 
sl@0: @param aPtr A pointer to an object of type T which the swizzle is to represent.
sl@0: @return A reference to this swizzle representing the object of type T. */
sl@0: 	{return *this=TSwizzle<T>(aPtr);}
sl@0: template <class T>
sl@0: inline T* TSwizzle<T>::AsPtr() const
sl@0: /** Returns a pointer to the object which this swizzle represents.
sl@0: 
sl@0: Note that the indirect component selector operator->() can be used to access 
sl@0: members of the represented object.
sl@0: 
sl@0: @return A pointer to the class T type object represented by this swizzle. */
sl@0: 	{return (T*)Ptr();}
sl@0: template <class T>
sl@0: inline TSwizzle<T>::operator T*() const
sl@0: 	{return AsPtr();}
sl@0: template <class T>
sl@0: inline T& TSwizzle<T>::operator*() const
sl@0: /** Returns a reference to the type T object which this swizzle represents.
sl@0: 
sl@0: @return A reference to the type T object represented by this swizzle. */
sl@0: 	{return *AsPtr();}
sl@0: template <class T>
sl@0: inline T* TSwizzle<T>::operator->() const
sl@0: /** Gives access to members of the type T object which this swizzle represents.
sl@0: 
sl@0: Note, use the AsPtr() member function to return a pointer to the object itself.
sl@0: 
sl@0: @return A pointer to the T type object; not explicitly accessible. */
sl@0: 	{return AsPtr();}
sl@0: template <class T>
sl@0: inline void TSwizzle<T>::ExternalizeL(RWriteStream& aStream) const
sl@0: /** Externalises the stream id of the stream associated with this swizzle.
sl@0: 
sl@0: This function presupposes that: 
sl@0: 
sl@0: a store map, i.e. an object of type CStoreMap, has been constructed
sl@0: 
sl@0: the id of the stream containing the external representation of the represented 
sl@0: type T object has been bound to this swizzle and added to the store map.
sl@0: 
sl@0: the concrete stream referenced by aStream has been constructed, specifying 
sl@0: the store map as an externaliser.
sl@0: 
sl@0: The presence of this function means that the standard templated operator<<() 
sl@0: can be used.
sl@0: 
sl@0: @param aStream Stream to which the stream id should be externalised.
sl@0: @see CStoreMap */
sl@0: 	{TSwizzleBase::DoExternalizeL(aStream,TExternalizer<T>::Function());}
sl@0: inline TSwizzle<TAny>::TSwizzle(TAny* aPtr)
sl@0: 	: TSwizzleBase(aPtr)
sl@0: /** Constructs the swizzle representing the specified untyped object as a pointer.
sl@0: 	
sl@0: @param aPtr A pointer to an untyped object which this swizzle is to represent. */
sl@0: 	{}
sl@0: inline TSwizzle<TAny>::TSwizzle(TStreamId anId)
sl@0: 	: TSwizzleBase(anId)
sl@0: /** Constructs the swizzle for an untyped object, represented as a stream id.
sl@0: 	
sl@0: @param anId The id of a stream containing the external representation of the 
sl@0: 	untyped object which this swizzle is to represent. */
sl@0: 	{}
sl@0: inline TSwizzle<TAny>::TSwizzle(const TSwizzleBase& aSwizzle)
sl@0: 	: TSwizzleBase(aSwizzle)
sl@0: /** Constructs the swizzle to represent the untyped object currently represented 
sl@0: 	by the specified swizzle.
sl@0: 	
sl@0: @param aSwizzle A reference to a swizzle whose representation of an object 
sl@0: 	is to be copied to this swizzle */
sl@0: 	{}
sl@0: inline TSwizzle<TAny>& TSwizzle<TAny>::operator=(TAny* aPtr)
sl@0: /** Sets this swizzle to represent the in-memory object, pointed to by the specified 
sl@0: 	pointer.
sl@0: 	
sl@0: @param aPtr A pointer to the untyped object which the swizzle is to represent.
sl@0: @return A reference to this swizzle. */
sl@0: 	{return *this=TSwizzle<TAny>(aPtr);}
sl@0: inline TSwizzle<TAny>& TSwizzle<TAny>::operator=(const TSwizzleBase& aSwizzle)
sl@0: 	/** Sets the swizzle to represent the untyped object currently represented by the 
sl@0: 	specified swizzle.
sl@0: 	
sl@0: 	@param aSwizzle The swizzle whose representation of an object is to be copied 
sl@0: 	to this swizzle.
sl@0: 	@return A reference to this swizzle. */
sl@0: 	{return *this=TSwizzle<TAny>(aSwizzle);}
sl@0: inline TAny* TSwizzle<TAny>::AsPtr() const
sl@0: /** Returns a pointer to the untyped object that this swizzle represents.
sl@0: 	
sl@0: 	@return A pointer to the untyped object represented by this swizzle. */
sl@0: 	{return Ptr();}
sl@0: inline TSwizzle<TAny>::operator TAny*() const
sl@0: 	{return AsPtr();}
sl@0: 
sl@0: // Template class TSwizzleC
sl@0: template <class T>
sl@0: inline TSwizzleC<T>::TSwizzleC(const T* aPtr)
sl@0: 	: TSwizzleCBase(aPtr)
sl@0: /** Constructs a swizzle for a class T type object and represents the object by 
sl@0: pointer.
sl@0: 
sl@0: @param aPtr A pointer to a class T type object. */
sl@0: 	{}
sl@0: template <class T>
sl@0: inline TSwizzleC<T>::TSwizzleC(TStreamId anId)
sl@0: 	: TSwizzleCBase(anId)
sl@0: /** Constructs a swizzle for a class T type object and represents the object as 
sl@0: a stream id.
sl@0: 
sl@0: @param anId The stream id of a stream containing the external representation 
sl@0: of an object of type class T. */
sl@0: 	{}
sl@0: template <class T>
sl@0: inline TSwizzleC<T>::TSwizzleC(TSwizzle<T> aSwizzle)
sl@0: 	: TSwizzleCBase(aSwizzle)
sl@0: /** Constructs a swizzle for a class T type object that is currently represented 
sl@0: by another swizzle.
sl@0: 
sl@0: The representation of the class T type object is the same as its representation 
sl@0: by the specified swizzle, i.e. if the specified swizzle represents the object 
sl@0: as a pointer, then this newly constructed swizzle also represents the object 
sl@0: as a pointer.
sl@0: 
sl@0: @param aSwizzle The swizzle whose representation of the class T type object 
sl@0: is to be copied to this swizzle. */
sl@0: 	{}
sl@0: template <class T>
sl@0: inline TSwizzleC<T>& TSwizzleC<T>::operator=(const T* aPtr)
sl@0: /** Sets this swizzle to represent the in-memory type T object, pointed to by the 
sl@0: specified T* pointer.
sl@0: 
sl@0: @param aPtr A pointer to an object of type T which the swizzle is to represent.
sl@0: @return A reference to this swizzle representing the object of type T.
sl@0: @see TSwizzle::operator=() */
sl@0: 	{return *this=TSwizzleC<T>(aPtr);}
sl@0: template <class T>
sl@0: inline const T* TSwizzleC<T>::AsPtr() const
sl@0: /** Returns a constant pointer to the object which this swizzle represents.
sl@0: 
sl@0: Note:
sl@0: 
sl@0: The in memory object cannot be changed through this swizzle.
sl@0: 
sl@0: To access members of the object, the indirect component selector operator->() 
sl@0: can be used.
sl@0: 
sl@0: @return A const pointer to the class T type object represented by this swizzle. */
sl@0: 	{return (const T*)Ptr();}
sl@0: template <class T>
sl@0: inline TSwizzleC<T>::operator const T*() const
sl@0: 	{return AsPtr();}
sl@0: template <class T>
sl@0: inline const T& TSwizzleC<T>::operator*() const
sl@0: /** Returns a const reference to the type T object which this swizzle represents.
sl@0: 
sl@0: @return A const reference to the type T object represented by this swizzle.
sl@0: @see TSwizzle::operator*() */
sl@0: 	{return *AsPtr();}
sl@0: template <class T>
sl@0: inline const T* TSwizzleC<T>::operator->() const
sl@0: /** Gives access to members of the type T object which this swizzle represents.
sl@0: 
sl@0: Note:
sl@0: 
sl@0: use the AsPtr() member function to return a pointer to the object itself.
sl@0: 
sl@0: the type T object cannot be changed through this operator.
sl@0: 
sl@0: @return A const pointer to the T type object; not explicitly accessible.
sl@0: @see TSwizzle::operator->() */
sl@0: 	{return AsPtr();}
sl@0: template <class T>
sl@0: inline void TSwizzleC<T>::ExternalizeL(RWriteStream& aStream) const
sl@0: /** Externalises the stream id of the stream associated with this swizzle.
sl@0: 
sl@0: This function presupposes that: 
sl@0: 
sl@0: a store map, i.e. an object of type CStoreMap, has been constructed
sl@0: 
sl@0: the id of the stream containing the external representation of the <class T> 
sl@0: object has been bound to this swizzle and added to the store map.
sl@0: 
sl@0: the concrete stream referenced by aStream has been constructed, specifying 
sl@0: the store map as an externalizer.
sl@0: 
sl@0: The presence of this function means that the standard templated operator<<() 
sl@0: can be used.
sl@0: 
sl@0: @param aStream Stream to which the stream id should be externalised
sl@0: @see CStoreMap */
sl@0: 	{TSwizzleCBase::DoExternalizeL(aStream,TExternalizer<T>::Function());}
sl@0: inline TSwizzleC<TAny>::TSwizzleC(const TAny* aPtr)
sl@0: 	: TSwizzleCBase(aPtr)
sl@0: /** Constructs the swizzle representing the specified untyped object as a pointer.
sl@0: 	
sl@0: @param aPtr A pointer to an untyped object which this swizzle is to represent. */
sl@0: 	{}
sl@0: inline TSwizzleC<TAny>::TSwizzleC(TStreamId anId)
sl@0: 	: TSwizzleCBase(anId)
sl@0: /** Constructs the swizzle for an untyped object, represented as a stream id.
sl@0: 	
sl@0: @param anId The id of a stream containing the external representation of the 
sl@0: 	untyped object which this swizzle is to represent. */
sl@0: 	{}
sl@0: inline TSwizzleC<TAny>::TSwizzleC(const TSwizzleCBase& aSwizzle)
sl@0: 	: TSwizzleCBase(aSwizzle)
sl@0: /** Constructs the swizzle to represent the untyped object currently represented 
sl@0: 	by the specified swizzle.
sl@0: 	
sl@0: @param aSwizzle The swizzle whose representation of an object is to be copied 
sl@0: 	to this swizzle. */
sl@0: 	{}
sl@0: inline TSwizzleC<TAny>::TSwizzleC(TStreamRef aRef)
sl@0: 	: TSwizzleCBase(aRef)
sl@0: /** Constructs the swizzle from a stream reference.
sl@0: 	
sl@0: @param aRef The stream reference. */
sl@0:  	{}
sl@0: inline TSwizzleC<TAny>& TSwizzleC<TAny>::operator=(const TAny* aPtr)
sl@0: /** Sets this swizzle to represent the specified in-memory untyped object.
sl@0: 	
sl@0: @param aPtr A pointer to the untyped object that the swizzle is to represent.
sl@0: @return A reference to this swizzle representing the untyped object. */
sl@0: 	{return *this=TSwizzleC<TAny>(aPtr);}
sl@0: inline TSwizzleC<TAny>& TSwizzleC<TAny>::operator=(const TSwizzleCBase& aSwizzle)
sl@0: /** Sets this swizzle to represent the untyped object currently represented by the 
sl@0: 	specific swizzle.
sl@0: 	
sl@0: @param aSwizzle A pointer to the untyped object that the swizzle is to represent.
sl@0: @return A reference to a swizzle whose representation of an object is to be 
sl@0: 	copied to this swizzle. */
sl@0: 	{return *this=TSwizzleC<TAny>(aSwizzle);}
sl@0: inline const TAny* TSwizzleC<TAny>::AsPtr() const
sl@0: /** Gets a constant pointer to the untyped object that this swizzle represents.
sl@0: 	
sl@0: @return A const pointer to the untyped object represented by this swizzle. */
sl@0: 	{return Ptr();}
sl@0: inline TSwizzleC<TAny>::operator const TAny*() const
sl@0: 	{return AsPtr();}
sl@0: