+The implementation of the family of operators operator<<() calls
+the internal Symbian platform function DoExternalizeL().
+There are two variants of this function distinguished by the value of the
+third parameter as either Externalize::Member or Externalize::Function.
+The family of operators operator<<() are implemented
+as follows:
+template <class T>
+inline RWriteStream& operator<<(RWriteStream& aStream,const T& anObject)
+ {
+ DoExternalizeL(anObject,aStream,Externalization(&anObject));
+ return aStream;
+ }
+The two variants of DoExternalizeL() are defined and implemented
+as:
+template <class T>
+inline void DoExternalizeL(const T& anObject,RWriteStream& aStream,Externalize::Member)
+ {anObject.ExternalizeL(aStream);}
+template <class T>
+inline void DoExternalizeL(const T& anObject,RWriteStream& aStream,Externalize::Function)
+ {ExternalizeL(anObject,aStream);}
+The variant called depends on the value returned from a call to the internal
+selector function, Externalization(). This selector function
+returns either Externalize::Function or Externalize::Member,
+depending on the type of anObject.
+The internal selector function Externalization() is a
+convenience mechanism that allows the operator<<() to
+call either the ExternalizeL() member function of a templated
+class or an ExternalizeL() templated global function.
+The store framework defines and implements a default selector function,
+prototyped as:
+Externalize::Member Externalization(const TAny*)
+By default, a call to Externalization() passing a parameter
+of general class type, is resolved at compile time into a call to this variant,
+and the return type is Externalize::Member. The store framework
+also defines and implements a number of other variants that take more specific
+argument types; for example, as part of its implementation of operator<<() for
+descriptors, the framework defines and implements:
+Externalize::Function Externalization(const TDesC8*)
+