| const TLitC8< sizeof("http:const static TLitC8<sizeof( "http:const static TLitC8< sizeof("Header")> KSenSoapEnvelopeHeaderName={sizeof("Header")-1,"Header"};const static TLitC8< sizeof("S:Header")> KSenSoapEnvelopeHeaderQName={sizeof("S:Header")-1,"S:Header"};const static TLitC8< sizeof("Body")> KSenSoapEnvelopeBodyName={sizeof("Body")-1,"Body"};const static TLitC8< sizeof("S:Body")> KSenSoapEnvelopeBodyQName={sizeof("S:Body")-1,"S:Body"};const static TLitC8< sizeof("Fault")> KSenSoapFaultName={sizeof("Fault")-1,"Fault"};const static TLitC8< sizeof("SOAPAction")> KSenSoapActionHeaderName={sizeof("SOAPAction")-1,"SOAPAction"};const static TLitC8< sizeof("\"\"")> KSenSoapActionHeaderValueEmpty={sizeof("\"\"")-1,"\"\""};const static TLitC8< sizeof("Security")> KSecurityName={sizeof("Security")-1,"Security"};const static TLitC8< sizeof("BinarySecurityToken")> KBinarySecurityToken={sizeof("BinarySecurityToken")-1,"BinarySecurityToken"};const static TLitC8< sizeof("http:const static TLitC8<sizeof( "http:const static TLitC8< sizeof("wsse")> KSecurityXmlNsPrefix={sizeof("wsse")-1,"wsse"};const static TLitC8< sizeof("Type")> KSecurityAttrType={sizeof("Type")-1,"Type"};const static TLitC8< sizeof("PasswordText")> KSecurityAttrTypeText={sizeof("PasswordText")-1,"PasswordText"};const static TLitC8< sizeof("PasswordDigest")> KSecurityAttrTypeDigest={sizeof("PasswordDigest")-1,"PasswordDigest"};const static TLitC8< sizeof("SecurityTokenReference")> KSecurityTokenReference={sizeof("SecurityTokenReference")-1,"SecurityTokenReference"};const static TLitC8< sizeof("http:const static TLitC8<sizeof( "wsu" )> KSecurityUtilityXmlNsPrefix ={sizeof( "wsu" )-1, "wsu" };const static TLitC8<sizeof( "Id" )> KSecurityUtilityId ={sizeof( "Id" )-1, "Id" };const static TLitC8<sizeof( "wsu:Id" )> KSecurityUtilityWsuId ={sizeof( "wsu:Id" )-1, "wsu:Id" };const TInt KStateParsingSoapHeader = 20; const TInt KStateParsingSoapBody = 40; const TInt KStateParsingSoapFault = 5; const static TLitC8<sizeof( "faultcode" )> KFaultCodeLocalname ={sizeof( "faultcode" )-1, "faultcode" }; const static TLitC8<sizeof( "faultstring" )> KFaultStringLocalname ={sizeof( "faultstring" )-1, "faultstring" }; const static TLitC8<sizeof( "faultactor" )> KFaultActorLocalname ={sizeof( "faultactor" )-1, "faultactor" }; const static TLitC8<sizeof( "detail" )> KDetailLocalname ={sizeof( "detail" )-1, "detail" }; const static TLitC8<sizeof( "Code" )> KFault12CodeLocalname ={sizeof( "Code" )-1, "Code" }; const static TLitC8<sizeof( "Subcode" )> KFault12SubcodeLocalname ={sizeof( "Subcode" )-1, "Subcode" }; const static TLitC8<sizeof( "Value" )> KFault12ValueLocalname ={sizeof( "Value" )-1, "Value" }; const static TLitC8<sizeof( "Reason" )> KFault12ReasonLocalname ={sizeof( "Reason" )-1, "Reason" }; const static TLitC8<sizeof( "Text" )> KFault12TextLocalname ={sizeof( "Text" )-1, "Text" }; const static TLitC8<sizeof( "Node" )> KFault12NodeLocalname ={sizeof( "Node" )-1, "Node" }; const static TLitC8<sizeof( "Detail" )> KFault12DetailLocalname ={sizeof( "Detail" )-1, "Detail" }; const static TLitC8<sizeof( "DataEncodingUnknown" )> KDataEncodingUnknown ={sizeof( "DataEncodingUnknown" )-1, "DataEncodingUnknown" }; const static TLitC8<sizeof( "MustUnderstand" )> KMustUnderstand ={sizeof( "MustUnderstand" )-1, "MustUnderstand" }; const static TLitC8<sizeof( "Receiver" )> KReceiver ={sizeof( "Receiver" )-1, "Receiver" }; const static TLitC8<sizeof( "Sender" )> KSender ={sizeof( "Sender" )-1, "Sender" }; const static TLitC8<sizeof( "VersionMismatch" )> KVersionMismatch ={sizeof( "VersionMismatch" )-1, "VersionMismatch" }; enum TSOAPVersion { ESOAP11 = 1, ESOAP12 };# 32 "x:/epoc32/include/mw/SenSoapEnvelope2.h" 2# 1 "x:/epoc32/include/mw/MSenMessage.h" 1#define M_SEN_MESSAGE_Hclass CSenElement;class CSenXmlReader;class MSenMessageContext;class MSenProperties;class MSenMessage { public: enum TClass { EMessageBase = 0, EHttpGetMsg = 1, EHttpPostMsg = 2, EHttpPutMsg = 3, EHttpDeleteMsg = 4, ESoapEnvelope = 5, ESoapMessage = 6, ESoapEnvelope2 = 7, ESoapMessage2 = 8, ESoapMessageDom2 = 9, EAtomMessage = 10 }; enum TDirection { EOutbound = 0, EInbound = 1 }; virtual TClass Type() = 0; virtual TDirection Direction() = 0; virtual TInt SetContext(MSenMessageContext* apNotOwnedContext) = 0; virtual MSenMessageContext* Context() = 0; virtual TInt SetProperties(MSenProperties* apOwnedProperties) = 0; virtual MSenProperties* Properties() = 0; virtual TBool IsSafeToCast(TClass aType) = 0; virtual TInt TxnId() = 0; virtual MSenMessage* CloneL() = 0; };# 33 "x:/epoc32/include/mw/SenSoapEnvelope2.h" 2class CSenSoapFault2;class CSenTransportProperties;class CSenMessageContext;class MSenMessageContext;class CSenSoapEnvelope2 : public CSenFragmentBase, public MSenMessage { public: IMPORT_C static CSenSoapEnvelope2* NewL(); IMPORT_C static CSenSoapEnvelope2* NewLC(); IMPORT_C static CSenSoapEnvelope2* NewL(MSenMessageContext& aContext); IMPORT_C static CSenSoapEnvelope2* NewLC(MSenMessageContext& aContext); IMPORT_C static CSenSoapEnvelope2* NewL(CSenSoapEnvelope2& aEnvelope); IMPORT_C static CSenSoapEnvelope2* NewLC(CSenSoapEnvelope2& aEnvelope); IMPORT_C virtual ~CSenSoapEnvelope2(); IMPORT_C virtual TPtrC8 SetBodyL(const TDesC8& aBody); IMPORT_C virtual TXmlEngElement SetBodyL(TXmlEngElement aBodyElement); IMPORT_C virtual TXmlEngElement BodyL(); IMPORT_C virtual TXmlEngElement HeaderL(); IMPORT_C virtual TXmlEngElement AddHeaderL(TXmlEngElement aHeaderElement); IMPORT_C virtual HBufC8* BodyAsStringL(); IMPORT_C virtual TBool IsFault(); IMPORT_C virtual CSenSoapFault2* DetachFaultL(); IMPORT_C virtual CSenSoapFault2* FaultL(); IMPORT_C virtual TPtrC8 SetSoapActionL(const TDesC8& aSoapAction); IMPORT_C virtual TPtrC8 SoapAction(); IMPORT_C TBool HasHeader(); IMPORT_C TBool HasBody(); IMPORT_C virtual TSOAPVersion SoapVersion(); public: IMPORT_C virtual TClass Type(); IMPORT_C virtual TDirection Direction(); IMPORT_C virtual TInt SetContext(MSenMessageContext* apOwnedContext); IMPORT_C virtual MSenMessageContext* Context(); IMPORT_C virtual TInt SetProperties(MSenProperties* apOwnedProperties); IMPORT_C virtual MSenProperties* Properties(); IMPORT_C virtual TBool IsSafeToCast(TClass aType); IMPORT_C virtual TInt TxnId(); IMPORT_C virtual MSenMessage* CloneL(); protected: CSenSoapEnvelope2(); IMPORT_C void BaseConstructL(TSOAPVersion aVersion); IMPORT_C void BaseConstructL(); IMPORT_C void BaseConstructL(MSenMessageContext& aMessage); IMPORT_C void BaseConstructL(MSenMessageContext& aMessage, TSOAPVersion aVersion); IMPORT_C void BaseConstructL(CSenSoapEnvelope2& aEnvelope); IMPORT_C virtual void ParseHeaderL(const RTagInfo& aElement, const RAttributeArray& aAttributes); IMPORT_C virtual void OnStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode); IMPORT_C virtual void OnEndElementL(const RTagInfo& aElement, TInt aErrorCode); IMPORT_C virtual CSenFragmentBase* CreateBodyFragmentL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aPrefix, const RAttributeArray& aAttributes, TXmlEngElement& aParent, RSenDocument& aOwnerDocument); protected: CSenFragmentBase* ipBodyFragment; CSenFragmentBase* ipHeaderFragment; HBufC8* ipSoapAction; TInt iTransactionId; MSenProperties* ipProperties; MSenMessageContext* ipNotOwnedContext; TAny* ipReserved; TBool iFault; TDirection iDirection; };# 33 "x:/sf/mw/websrv/webservices/wsmessages/src/sensoapenvelope2.cpp" 2# 1 "x:/epoc32/include/mw/SenSoapFault2.h" 1#define SEN_SOAP_FAULT_Hclass CSenSoapFault2 : public CSenDomFragmentBase { public: IMPORT_C static CSenSoapFault2* NewL(TXmlEngElement& aElement); IMPORT_C static CSenSoapFault2* NewL(TXmlEngElement& aElement, RSenDocument& aDocument); IMPORT_C static CSenSoapFault2* NewL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aPrefix, const RAttributeArray& aAttributes, TXmlEngElement& aElement, RSenDocument& aDocument); IMPORT_C virtual ~CSenSoapFault2(); IMPORT_C TPtrC8 FaultCode(); IMPORT_C TPtrC8 FaultSubcode(); IMPORT_C TPtrC8 FaultString(); IMPORT_C TPtrC8 FaultActor(); IMPORT_C TPtrC8 Detail(); protected: IMPORT_C CSenSoapFault2(); IMPORT_C void ConstructL(TXmlEngElement& aElement); IMPORT_C void ConstructL(TXmlEngElement& aElement, RSenDocument& aDocument); IMPORT_C void ConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aPrefix, const RAttributeArray& aAttributes, TXmlEngElement& aElement, RSenDocument& aDocument); };# 34 "x:/sf/mw/websrv/webservices/wsmessages/src/sensoapenvelope2.cpp" 2# 1 "x:/sf/mw/websrv/webservices/wsframework/inc/senlayeredtransportproperties.h" 1#define SEN_LAYERED_TRANSPORT_PROPERTIES_H# 1 "x:/sf/mw/websrv/webservices/wsframework/inc/senlayeredxmlproperties.h" 1#define SEN_LAYERED_XML_PROPERTIES_H# 1 "x:/epoc32/include/mw/SenDomFragment.h" 1#define SEN_DOM_FRAGMENT_H# 1 "x:/epoc32/include/mw/SenBaseFragment.h" 1#define SEN_BASE_FRAGMENT_H# 1 "x:/epoc32/include/mw/MSenContentHandlerClient.h" 1#define __MSENCONTENTHANDLERCLIENT_Husing namespace Xml;class MSenContentHandlerClient { public: virtual TInt StartDocument() = 0; virtual TInt EndDocument() = 0; inline virtual TInt StartElement( const TDesC8& , const TDesC8& , const TDesC8& , const RAttributeArray& ) { return KErrNotSupported; } inline virtual TInt EndElement( const TDesC8& , const TDesC8& , const TDesC8& ) { return KErrNotSupported; } inline virtual TInt Characters(const TDesC8& , const TInt , const TInt ) { return KErrNotSupported; } inline virtual TInt ProcessingInstructions(const TDesC8& , const TDesC8& ) { return KErrNotSupported; } inline virtual TInt SkippedEntity(const TDesC8& ) { return KErrNotSupported; } inline virtual TInt Error(TInt ) { return KErrNotSupported; } inline virtual TInt StartPrefixMappingL( const TDesC8& , const TDesC8& ) { return KErrNotSupported; } inline virtual TInt EndPrefixMappingL(const TDesC8& ) { return KErrNotSupported; } inline virtual TInt OnIgnorableWhiteSpaceL(const TDesC8& ) { return KErrNotSupported; } inline virtual TAny* GetExtendedInterface(const TInt32 ) { return NULL; } }; # 29 "x:/epoc32/include/mw/SenBaseFragment.h" 2# 1 "x:/epoc32/include/mw/SenElement.h" 1#define SEN_ELEMENT_H# 1 "x:/epoc32/include/mw/MSenElement.h" 1#define M_SEN_ELEMENT_Hclass CSenElement;class CSenBaseAttribute;class CSenNamespace;using namespace Xml;class MSenElement { public: virtual const TDesC8& LocalName() const = 0; virtual const TDesC8& NamespaceURI() const = 0; virtual void SetNamespaceL(const TDesC8& aNsUri) = 0; virtual void SetNamespaceL( const TDesC8& aNsPrefix, const TDesC8& aNsUri) = 0; virtual const CSenNamespace* AddNamespaceL( const TDesC8& aPrefix, const TDesC8& aUri) = 0; virtual const CSenNamespace* AddNamespaceL( CSenNamespace& aNewNamespace, TBool aCheckInParent) = 0; virtual const CSenNamespace* Namespace() = 0; virtual const CSenNamespace* Namespace( const TDesC8& aNsPrefix) = 0; virtual const CSenNamespace* Namespace( const TDesC8& aNsPrefix, const TDesC8& aUri) = 0; virtual const CSenNamespace* Namespace( const TDesC8& aNsPrefix, const TBool aCheckInParent) = 0; virtual const TDesC8& NsPrefix() const = 0; virtual void SetPrefixL(const TDesC8& aPrefix) = 0; virtual TBool HasContent() const = 0; virtual TPtrC8 Content() const = 0; virtual HBufC* ContentUnicodeL() const = 0; virtual TPtrC8 SetContentL(const TDesC8& aContent) = 0; virtual RWriteStream& ContentWriteStreamL() = 0; virtual TBool ConsistsOfL(MSenElement& aCandidate) = 0; virtual RPointerArray<CSenElement>& ElementsL() = 0; virtual CSenElement* Child(TInt aIndex) = 0; virtual const TDesC8* AttrValue(const TDesC8& aName) = 0; virtual void AddAttrL(const TDesC8& aName, const TDesC8& aValue) = 0; virtual RPointerArray<CSenBaseAttribute>& AttributesL() = 0; virtual RPointerArray<CSenNamespace>& NamespacesL() = 0; virtual CSenElement* Parent() = 0; virtual CSenElement* SetParent(CSenElement* apParent) = 0; virtual CSenElement* DetachL() = 0; virtual MSenElement& Root() = 0; virtual CSenElement* Element(const TDesC8& aLocalName) = 0; virtual CSenElement* Element(const TDesC8& aNsUri, const TDesC8& aLocalName) = 0; virtual CSenElement* CreateElementL(const TDesC8& aNsPrefix, const TDesC8& aLocalName) = 0; virtual CSenElement& InsertElementL(CSenElement& aInsertedElement, const CSenElement& aBeforeElement) = 0; virtual CSenElement& AddElementL(CSenElement& aElement) = 0; virtual CSenElement& AddElementL(const TDesC8& aNsUri, const TDesC8& aLocalName) = 0; virtual CSenElement& AddElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName) = 0; virtual CSenElement& AddElementL(const TDesC8& aLocalName) = 0; virtual CSenElement* RemoveElement(CSenElement& aElement) = 0; virtual CSenElement* RemoveElement( const TDesC8& aNsUri, const TDesC8& aLocalName) = 0; virtual CSenElement* RemoveElement(const TDesC8& aLocalName) = 0; virtual CSenElement* ReplaceElementL(CSenElement& aElement) = 0; virtual HBufC8* AsXmlL() = 0; virtual HBufC* AsXmlUnicodeL() = 0; virtual void WriteAsXMLToL(RWriteStream& aWriteStream) = 0; virtual void WriteNamespacesToL(RWriteStream& aWriteStream) = 0; virtual MSenElement* AsElement() = 0; virtual void CopyFromL(CSenElement& aSource) = 0; virtual void Set(const TDesC8& aNamespaceURI, const TDesC8& aLocalName, const TDesC8& aQName) = 0; virtual void AddAttributesL(const RAttributeArray& aAttrs) = 0;};# 34 "x:/epoc32/include/mw/SenElement.h" 2using namespace Xml;class CSenElement : public CBase, public MSenElement { public: virtual const TDesC8& LocalName() const = 0; virtual const TDesC8& NamespaceURI() const = 0; virtual void SetNamespaceL(const TDesC8& aNsUri) = 0; virtual void SetNamespaceL( const TDesC8& aNsPrefix, const TDesC8& aNsUri) = 0; virtual const CSenNamespace* AddNamespaceL( const TDesC8& aPrefix, const TDesC8& aUri) = 0; virtual const CSenNamespace* Namespace() = 0; virtual const CSenNamespace* Namespace(const TDesC8& aNsPrefix) = 0; virtual const CSenNamespace* Namespace( const TDesC8& aNsPrefix, const TDesC8& aUri) = 0; virtual const CSenNamespace* Namespace( const TDesC8& aNsPrefix, const TBool aCheckInParent) = 0; virtual const TDesC8& NsPrefix() const = 0; virtual void SetPrefixL(const TDesC8& aPrefix) = 0; virtual TBool HasContent() const = 0; virtual TPtrC8 Content() const = 0; virtual HBufC* ContentUnicodeL() const = 0; virtual TPtrC8 SetContentL(const TDesC8& aContent) = 0; virtual RWriteStream& ContentWriteStreamL() = 0; virtual TBool ConsistsOfL(MSenElement& aCandidate) = 0; virtual TInt ElementsL(RPointerArray<CSenElement>& aElementArray, const TDesC8& aNsUri, const TDesC8& aLocalName) = 0; virtual TInt ElementsL(RPointerArray<CSenElement>& aElementArray, const TDesC8& aLocalName) = 0; virtual RPointerArray<CSenElement>& ElementsL() = 0; virtual const CSenNamespace* AddNamespaceL(CSenNamespace& aNewNamespace, TBool aCheckInParent) = 0; virtual const TDesC8* AttrValue(const TDesC8& aName) = 0; virtual void AddAttrL(const TDesC8& aName, const TDesC8& aValue) = 0; virtual RPointerArray<CSenBaseAttribute>& AttributesL() = 0; virtual RPointerArray<CSenNamespace>& NamespacesL() = 0; virtual CSenElement* Parent() = 0; virtual CSenElement* SetParent(CSenElement* apParent) = 0; virtual CSenElement* DetachL() = 0; virtual CSenElement* Child(TInt aIndex) = 0; virtual MSenElement& Root() = 0; virtual CSenElement* Element(const TDesC8& aLocalName) = 0; virtual CSenElement* Element(const TDesC8& aNsUri, const TDesC8& aLocalName) = 0; virtual CSenElement* CreateElementL(const TDesC8& aNsPrefix, const TDesC8& aLocalName) = 0; virtual CSenElement& InsertElementL(CSenElement& aInsertedElement, const CSenElement& aBeforeElement) = 0; virtual CSenElement& AddElementL(CSenElement& aElement) = 0; virtual CSenElement& AddElementL( const TDesC8& aNsUri, const TDesC8& aLocalName) = 0; virtual CSenElement& AddElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName) = 0; virtual CSenElement& AddElementL(const TDesC8& aLocalName) = 0; virtual CSenElement* RemoveElement(CSenElement& aElement) = 0; virtual CSenElement* RemoveElement( const TDesC8& aNsUri, const TDesC8& aLocalName) = 0; virtual CSenElement* RemoveElement(const TDesC8& aLocalName) = 0; virtual CSenElement* ReplaceElementL(CSenElement& aElement) = 0; virtual HBufC8* AsXmlL() = 0; virtual HBufC* AsXmlUnicodeL() = 0; virtual void WriteAsXMLToL(RWriteStream& aWriteStream) = 0; virtual void WriteNamespacesToL(RWriteStream& aWriteStream) = 0; virtual MSenElement* AsElement() = 0; virtual void CopyFromL(CSenElement& aSource) = 0; virtual void Set(const TDesC8& aNamespaceURI, const TDesC8& aLocalName, const TDesC8& aQName) = 0; virtual void AddAttributesL(const RAttributeArray& apAttrs) = 0; };# 30 "x:/epoc32/include/mw/SenBaseFragment.h" 2# 1 "x:/epoc32/include/mw/SenFragment.h" 1#define SEN_FRAGMENT_H# 1 "x:/epoc32/include/mw/SenXmlReader.h" 1#define SEN_XMLREADER_H# 1 "x:/epoc32/include/xml/parserfeature.h" 1#define PARSERFEATURE_Hnamespace Xml{enum TParserFeature { EConvertTagsToLowerCase = 0x0001, EErrorOnUnrecognisedTags = 0x0002, EReportUnrecognisedTags = 0x0004, EReportNamespaces = 0x0008, EReportNamespacePrefixes = 0x0010, ESendFullContentInOneChunk = 0x0020, EReportNamespaceMapping = 0x0040, ERawContent = 0x0080, EReplaceIntEntityFromExtSubsetByRef = 0x0100, EXmlVersion_1_1 = 0x0200, ELastFeature = EXmlVersion_1_1, };}# 30 "x:/epoc32/include/mw/SenXmlReader.h" 2 # 1 "x:/epoc32/include/badesca.h" 1#define __BADESCA_H__# 1 "x:/epoc32/include/bamdesca.h" 1#define __BAMDESCA_H__class MDesC8Array {public: virtual ~MDesC8Array() {} virtual TInt MdcaCount() const =0; virtual TPtrC8 MdcaPoint(TInt aIndex) const =0; };class MDesC16Array {public: virtual ~MDesC16Array() {} virtual TInt MdcaCount() const =0; virtual TPtrC16 MdcaPoint(TInt aIndex) const =0; };#define MDesCArray# 23 "x:/epoc32/include/badesca.h" 2class CDesC8Array : public CArrayFixBase, public MDesC8Array {protected: IMPORT_C CDesC8Array(TBufRep aRep,TInt aGranularity);public: IMPORT_C ~CDesC8Array(); IMPORT_C void AppendL(const TDesC8& aPtr); IMPORT_C void InsertL(TInt aPos,const TDesC8& aPtr); IMPORT_C TInt InsertIsqL(const TDesC8& aPtr,TKeyCmpText aTextComparisonType=ECmpFolded); IMPORT_C TInt InsertIsqAllowDuplicatesL(const TDesC8& aPtr,TKeyCmpText aTextComparisonType=ECmpFolded); IMPORT_C void Sort(TKeyCmpText aTextComparisonType=ECmpFolded); IMPORT_C TInt Find(const TDesC8& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType=ECmpFolded) const; IMPORT_C TInt FindIsq(const TDesC8& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType=ECmpFolded) const; IMPORT_C void Delete(TInt aPos); IMPORT_C void Delete(TInt aIndex,TInt aCount); IMPORT_C void Reset(); inline TPtrC8 operator[](TInt aIndex) const; IMPORT_C TInt MdcaCount() const; IMPORT_C TPtrC8 MdcaPoint(TInt aIndex) const; };inline TPtrC8 CDesC8Array::operator[](TInt aIndex) const { return(MdcaPoint(aIndex)); }class CDesC8ArrayFlat : public CDesC8Array {public: IMPORT_C CDesC8ArrayFlat(TInt aGranularity); IMPORT_C ~CDesC8ArrayFlat(); };class CDesC8ArraySeg : public CDesC8Array {public: IMPORT_C CDesC8ArraySeg(TInt aGranularity); IMPORT_C ~CDesC8ArraySeg(); };class CDesC16Array : public CArrayFixBase, public MDesC16Array {protected: IMPORT_C CDesC16Array(TBufRep aRep,TInt aGranularity);public: IMPORT_C ~CDesC16Array(); IMPORT_C void AppendL(const TDesC16& aPtr); IMPORT_C void InsertL(TInt aPos,const TDesC16& aPtr); IMPORT_C TInt InsertIsqL(const TDesC16& aPtr,TKeyCmpText aTextComparisonType=ECmpFolded); IMPORT_C TInt InsertIsqAllowDuplicatesL(const TDesC16& aPtr,TKeyCmpText aTextComparisonType=ECmpFolded); IMPORT_C void Sort(TKeyCmpText aTextComparisonType=ECmpFolded); IMPORT_C TInt Find(const TDesC16& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType=ECmpFolded) const; IMPORT_C TInt FindIsq(const TDesC16& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType=ECmpFolded) const; IMPORT_C void Delete(TInt aPos); IMPORT_C void Delete(TInt aIndex,TInt aCount); IMPORT_C void Reset(); inline TPtrC16 operator[](TInt aIndex) const; IMPORT_C TInt MdcaCount() const; IMPORT_C TPtrC16 MdcaPoint(TInt aIndex) const; };inline TPtrC16 CDesC16Array::operator[](TInt aIndex) const { return(MdcaPoint(aIndex)); }class CDesC16ArrayFlat : public CDesC16Array {public: IMPORT_C CDesC16ArrayFlat(TInt aGranularity); IMPORT_C ~CDesC16ArrayFlat(); };class CDesC16ArraySeg : public CDesC16Array {public: IMPORT_C CDesC16ArraySeg(TInt aGranularity); IMPORT_C ~CDesC16ArraySeg(); };class CPtrC8Array : public CArrayFixFlat<TPtrC8>, public MDesC8Array {public: IMPORT_C CPtrC8Array(TInt aGranularity); IMPORT_C ~CPtrC8Array(); IMPORT_C void CopyL(const MDesC8Array& aArray); inline void operator=(const MDesC8Array& aArray); IMPORT_C TInt MdcaCount() const; IMPORT_C TPtrC8 MdcaPoint(TInt aIndex) const; };class CPtrC16Array : public CArrayFixFlat<TPtrC16>, public MDesC16Array {public: IMPORT_C CPtrC16Array(TInt aGranularity); IMPORT_C ~CPtrC16Array(); IMPORT_C void CopyL(const MDesC16Array& aArray); inline void operator=(const MDesC16Array& aArray); IMPORT_C TInt MdcaCount() const; IMPORT_C TPtrC16 MdcaPoint(TInt aIndex) const; };inline void CPtrC8Array::operator=(const MDesC8Array& aArray) {CopyL(aArray);}inline void CPtrC16Array::operator=(const MDesC16Array& aArray) {CopyL(aArray);}typedef CDesC16Array CDesCArray;typedef CDesC16ArrayFlat CDesCArrayFlat;typedef CDesC16ArraySeg CDesCArraySeg;typedef CPtrC16Array CPtrCArray;# 32 "x:/epoc32/include/mw/SenXmlReader.h" 2using namespace Xml;const TInt KSenDefaultParserFeature = (TInt)EReportNamespaceMapping; const static TLitC8<sizeof( "text/xml" )> KXmlParserMimeType ={sizeof( "text/xml" )-1, "text/xml" }; const static TLitC8<sizeof( "libxml2" )> KXmlVariant ={sizeof( "libxml2" )-1, "libxml2" }; class MSenContentHandlerClient;class RFs;class CSenXmlReader : public CBase, public MContentHandler { public: IMPORT_C static CSenXmlReader* NewL(); IMPORT_C static CSenXmlReader* NewLC(); IMPORT_C static CSenXmlReader* NewL(TInt aParserFeature); IMPORT_C static CSenXmlReader* NewLC(TInt aParserFeature); IMPORT_C static CSenXmlReader* NewL(const TDesC8& aParserMimeType); IMPORT_C static CSenXmlReader* NewLC(const TDesC8& aParserMimeType); IMPORT_C static CSenXmlReader* NewL(const TDesC8& aParserMimeType, TInt aParserFeature); IMPORT_C static CSenXmlReader* NewLC(const TDesC8& aParserMimeType, TInt aParserFeature); IMPORT_C virtual ~CSenXmlReader(); IMPORT_C virtual void SetContentHandler( MSenContentHandlerClient& aContentHandler); IMPORT_C virtual TInt EnabledParserFeature(); IMPORT_C virtual TInt ParserFeature(); TInt SetParserFeature(TInt aParserFeature); IMPORT_C void ParseL(const TDesC8& aBuff); IMPORT_C void ParseL(RFs &aRFs, const TDesC& aFileToParse); virtual void OnStartDocumentL(const RDocumentParameters& aDocParam, TInt aErrorCode); virtual void OnEndDocumentL(TInt aErrorCode); virtual void OnStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode); virtual void OnEndElementL(const RTagInfo& aElement, TInt aErrorCode); virtual void OnContentL(const TDesC8& aBytes, TInt aErrorCode); virtual void OnStartPrefixMappingL(const RString& aPrefix, const RString& aUri, TInt aErrorCode); virtual void OnEndPrefixMappingL(const RString& aPrefix, TInt aErrorCode); virtual void OnIgnorableWhiteSpaceL(const TDesC8& aBytes, TInt aErrorCode); virtual void OnSkippedEntityL(const RString& aName, TInt aErrorCode); virtual void OnProcessingInstructionL(const TDesC8& aTarget, const TDesC8& aData, TInt aErrorCode); virtual void OnError(TInt aErrorCode); virtual TAny* GetExtendedInterface(const TInt32 aUid); protected: IMPORT_C CSenXmlReader(TInt aParserFeature); void ConstructL(const TDesC8& aParserMimeType); void RecreateParserL(); private: static void CleanupParser(TAny* apReader); void CleanUp(); private: CParser* iParser; MSenContentHandlerClient* iContentHandler; CDesC8Array* ipNsPrefixes; CDesC8Array* ipNsUris; RStringPool iStringPool; TInt iEnabledFeature; }; # 32 "x:/epoc32/include/mw/SenFragment.h" 2# 1 "x:/epoc32/include/mw/MSenFragment.h" 1#define M_SEN_FRAGMENT_Hclass CSenElement;using namespace Xml;class MSenFragment { public: virtual CSenElement& AsElement() = 0; virtual CSenElement* ExtractElement() = 0; virtual void SetReader(CSenXmlReader& aReader) = 0; virtual CSenXmlReader* Reader() = 0; virtual void ParseL(const TDesC8& aBuf) = 0; virtual TInt BuildFrom(const TDesC8& aBuf) = 0; virtual void DelegateParsingL(MSenFragment& aDelegate) = 0; virtual void DelegateParsingL( const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs) = 0; virtual void ParseWithL(CSenXmlReader& aReader) = 0; virtual void SetOwner(MSenFragment& aFragment) = 0; virtual void ResumeParsingFromL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName) = 0; virtual void SetAttributesL(const RAttributeArray& aAttrs) = 0; virtual void WriteStartElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs) = 0; virtual void WriteEndElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName) = 0; virtual const TDesC8& LocalName() const = 0; virtual const TDesC8& NsUri() const = 0; virtual const TDesC8& NsPrefix() const = 0; virtual void WriteAsXMLToL(RWriteStream& aWriteStream) = 0; virtual HBufC* AsXmlUnicodeL() = 0; virtual HBufC8* AsXmlL() = 0; virtual TBool ConsistsOfL(MSenFragment& aCandidate) = 0; };# 34 "x:/epoc32/include/mw/SenFragment.h" 2class CSenFragment : public CBase, public MSenFragment { public: virtual CSenElement& AsElement() = 0; virtual CSenElement* ExtractElement() = 0; virtual void SetReader(CSenXmlReader& aReader) = 0; virtual CSenXmlReader* Reader() = 0; virtual void ParseL(const TDesC8& aXml) = 0; virtual TInt BuildFrom(const TDesC8& aBuf) = 0; virtual void DelegateParsingL(MSenFragment& aDelegate) = 0; virtual void DelegateParsingL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs) = 0; virtual void ParseWithL(CSenXmlReader& aReader) = 0; virtual void SetOwner(MSenFragment& aFragment) = 0; virtual void ResumeParsingFromL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName) = 0; virtual void SetAttributesL(const RAttributeArray& aAttrs) = 0; virtual void WriteStartElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs) = 0; virtual void WriteEndElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName) = 0; virtual const TDesC8& LocalName() const = 0; virtual const TDesC8& NsUri() const = 0; virtual const TDesC8& NsPrefix() const = 0; virtual void WriteAsXMLToL(RWriteStream& aWriteStream) = 0; virtual HBufC* AsXmlUnicodeL() = 0; virtual HBufC8* AsXmlL() = 0; virtual TPtrC8 Content() = 0; virtual TBool ConsistsOfL(MSenFragment& aCandidate) = 0; };# 31 "x:/epoc32/include/mw/SenBaseFragment.h" 2const TInt KStateNotSet = -1;const TInt KStateIgnore = 0;const TInt KStateSave = 1;const TInt KStateResume = 2;class CSenXmlReader;class CSenBaseFragment : public CSenFragment, public MSenContentHandlerClient { public: IMPORT_C static CSenBaseFragment* NewL(const CSenElement& aElement); IMPORT_C static CSenBaseFragment* NewL(const TDesC8& aLocalName); IMPORT_C static CSenBaseFragment* NewL(const TDesC8& aNsUri, const TDesC8& aLocalName); IMPORT_C static CSenBaseFragment* NewL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); IMPORT_C static CSenBaseFragment* NewL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& apAttrs); IMPORT_C static CSenBaseFragment* NewL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& apAttrs, CSenElement& aParent); IMPORT_C virtual ~CSenBaseFragment(); IMPORT_C virtual TPtrC8 Content(); IMPORT_C virtual CSenNamespace* Namespace(const TDesC8& aPrefix); IMPORT_C virtual void EnsureNamespace(const TDesC8& aPrefix); IMPORT_C virtual void DetachL(); IMPORT_C virtual void SaveNamespacesL(const RAttributeArray& aAttrs, TBool aEnsure); IMPORT_C virtual void ResetContentL(); IMPORT_C virtual const TDesC8& LocalName() const; IMPORT_C virtual const TDesC8& NsUri() const; IMPORT_C virtual const TDesC8& NsPrefix() const; IMPORT_C virtual CSenElement& AsElement(); IMPORT_C virtual CSenElement* ExtractElement(); IMPORT_C virtual CSenXmlReader* Reader(); IMPORT_C virtual void SetReader(CSenXmlReader& aReader); IMPORT_C virtual void ParseL(const TDesC8& aXml); IMPORT_C virtual TInt BuildFrom(const TDesC8& aXml); IMPORT_C virtual void DelegateParsingL(MSenFragment& aDelegate); IMPORT_C virtual void DelegateParsingL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C virtual void ParseWithL(CSenXmlReader& aReader); IMPORT_C virtual void SetOwner(MSenFragment& aFragment); IMPORT_C virtual void ResumeParsingFromL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); IMPORT_C virtual void SetAttributesL(const RAttributeArray& aAttrs); IMPORT_C void WriteStartElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C void WriteEndElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); IMPORT_C virtual HBufC* AsXmlUnicodeL(); IMPORT_C virtual HBufC8* AsXmlL(); IMPORT_C virtual void WriteAsXMLToL(RWriteStream& aWs); IMPORT_C virtual TBool ConsistsOfL(MSenFragment& aCandidate); protected: IMPORT_C CSenBaseFragment(); IMPORT_C void BaseConstructL(const CSenElement& aElement); IMPORT_C void BaseConstructL(const TDesC8& aLocalName); IMPORT_C void BaseConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName); IMPORT_C void BaseConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); IMPORT_C void BaseConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C void BaseConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs, CSenElement& aParent); IMPORT_C void BaseConstructL(CSenXmlReader& aReader); IMPORT_C virtual void AllocContentSaverL(); IMPORT_C virtual void StartElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C virtual void EndElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); IMPORT_C virtual void CharactersL(const TDesC8& aChars, TInt aStart, TInt aLength); IMPORT_C TInt StartEntity(TDesC8& aName); IMPORT_C MSenElement& SetContentOfL(const TDesC8& aLocalName, const TDesC8& aContent); IMPORT_C TPtrC8 ContentOf(const TDesC8& aLocalName); private: TPtrC8 ContentL(); IMPORT_C virtual TInt StartDocument(); IMPORT_C virtual TInt EndDocument(); IMPORT_C virtual TInt StartElement(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C virtual TInt EndElement(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); IMPORT_C virtual TInt Characters(const TDesC8& aChars, const TInt aStart, const TInt aLength); IMPORT_C virtual TInt Error(TInt aErrorCode); protected: TInt iState; CSenElement* ipElement; CSenXmlReader* iXmlReader; MSenFragment* ipOwner; RWriteStream iWs; private: CSenFragment* ipDelegate; RPointerArray<CSenNamespace> iNamespaces; RPointerArray<HBufC8> iPrefixes; CBufFlat* ipContentWithNamespaces; TBool hasContentWriteStream; TBool iElementOwned; };# 29 "x:/epoc32/include/mw/SenDomFragment.h" 2class RFileLogger;class CSenDomFragment : public CSenBaseFragment { public: IMPORT_C static CSenDomFragment* NewL(); IMPORT_C static CSenDomFragment* NewL( const CSenElement& aElement); IMPORT_C static CSenDomFragment* NewL(const TDesC8& aLocalName); IMPORT_C static CSenDomFragment* NewL(const TDesC8& aNsUri, const TDesC8& aLocalName); IMPORT_C static CSenDomFragment* NewL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); IMPORT_C static CSenDomFragment* NewL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C static CSenDomFragment* NewL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs, CSenElement& aParent); IMPORT_C virtual ~CSenDomFragment(); IMPORT_C virtual void ExpandL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C void ResumeParsingFromL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); IMPORT_C virtual void ParseWithL(CSenXmlReader& aReader); IMPORT_C virtual void SetAttributesL(const RAttributeArray& aAttrs); protected: IMPORT_C CSenDomFragment(); IMPORT_C void BaseConstructL(const CSenElement& aElement); IMPORT_C void BaseConstructL(const TDesC8& aLocalName); IMPORT_C void BaseConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName); IMPORT_C void BaseConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); IMPORT_C void BaseConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C void BaseConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs, CSenElement& aParent); IMPORT_C void BaseConstructL(CSenXmlReader& aReader); IMPORT_C virtual void StartElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C virtual void CharactersL(const TDesC8& aChars,TInt aStart,TInt aLength); IMPORT_C void WriteStartElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, const RAttributeArray& aAttrs); IMPORT_C void WriteEndElementL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName); protected: CSenDomFragment* ipDomDelegate; };# 29 "x:/sf/mw/websrv/webservices/wsframework/inc/senlayeredxmlproperties.h" 2# 1 "x:/sf/mw/websrv/webservices/wsframework/inc/msenlayeredproperties.h" 1#define M_SEN_LAYERED_PROPERTIES_H# 1 "x:/epoc32/include/mw/MSenProperties.h" 1#define M_SEN_PROPERTIES_Hconst TInt KErrSenOmitted = 10;class RWriteStream;class CSenXmlReader;class MSenProperties { public: enum TSenPropertiesClassType { ENotInUse = 0, ESenXmlProperties = 1, ESenTransportProperties = 2, ESenHttpTransportProperties = 3, ESenVtcpTransportProperties = 4, ESenLayeredXmlProperties = 5, ESenLayeredTransportProperties = 6, ESenLayeredHttpTransportProperties = 7, ESenLayeredVtcpTransportProperties = 8 }; virtual void SetReader(CSenXmlReader& aReader) = 0; virtual TSenPropertiesClassType PropertiesClassType() = 0; virtual void WriteToL(RWriteStream& aWriteStream) = 0; virtual void ReadFromL(const TDesC8& aBuffer) = 0; virtual HBufC8* AsUtf8L() = 0; virtual HBufC8* AsUtf8LC() = 0; virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue) = 0; virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue) = 0; virtual TInt SetIntPropertyL(const TDesC8& aName, const TInt aValue) = 0; virtual TInt IntPropertyL(const TDesC8& aName, TInt& aValue) = 0; virtual TInt SetBoolPropertyL(const TDesC8& aName, const TBool aValue) = 0; virtual TInt BoolPropertyL(const TDesC8& aName, TBool& aValue) = 0; virtual MSenProperties* Clone(TInt& aOkOrError) const = 0; virtual TBool IsSafeToCast(TSenPropertiesClassType aClass) = 0; virtual MSenProperties* CloneL() const = 0; };# 30 "x:/sf/mw/websrv/webservices/wsframework/inc/msenlayeredproperties.h" 2# 1 "x:/epoc32/include/mw/MSenProperty.h" 1#define M_SEN_PROPERTY_Hclass MSenProperty { public: virtual TPtrC8 Name() = 0; virtual TPtrC8 Type() = 0; virtual TPtrC8 Value() = 0; virtual TInt IntValue(TInt& aValue) = 0; virtual TInt BoolValue(TBool& aValue) = 0; virtual TInt ValueTokensL(const TDesC8& aDelimiter, RPointerArray<TPtrC8>& aTokens) = 0; };# 31 "x:/sf/mw/websrv/webservices/wsframework/inc/msenlayeredproperties.h" 2class MSenLayeredProperties : public MSenProperties { public: enum TSenPropertiesLayer { ESenTransportLayer = 1, ESenSereneLayer = 2, ESenFrameworkLayer = 3, ESenProviderSessionLayer = 4, ESenConsumerSessionLayer = 5, ESenMessageLayer = 6, ESenLastLayer = ESenMessageLayer }; virtual void WriteToL(RWriteStream& aWriteStream, TSenPropertiesLayer aLayer) = 0; virtual void ReadFromL(const TDesC8& aBuffer, TSenPropertiesLayer aLayer) = 0; virtual HBufC8* AsUtf8L(TSenPropertiesLayer aLayer) = 0; virtual HBufC8* AsUtf8LC(TSenPropertiesLayer aLayer) = 0; virtual TInt ShrinkTo(TSenPropertiesLayer aLayer) = 0; virtual void ExpandToL(TSenPropertiesLayer aLayer) = 0; virtual TSenPropertiesLayer TopLayer() = 0; virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue, TSenPropertiesLayer aLayer) = 0; virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue, TSenPropertiesLayer aLayer) = 0; virtual TInt PropertyL(const TDesC8& aName, MSenProperty*& aValue, TSenPropertiesLayer aLayer) = 0; virtual TInt PropertyL(const TDesC8& aName, MSenProperty*& aValue) = 0; virtual TInt PropertiesByTypeL(const TDesC8& aTypeName, RPointerArray<MSenProperty>& aArray) = 0; virtual TInt SetIntPropertyL(const TDesC8& aName, const TInt aValue, TSenPropertiesLayer aLayer) = 0; virtual TInt IntPropertyL(const TDesC8& aName, TInt& aValue, TSenPropertiesLayer aLayer) = 0; virtual TInt SetBoolPropertyL(const TDesC8& aName, const TBool aValue, TSenPropertiesLayer aLayer) = 0; virtual TInt BoolPropertyL(const TDesC8& aName, TBool& aValue, TSenPropertiesLayer aLayer) = 0; };# 31 "x:/sf/mw/websrv/webservices/wsframework/inc/senlayeredxmlproperties.h" 2class RWriteStream;class CSenXmlReader;class CSenPropertiesFragment;const static TLitC8<sizeof( "Properties" )> KSenLayeredXmlPropertiesLocalname ={sizeof( "Properties" )-1, "Properties" };class CSenLayeredXmlProperties : public CBase, public MSenLayeredProperties { public: static CSenLayeredXmlProperties* NewL(); static CSenLayeredXmlProperties* NewLC(); static CSenLayeredXmlProperties* NewL(const TDesC8& aXmlUtf8, CSenXmlReader& aParser); static CSenLayeredXmlProperties* NewLC(const TDesC8& aXmlUtf8, CSenXmlReader& aParser); static CSenLayeredXmlProperties* NewL(const CSenElement& aElement); static CSenLayeredXmlProperties* NewLC(const CSenElement& aElement); static CSenLayeredXmlProperties* NewL(RStringPool& aStringPool); static CSenLayeredXmlProperties* NewLC(RStringPool& aStringPool); static CSenLayeredXmlProperties* NewL(const TDesC8& aXmlUtf8, CSenXmlReader& aParser, RStringPool& aStringPool); static CSenLayeredXmlProperties* NewLC(const TDesC8& aXmlUtf8, CSenXmlReader& aParser, RStringPool& aStringPool); static CSenLayeredXmlProperties* NewL(const CSenElement& aElement, RStringPool& aStringPool); static CSenLayeredXmlProperties* NewLC(const CSenElement& aElement, RStringPool& aStringPool); virtual void SetReader(CSenXmlReader& aReader); virtual TSenPropertiesClassType PropertiesClassType(); virtual void WriteToL(RWriteStream& aWriteStream); virtual void ReadFromL(const TDesC8& aBuffer); virtual HBufC8* AsUtf8L(); virtual HBufC8* AsUtf8LC(); virtual TBool IsSafeToCast(TSenPropertiesClassType aClass); virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue); virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue); virtual TInt SetIntPropertyL(const TDesC8& aName, const TInt aValue); virtual TInt IntPropertyL(const TDesC8& aName, TInt& aValue); virtual TInt SetBoolPropertyL(const TDesC8& aName, const TBool aValue); virtual TInt BoolPropertyL(const TDesC8& aName, TBool& aValue); virtual TInt SetOmittedL(const TDesC8& aName, TBool aValue); virtual TInt RemovePropertyL(const TDesC8& aName); virtual void WriteToL(RWriteStream& aWriteStream, TSenPropertiesLayer aLayer); virtual void ReadFromL(const TDesC8& aBuffer, TSenPropertiesLayer aLayer); virtual HBufC8* AsUtf8L(TSenPropertiesLayer aLayer); virtual HBufC8* AsUtf8LC(TSenPropertiesLayer aLayer); virtual TInt ShrinkTo(TSenPropertiesLayer aLayer); virtual void ExpandToL(TSenPropertiesLayer aLayer); virtual TSenPropertiesLayer TopLayer(); virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue, TSenPropertiesLayer aLayer); virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue, TSenPropertiesLayer aLayer); virtual TInt PropertyL(const TDesC8& aName, MSenProperty*& aValue, TSenPropertiesLayer aLayer); virtual TInt PropertyL(const TDesC8& aName, MSenProperty*& aValue); virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue, const TDesC8& aType); virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue, TPtrC8& aType); virtual TInt PropertiesByTypeL(const TDesC8& aTypeName, RPointerArray<MSenProperty>& aArray); virtual TInt SetIntPropertyL(const TDesC8& aName, const TInt aValue, TSenPropertiesLayer aLayer); virtual TInt IntPropertyL(const TDesC8& aName, TInt& aValue, TSenPropertiesLayer aLayer); virtual MSenProperties* CloneL() const; virtual MSenProperties* Clone(TInt& aOkOrError) const; virtual TInt SetBoolPropertyL(const TDesC8& aName, const TBool aValue, TSenPropertiesLayer aLayer); virtual TInt BoolPropertyL(const TDesC8& aName, TBool& aValue, TSenPropertiesLayer aLayer); virtual TInt SetOmittedL(const TDesC8& aName, TBool aValue, TSenPropertiesLayer aLayer); virtual TInt RemovePropertyL(const TDesC8& aName, TSenPropertiesLayer aLayer); virtual ~CSenLayeredXmlProperties(); protected: virtual void BaseConstructL(const TDesC8& aLocalname, const TDesC8& aXml, CSenXmlReader* aParser = NULL, RStringPool* aStringPool = NULL); virtual void BaseConstructL(const TDesC8& aNamespace, const TDesC8& aLocalname, const TDesC8& aXml, CSenXmlReader* aParser = NULL, RStringPool* aStringPool = NULL); virtual void BaseConstructL(const TDesC8& aNamespace, const TDesC8& aLocalname, const TDesC8& aQualifiedName, const TDesC8& aXml, CSenXmlReader* aParser = NULL, RStringPool* aStringPool = NULL); virtual void BaseConstructL(const CSenElement& aElement, RStringPool* aStringPool = NULL); virtual TInt AllPropertiesByTypeL(const TDesC8& aTypeName, RPointerArray<MSenProperty>& aArray); protected: CSenLayeredXmlProperties(); private: void CreateChildPropertiesL(); void ElementsL(RPointerArray<CSenElement>& aProps) const; protected: CSenPropertiesFragment* ipFragment; CSenLayeredXmlProperties* ipChildProperties; private: TSenPropertiesLayer iLayer; CSenXmlReader* ipReader; CSenLayeredXmlProperties* ipParentProperties; };# 28 "x:/sf/mw/websrv/webservices/wsframework/inc/senlayeredtransportproperties.h" 2class CSenLayeredTransportProperties : public CSenLayeredXmlProperties { public: public: IMPORT_C static CSenLayeredTransportProperties* NewL(); IMPORT_C static CSenLayeredTransportProperties* NewLC(); IMPORT_C static CSenLayeredTransportProperties* NewL(const TDesC8& aXmlUtf8, CSenXmlReader& aParser); IMPORT_C static CSenLayeredTransportProperties* NewLC(const TDesC8& aXmlUtf8, CSenXmlReader& aParser); IMPORT_C static CSenLayeredTransportProperties* NewL(const CSenElement& aElement); IMPORT_C static CSenLayeredTransportProperties* NewLC(const CSenElement& aElement); IMPORT_C static CSenLayeredTransportProperties* NewL(RStringPool& aStringPool); IMPORT_C static CSenLayeredTransportProperties* NewLC(RStringPool& aStringPool); IMPORT_C static CSenLayeredTransportProperties* NewL(const TDesC8& aXmlUtf8, CSenXmlReader& aParser, RStringPool& aStringPool); IMPORT_C static CSenLayeredTransportProperties* NewLC(const TDesC8& aXmlUtf8, CSenXmlReader& aParser, RStringPool& aStringPool); IMPORT_C static CSenLayeredTransportProperties* NewL(const CSenElement& aElement, RStringPool& aStringPool); IMPORT_C static CSenLayeredTransportProperties* NewLC(const CSenElement& aElement, RStringPool& aStringPool); IMPORT_C virtual void SetReader(CSenXmlReader& aReader); IMPORT_C virtual TSenPropertiesClassType PropertiesClassType(); IMPORT_C virtual void WriteToL(RWriteStream& aWriteStream); IMPORT_C virtual void ReadFromL(const TDesC8& aBuffer); IMPORT_C virtual HBufC8* AsUtf8L(); IMPORT_C virtual HBufC8* AsUtf8LC(); IMPORT_C virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue); IMPORT_C virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue); IMPORT_C virtual TInt SetIntPropertyL(const TDesC8& aName, const TInt aValue); IMPORT_C virtual TInt IntPropertyL(const TDesC8& aName, TInt& aValue); IMPORT_C virtual TInt SetBoolPropertyL(const TDesC8& aName, const TBool aValue); IMPORT_C virtual TInt BoolPropertyL(const TDesC8& aName, TBool& aValue); IMPORT_C virtual TBool IsSafeToCast(TSenPropertiesClassType aClass); IMPORT_C virtual void WriteToL(RWriteStream& aWriteStream, TSenPropertiesLayer aLayer); IMPORT_C virtual void ReadFromL(const TDesC8& aBuffer, TSenPropertiesLayer aLayer); IMPORT_C virtual HBufC8* AsUtf8L(TSenPropertiesLayer aLayer); IMPORT_C virtual HBufC8* AsUtf8LC(TSenPropertiesLayer aLayer); IMPORT_C virtual TInt ShrinkTo(TSenPropertiesLayer aLayer); IMPORT_C virtual void ExpandToL(TSenPropertiesLayer aLayer); IMPORT_C virtual TSenPropertiesLayer TopLayer(); IMPORT_C virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue, TSenPropertiesLayer aLayer); IMPORT_C virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue, TSenPropertiesLayer aLayer); IMPORT_C virtual TInt PropertyL(const TDesC8& aName, MSenProperty*& aValue, TSenPropertiesLayer aLayer); IMPORT_C virtual TInt PropertyL(const TDesC8& aName, MSenProperty*& aValue); IMPORT_C virtual TInt PropertiesByTypeL(const TDesC8& aTypeName, RPointerArray<MSenProperty>& aArray); IMPORT_C virtual TInt SetIntPropertyL(const TDesC8& aName, const TInt aValue, TSenPropertiesLayer aLayer); IMPORT_C virtual TInt IntPropertyL(const TDesC8& aName, TInt& aValue, TSenPropertiesLayer aLayer); IMPORT_C virtual MSenProperties* CloneL() const; IMPORT_C virtual MSenProperties* Clone(TInt& aOkOrError) const; IMPORT_C virtual TInt SetBoolPropertyL(const TDesC8& aName, const TBool aValue, TSenPropertiesLayer aLayer); IMPORT_C virtual TInt BoolPropertyL(const TDesC8& aName, TBool& aValue, TSenPropertiesLayer aLayer); IMPORT_C virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue, const TDesC8& aType); IMPORT_C virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue, TPtrC8& aType); IMPORT_C virtual TInt IapIdL(TUint32& aCurrentIapId); IMPORT_C virtual TInt ProxyPortL(TInt& aProxyPort); IMPORT_C virtual TInt ProxyHostL(TPtrC8& aProxyHost); IMPORT_C virtual TInt ProxyUsageL(TBool& aProxyUsage); IMPORT_C virtual TInt IAPDialogL(TBool& aIAPDialog); IMPORT_C virtual TInt UserAgentL(TPtrC8& aUserAgent); IMPORT_C virtual TInt DeviceIDL(TPtrC8& aDeviceID); IMPORT_C virtual TInt SoapActionL(TPtrC8& aAction); IMPORT_C virtual TInt DownloadFolderL(TPtrC8& aDownloadFolder); IMPORT_C virtual TInt FileAttachmentL(const TDesC8& aCid, HBufC8*& aFileName); IMPORT_C virtual TInt MwsNamespaceL(TPtrC8& aMwsNamespace); IMPORT_C virtual TInt HeartbeatL(TInt& aHeartbeat); IMPORT_C virtual TInt MaxTimeToLiveL(TInt& aMax); IMPORT_C virtual TInt MinTimeToLiveL(TInt& aMin); IMPORT_C virtual TInt SetMaxRetryTTLL(TInt aMaxRetryTTL); IMPORT_C virtual TInt MaxRetryTTLL(TInt& aMaxRetryTTL); IMPORT_C virtual TInt SetRetryDeltaTimeoutL(TInt aTimeout); IMPORT_C virtual TInt RetryDeltaTimeoutL(TInt& aTimeout); IMPORT_C virtual TInt SetMinRetryTTLL(TInt aMinRetryTTL); IMPORT_C virtual TInt MinRetryTTLL(TInt& aMinRetryTTL); IMPORT_C virtual ~CSenLayeredTransportProperties(); protected: IMPORT_C virtual void BaseConstructL(const TDesC8& aLocalname, const TDesC8& aXml, CSenXmlReader* aParser = NULL, RStringPool* aStringPool = NULL); IMPORT_C virtual void BaseConstructL(const TDesC8& aNamespace, const TDesC8& aLocalname, const TDesC8& aXml, CSenXmlReader* aParser = NULL, RStringPool* aStringPool = NULL); IMPORT_C virtual void BaseConstructL(const TDesC8& aNamespace, const TDesC8& aLocalname, const TDesC8& aQualifiedName, const TDesC8& aXml, CSenXmlReader* aParser = NULL, RStringPool* aStringPool = NULL); IMPORT_C virtual void BaseConstructL(const CSenElement& aElement, RStringPool* aStringPool = NULL); public: IMPORT_C virtual TInt SnapIdL(TUint32& aCurrentSnapId); IMPORT_C virtual TInt SnapDialogL(TBool& aSNAPDialog); protected: IMPORT_C CSenLayeredTransportProperties(); };# 35 "x:/sf/mw/websrv/webservices/wsmessages/src/sensoapenvelope2.cpp" 2# 1 "x:/sf/mw/websrv/webservices/wsframework/inc/senmessagecontext.h" 1#define SEN_MESSAGE_CONTEXT_H# 1 "x:/sf/mw/websrv/webservices/wsframework/inc/sencontext.h" 1#define SEN_CONTEXT_H# 1 "x:/sf/mw/websrv/webservices/wsframework/inc/msencontext.h" 1#define M_SEN_CONTEXT_Hclass CSenElement;class CSenXmlReader;namespace SenContext { const static TLitC8<sizeof( "urn:com.nokia.serene:core:service-manager" )> KSenCtxKeyCoreServiceManager ={sizeof( "urn:com.nokia.serene:core:service-manager" )-1, "urn:com.nokia.serene:core:service-manager" }; const static TLitC8<sizeof( "urn:com.nokia.serene:framework:session-initializer" )> KSenCtxKeySessionInitializer ={sizeof( "urn:com.nokia.serene:framework:session-initializer" )-1, "urn:com.nokia.serene:framework:session-initializer" }; const static TLitC8<sizeof( "urn:com.nokia.serene:framework:service-session" )> KSenCtxKeyServiceSession ={sizeof( "urn:com.nokia.serene:framework:service-session" )-1, "urn:com.nokia.serene:framework:service-session" }; const static TLitC8<sizeof( "urn:com.nokia.serene:framework:transport-properties" )> KSenCtxKeyTransportProperties ={sizeof( "urn:com.nokia.serene:framework:transport-properties" )-1, "urn:com.nokia.serene:framework:transport-properties" }; const static TLitC8<sizeof( "urn:com.nokia.serene:framework:message" )> KSenCtxKeyMessage ={sizeof( "urn:com.nokia.serene:framework:message" )-1, "urn:com.nokia.serene:framework:message" }; const static TLitC8<sizeof( "urn:com.nokia.serene:framework:chunk" )> KSenCtxKeyChunk ={sizeof( "urn:com.nokia.serene:framework:chunk" )-1, "urn:com.nokia.serene:framework:chunk" }; const static TLitC8<sizeof( "urn:com.nokia.serene:framework:message:properties" )> KSenCtxKeyMessageProperties ={sizeof( "urn:com.nokia.serene:framework:message:properties" )-1, "urn:com.nokia.serene:framework:message:properties" }; const static TLitC8<sizeof( "urn:com.nokia.serene:framework:current-soap-msg" )> KSenCtxKeyCurrentSoapMessage ={sizeof( "urn:com.nokia.serene:framework:current-soap-msg" )-1, "urn:com.nokia.serene:framework:current-soap-msg" }; const static TLitC8<sizeof( "urn:com.nokia.serene:framework:current-msg-desc" )> KSenCtxKeyCurrentMessageAsDesc ={sizeof( "urn:com.nokia.serene:framework:current-msg-desc" )-1, "urn:com.nokia.serene:framework:current-msg-desc" }; enum TContextType { EContextBase = 0, EHandlerContext, ESessionContext, EMessageContext, ETransportContext }; enum TContextDirection { EOutgoing = 1, EIncoming, EBoth }; }class MSenContext { public: virtual SenContext::TContextType Type() const = 0; virtual SenContext::TContextDirection Direction() const = 0; virtual TInt Add(const TDesC8& aKey, const TDesC8& aValue) = 0; virtual TInt Update(const TDesC8& aKey, const TDesC8& aValue) = 0; virtual const TDesC8* GetDesC8L(const TDesC8& aKey) = 0; virtual TInt Add(const TDesC8& aKey, TInt aValue) = 0; virtual TInt Update(const TDesC8& aKey, TInt aValue) = 0; virtual const TInt* GetIntL(const TDesC8& aKey) = 0; virtual TInt Add(const TDesC8& aKey, CSenElement* aValue) = 0; virtual TInt Update(const TDesC8& aKey, CSenElement* aValue) = 0; virtual const CSenElement* GetSenElementL(const TDesC8& aKey) = 0; virtual TInt Add(const TDesC8& aKey, TAny* aValue) = 0; virtual TInt Update(const TDesC8& aKey, TAny* aValue) = 0; virtual TAny* GetAnyL(const TDesC8& aKey) = 0; virtual const CSenXmlReader* GetParser() = 0; virtual TInt Remove(const TDesC8& aKey) = 0; virtual TInt Count() const = 0; virtual TPtrC8 KeyAtL(TInt aIndex) = 0; virtual void Reset() = 0; virtual TInt SetDirection( SenContext::TContextDirection aDirection ) = 0; };# 32 "x:/sf/mw/websrv/webservices/wsframework/inc/sencontext.h" 2# 1 "x:/epoc32/include/mw/senpointermap.h" 1#define POINTERMAP_Htemplate <typename K, typename V>class RSenPointerMap { public: RSenPointerMap(TBool aTakeOwnershipKey, TBool aTakeOwnershipValue) : iTakeOwnershipKey(aTakeOwnershipKey), iTakeOwnershipValue(aTakeOwnershipValue) {} ~RSenPointerMap() { Reset(); } TInt Append(const K* aKey, const V* aValue) { TInt err = iKeys.Append(aKey); if (err == KErrNone) { err = iValues.Append(aValue); if (err != KErrNone) { TInt lastElementIndex = iKeys.Count() - 1; iKeys.Remove(lastElementIndex); } } return err; } TInt Find(const K& aKey) const { TInt index( KErrNotFound ); for (TInt i = 0; i < iKeys.Count(); i++) { if (*iKeys[i] == aKey) { index = i; break; } } return index; } TInt FindReverse(const K& aKey) const { TInt index( KErrNotFound ); TInt count( iKeys.Count() ); for (TInt i = count-1; i >=0 ; i--) { if (*iKeys[i] == aKey) { index = i; break; } } return index; } TInt RemoveAt( TInt aIndex ) { K* key = KeyAt( aIndex ); return RemoveByKey( *key ); } TInt RemoveByKey(const K& aKey) { TInt index = Find(aKey); if (index != KErrNotFound) { if(iTakeOwnershipKey) { K* key = KeyAt(index); delete key; } if(iTakeOwnershipValue) { V* value = iValues[index]; delete value; } iKeys.Remove(index); iValues.Remove(index); } return index; } TInt Remove(const V& aValue) { TInt index = FindValue(aValue); if (index != KErrNotFound) { if (iTakeOwnershipValue) { V* value = iValues[index]; delete value; } if (iTakeOwnershipKey) { K* key = iKeys[index]; delete key; } iValues.Remove(index); iKeys.Remove(index); } return index; } TInt FindValue(const V& aValue) const { TInt index = KErrNotFound; for (TInt i = 0; i < iValues.Count(); i++) { if ((iValues[i]) && (*iValues[i] == aValue)) { index = i; break; } } return index; } TInt UpdateValue(const K* aKey, const V* aValue) { TInt index=Find(*aKey); if (index==KErrNotFound) { return Append(aKey, aValue); } V* bValue=iValues[index]; if (iTakeOwnershipValue) { delete bValue; } iValues[index]=(V*)aValue; return KErrNone; } K* KeyAt(TInt aIndex) { return iKeys[aIndex]; } const V* ValueAt(TInt aIndex) const { return iValues[aIndex]; } TInt Count() const { return iKeys.Count(); } void Reset() { if ( iTakeOwnershipKey ) { iKeys.ResetAndDestroy(); } else { iKeys.Reset(); } if ( iTakeOwnershipValue ) { iValues.ResetAndDestroy(); } else { iValues.Reset(); } } TInt Insert(const K* aKey, const V* aValue) { TInt count=iKeys.Count(); TInt err=KErrNone; TBool inserted=EFalse; for(TInt i=0; i<count; i++) { if(*iKeys[i] >= *aKey) { err = iKeys.Insert(aKey, i); if (err == KErrNone) { err = iValues.Insert(aValue, i); if (err != KErrNone) { iKeys.Remove(i); } else { inserted=ETrue; } } break; } } if(!inserted) { err = iKeys.Append(aKey); if (err == KErrNone) { err = iValues.Append(aValue); if (err != KErrNone) { TInt lastElementIndex = iKeys.Count() - 1; iKeys.Remove(lastElementIndex); } } } return err; } private: TBool iTakeOwnershipKey; TBool iTakeOwnershipValue; RPointerArray<K> iKeys; RPointerArray<V> iValues; };# 33 "x:/sf/mw/websrv/webservices/wsframework/inc/sencontext.h" 2class CSenContextItem;class CSenXmlReader;typedef RSenPointerMap<TDesC8, CSenContextItem> RCtxItemMap; class CSenContext : public CBase { public: IMPORT_C static CSenContext* NewL(SenContext::TContextDirection aDirection); IMPORT_C static CSenContext* NewLC(SenContext::TContextDirection aDirection); IMPORT_C virtual ~CSenContext(); virtual SenContext::TContextType Type() const; virtual SenContext::TContextDirection Direction() const; virtual TInt Add(const TDesC8& aKey, const TDesC8& aValue); virtual TInt Update(const TDesC8& aKey, const TDesC8& aValue); virtual const TDesC8* GetDesC8L(const TDesC8& aKey); virtual TInt Add(const TDesC8& aKey, TInt aValue); virtual TInt Update(const TDesC8& aKey, TInt aValue); virtual const TInt* GetIntL(const TDesC8& aKey); virtual TInt Add(const TDesC8& aKey, CSenElement* aValue); virtual TInt Update(const TDesC8& aKey, CSenElement* aValue); virtual const CSenElement* GetSenElementL(const TDesC8& aKey); virtual TInt Add(const TDesC8& aKey, TAny* aValue); virtual TInt Update(const TDesC8& aKey, TAny* aValue); virtual TAny* GetAnyL(const TDesC8& aKey); virtual const CSenXmlReader* GetParser(); virtual TInt Remove(const TDesC8& aKey); virtual TInt Count() const; virtual TPtrC8 KeyAtL(TInt aIndex); virtual void Reset(); virtual TInt SetDirection(SenContext::TContextDirection aDirection); protected: IMPORT_C CSenContext(SenContext::TContextDirection aDirection); IMPORT_C void BaseConstructL(); RCtxItemMap iItems; private: SenContext::TContextDirection iDirection; };# 33 "x:/sf/mw/websrv/webservices/wsframework/inc/senmessagecontext.h" 2# 1 "x:/sf/mw/websrv/webservices/wsframework/inc/msenmessagecontext.h" 1#define M_SEN_MESSAGE_CONTEXT_Hnamespace SenContext { const static TLitC8<sizeof( "urn:com.nokia.serene:message:soap:current" )> KSenCurrentSoapMessageCtxKey ={sizeof( "urn:com.nokia.serene:message:soap:current" )-1, "urn:com.nokia.serene:message:soap:current" }; const static TLitC8<sizeof( "RemoteConsumer" )> KRemoteConsumer ={sizeof( "RemoteConsumer" )-1, "RemoteConsumer" }; }class CSenSoapEnvelope;class CSenSoapMessage;class CSenChunk;class MSenMessageContext : public MSenContext { public: virtual MSenMessage* MessageL() = 0; virtual TInt SetMessage(MSenMessage* apMessage, TBool aOwned = ETrue) = 0; virtual CSenChunk* ChunkL() = 0; virtual TInt SetChunk(CSenChunk* apMsgAsChunk, TBool aOwned = ETrue) = 0; virtual TInt SetProperties(MSenProperties* apProperties, TBool aOwned = ETrue) = 0; virtual MSenProperties* Properties() = 0; virtual TInt Add(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned = ETrue) = 0; virtual TInt Update(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned = ETrue) = 0; virtual MSenMessage* GetMessageL(const TDesC8& aKey) = 0; virtual CSenSoapMessage* GetCurrentSoapMessage() = 0; virtual TPtrC8 GetMessageL() = 0; virtual TInt Add(const TDesC8& aKey, CSenSoapEnvelope* aValue) = 0; virtual TInt Update(const TDesC8& aKey, CSenSoapEnvelope* aValue) = 0; virtual const CSenSoapEnvelope* GetSenSoapEnvelopeL(const TDesC8& aKey) = 0; };# 35 "x:/sf/mw/websrv/webservices/wsframework/inc/senmessagecontext.h" 2class CSenContextItem;class MSenProperties;class CSenXmlReader;class MSenRemoteServiceConsumer;class CSenChunk;class CSenMessageContext : public CSenContext, public MSenMessageContext { public: IMPORT_C static CSenMessageContext* NewL(SenContext::TContextDirection aDirection, MSenProperties* apOwnedTp); IMPORT_C static CSenMessageContext* NewLC(SenContext::TContextDirection aDirection, MSenProperties* apOwnedTp); IMPORT_C virtual ~CSenMessageContext(); virtual MSenMessage* MessageL(); virtual TInt SetMessage(MSenMessage* apMessage, TBool aOwned = ETrue); virtual CSenChunk* ChunkL(); virtual TInt SetChunk(CSenChunk* apMsgAsChunk, TBool aOwned = ETrue); virtual TInt SetProperties(MSenProperties* apProperties, TBool aOwned = ETrue); virtual MSenProperties* Properties(); virtual TInt Add(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned = ETrue); virtual TInt Update(const TDesC8& aKey, MSenMessage* apMessage, TBool aOwned = ETrue); MSenMessage* GetMessageL(const TDesC8& aKey); virtual CSenSoapMessage* GetCurrentSoapMessage(); virtual TPtrC8 GetMessageL(); virtual TInt Add(const TDesC8& aKey, CSenSoapEnvelope* aValue); virtual TInt Update(const TDesC8& aKey, CSenSoapEnvelope* aValue); virtual const CSenSoapEnvelope* GetSenSoapEnvelopeL(const TDesC8& aKey); virtual SenContext::TContextType Type() const; virtual SenContext::TContextDirection Direction() const; virtual TInt Add(const TDesC8& aKey, const TDesC8& aValue); virtual TInt Update(const TDesC8& aKey, const TDesC8& aValue); virtual const TDesC8* GetDesC8L(const TDesC8& aKey); virtual TInt Add(const TDesC8& aKey, TInt aValue); virtual TInt Update(const TDesC8& aKey, TInt aValue); virtual const TInt* GetIntL(const TDesC8& aKey); virtual TInt Add(const TDesC8& aKey, CSenElement* aValue); virtual TInt Update(const TDesC8& aKey, CSenElement* aValue); virtual const CSenElement* GetSenElementL(const TDesC8& aKey); virtual TInt Add(const TDesC8& aKey, TAny* aValue); virtual TInt Update(const TDesC8& aKey, TAny* aValue); virtual TAny* GetAnyL(const TDesC8& aKey); virtual TInt Remove(const TDesC8& aKey); virtual TInt Count() const; virtual TPtrC8 KeyAtL(TInt aIndex); virtual void Reset(); virtual const CSenXmlReader* GetParser(); virtual TInt SetDirection( SenContext::TContextDirection aDirection ); protected: IMPORT_C CSenMessageContext(SenContext::TContextDirection aDirection, MSenProperties* apOwnedTp); IMPORT_C void BaseConstructL(); private: CSenContextItem* MessageToItem(MSenMessage* apMessage, TBool aOwned, TInt& aError); MSenProperties* ipOwnedTp; };# 36 "x:/sf/mw/websrv/webservices/wsmessages/src/sensoapenvelope2.cpp" 2# 1 "x:/epoc32/include/mw/SenXmlProperties.h" 1#define SEN_XML_PROPERTIES_Hclass RWriteStream;class CSenXmlReader;class CSenPropertiesFragment;const static TLitC8<sizeof( "Properties" )> KSenXmlPropertiesLocalname ={sizeof( "Properties" )-1, "Properties" };const static TLitC8<sizeof( "Type" )> KSenTypeAttributeName ={sizeof( "Type" )-1, "Type" };const static TLitC8<sizeof( "Omitted" )> KSenOmittedAttributeName ={sizeof( "Omitted" )-1, "Omitted" };const static TLitC8<sizeof( "" )> KSenOmittedTrueNoValue ={sizeof( "" )-1, "" };const static TLitC8<sizeof( "true" )> KSenPropertyTrue ={sizeof( "true" )-1, "true" };const static TLitC8<sizeof( "false" )> KSenPropertyFalse ={sizeof( "false" )-1, "false" };class CSenXmlProperties : public CBase, public MSenProperties { public: IMPORT_C static CSenXmlProperties* NewL(); IMPORT_C static CSenXmlProperties* NewLC(); IMPORT_C static CSenXmlProperties* NewL(const TDesC8& aXmlUtf8, CSenXmlReader& aParser); IMPORT_C static CSenXmlProperties* NewLC(const TDesC8& aXmlUtf8, CSenXmlReader& aParser); IMPORT_C static CSenXmlProperties* NewL(const CSenElement& aElement); IMPORT_C static CSenXmlProperties* NewLC(const CSenElement& aElement); virtual void SetReader(CSenXmlReader& aReader); virtual TSenPropertiesClassType PropertiesClassType(); virtual void WriteToL(RWriteStream& aWriteStream); virtual void ReadFromL(const TDesC8& aBuffer); virtual HBufC8* AsUtf8L(); virtual HBufC8* AsUtf8LC(); virtual TBool IsSafeToCast(TSenPropertiesClassType aClass); virtual MSenProperties* Clone(TInt& aOkOrError) const; virtual MSenProperties* CloneL() const; virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue); virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue); virtual TInt SetIntPropertyL(const TDesC8& aName, const TInt aValue); virtual TInt IntPropertyL(const TDesC8& aName, TInt& aValue); virtual TInt SetBoolPropertyL(const TDesC8& aName, const TBool aValue); virtual TInt BoolPropertyL(const TDesC8& aName, TBool& aValue); virtual TInt SetOmittedL(const TDesC8& aName, TBool aValue); virtual TInt RemovePropertyL(const TDesC8& aName); virtual ~CSenXmlProperties(); virtual TInt SetPropertyL(const TDesC8& aName, const TDesC8& aValue, const TDesC8& aType); virtual TInt PropertyL(const TDesC8& aName, TPtrC8& aValue, TPtrC8& aType); protected: virtual void BaseConstructL(const TDesC8& aLocalname, const TDesC8& aXml, CSenXmlReader* aParser = NULL); virtual void BaseConstructL(const TDesC8& aNamespace, const TDesC8& aLocalname, const TDesC8& aXml, CSenXmlReader* aParser = NULL); virtual void BaseConstructL(const TDesC8& aNamespace, const TDesC8& aLocalname, const TDesC8& aQualifiedName, const TDesC8& aXml, CSenXmlReader* aParser = NULL); virtual void BaseConstructL(const CSenElement& aElement); protected: CSenXmlProperties(); protected: CSenPropertiesFragment* ipFragment; CSenXmlReader* ipReader; };# 39 "x:/sf/mw/websrv/webservices/wsmessages/src/sensoapenvelope2.cpp" 2 # 1 "x:/sf/mw/websrv/webservices/wsutils/inc/sendebug.h" 1#define SEN_DEBUG_H#define SENDEBUG(parameters)#define SENDEBUG_L(string)#define LOG_CONNECT#define LOG_CREATELOG(parameters)#define LOG_WRITE(parameters)#define LOG_WRITE_L(string)#define LOG_WRITEFORMAT(parameters)#define LOG_CLOSELOG#define LOG_CLOSE#define LOG_WRITEALL(parameters)#define FILELOG(dir, file, string)#define FILELOGAPPEND(dir, file, string)#define FILELOGALL(dir, file, parameters)# 42 "x:/sf/mw/websrv/webservices/wsmessages/src/sensoapenvelope2.cpp" 2# 1 "x:/sf/mw/websrv/webservices/wslogger/inc/senlogger.h" 1#define SEN_LOGGER_H# 1 "x:/epoc32/include/flogger.h" 1#define __FLOGGER_H__const TInt KLogBufferSize=150;class FLogger {public: class TSignal { friend class FLogger; public: inline TSignal() {} inline TInt Set(const TDesC& aCommand); inline TSignal(TRequestStatus& aStatus); inline TPtrC Command() const; private: TRequestStatus* iStatus; TThreadId iId; };public: static TInt Start(); IMPORT_C static TInt Run(TSignal& aSignal);private: static TInt Init(); };enum TFileLoggingMode { EFileLoggingModeUnknown =0, EFileLoggingModeAppend, EFileLoggingModeOverwrite, EFileLoggingModeAppendRaw, EFileLoggingModeOverwriteRaw };class TLogFormatter16Overflow :public TDes16Overflow {public: virtual void Overflow(TDes16& aDes); };class TLogFormatter8Overflow :public TDes8Overflow {public: virtual void Overflow(TDes8& aDes); };class TLogFormatter {public: TLogFormatter(); void SetDateAndTime(TBool aUseDate,TBool aUseTime); TInt FormatTextToWritableBuffer(TDes8& aBuf, const TDesC16& aText) const; TInt FormatTextToWritableBuffer(TDes8& aBuf, const TDesC8& aText) const; TInt ConvertToWritableBuffer(TDes8& aBuf, TRefByValue<const TDesC16> aFmt, VA_LIST& aList); TInt ConvertToWritableBuffer(TDes8& aBuf, TRefByValue<const TDesC8> aFmt, VA_LIST& aList);private: void GetDateAndTimeL(TDes& aDate, TDes& aTime) const; void WriteL(TDes8& aTrg, const TDesC16& aSrc) const; void WriteL(TDes8& aTrg, const TDesC8& aSrc) const;private: TBool iUseDate; TBool iUseTime; TLogFormatter16Overflow iOverflow16; TLogFormatter8Overflow iOverflow8; };class TLogFile {public: TLogFile(); TLogFile(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode); TBool operator==(const TLogFile& aLogFile) const; void Set(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode); inline TBool Valid() const; inline TFileName Directory() const; inline TFileName Name() const; inline TFileLoggingMode Mode() const; inline void SetValid(TBool aValid);private: TBool iValid; TFileName iDirectory; TFileName iName; TFileLoggingMode iMode; };# 1 "x:/epoc32/include/flogger.inl" 1#define __FLOGGER_INL__inline FLogger::TSignal::TSignal(TRequestStatus& aStatus) :iStatus(&aStatus),iId(RThread().Id()) { aStatus=KRequestPending; }inline TPtrC FLogger::TSignal::Command() const { return TPtrC((const TText*)this,sizeof(*this)/sizeof(TText)); }inline TInt FLogger::TSignal::Set(const TDesC& aCommand) { if (aCommand.Size()!=sizeof(*this)) return KErrGeneral; return (Mem::Copy(this,aCommand.Ptr(),sizeof(*this)),KErrNone); }inline TBool TLogFile::Valid() const { return iValid; }inline TFileName TLogFile::Directory() const { return iDirectory; } inline TFileName TLogFile::Name() const { return iName; }inline TFileLoggingMode TLogFile::Mode() const { return iMode; } inline void TLogFile::SetValid(TBool aValid) { iValid=aValid; }# 156 "x:/epoc32/include/flogger.h" 2class RFileLogger : public RSessionBase {public: IMPORT_C RFileLogger(); IMPORT_C ~RFileLogger(); IMPORT_C TVersion Version() const; IMPORT_C TInt Connect(); IMPORT_C void SetDateAndTime(TBool aUseDate,TBool aUseTime); IMPORT_C void CreateLog(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode); IMPORT_C void CloseLog(); IMPORT_C void Write(const TDesC16& aText); IMPORT_C void WriteFormat(TRefByValue<const TDesC16> aFmt,...); IMPORT_C void WriteFormat(TRefByValue<const TDesC16> aFmt, VA_LIST& aList); IMPORT_C void Write(const TDesC8& aText); IMPORT_C void WriteFormat(TRefByValue<const TDesC8> aFmt,...); IMPORT_C void WriteFormat(TRefByValue<const TDesC8> aFmt, VA_LIST& aList); IMPORT_C void HexDump(const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen); IMPORT_C static void Write(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, const TDesC16& aText); IMPORT_C static void WriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue<const TDesC16> aFmt,...); IMPORT_C static void WriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue<const TDesC16> aFmt, VA_LIST& aList); IMPORT_C static void Write(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, const TDesC8& aText); IMPORT_C static void WriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue<const TDesC8> aFmt,...); IMPORT_C static void WriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue<const TDesC8> aFmt, VA_LIST& aList); IMPORT_C static void HexDump(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen); IMPORT_C TInt LastError() const; IMPORT_C TBool LogValid() const; IMPORT_C TBool LogSTI() const;private: TInt DoConnect(); void DoWrite(const TDesC8& aBuf); void DoStaticWrite(const TDesC8& aBuf); void DoWriteFormat(TRefByValue<const TDesC16> aFmt, VA_LIST& aList); void DoWriteFormat(TRefByValue<const TDesC8> aFmt, VA_LIST& aList); static void DoStaticWriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue<const TDesC16> aFmt, VA_LIST& aList); static void DoStaticWriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue<const TDesC8> aFmt, VA_LIST& aList); void DoHexDump(const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen);private: TLogFormatter iFormatter; TLogFile iLogFile; TInt iLastError; TBool iLogSTI; };# 38 "x:/sf/mw/websrv/webservices/wslogger/inc/senlogger.h" 2const TInt KMaxLogLevel =2;const TInt KNormalLogLevel =1;const TInt KMinLogLevel =0;const TInt KSenServiceConnectionLogChannelBase = 1000;const TInt KSenServiceConnectionLogChannel =18000;const TInt KSenServiceConnectionLogLevel =0;const TInt KSenServiceConnectionStatusLogChannelBase = 1100;const TInt KSenServiceConnectionStatusLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenServiceConnectionLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenServiceConn.log" )/2> KSenServiceConnectionLogFile ={sizeof(L"SenServiceConn.log" )/2-1,L"SenServiceConn.log" };const static TLitC<sizeof(L"SenServiceConnStatus.log" )/2> KSenServiceConnectionStatusLogFile ={sizeof(L"SenServiceConnStatus.log" )/2-1,L"SenServiceConnStatus.log" };const TInt KSenServiceManagerLogChannelBase = 2000;const TInt KSenServiceManagerLogChannel = 19000;const TInt KSenServiceManagerLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenServiceManagerLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenServiceMgr.log" )/2> KSenServiceManagerLogFile ={sizeof(L"SenServiceMgr.log" )/2-1,L"SenServiceMgr.log" };const TInt KSenHttpChannelLogChannelBase = 3000;const TInt KSenHttpChannelLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenHttpChannelLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenHttpChannel.log" )/2> KSenHttpChannelLogFile ={sizeof(L"SenHttpChannel.log" )/2-1,L"SenHttpChannel.log" };const TInt KSenHostletConnectionLogChannelBase = 4000;const TInt KSenHostletConnectionLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenHostletConnectionLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenHostletConnection.log" )/2> KSenHostletConnectionLogFile ={sizeof(L"SenHostletConnection.log" )/2-1,L"SenHostletConnection.log" };const TInt KSenCoreServiceManagerLogChannelBase = 5000;const TInt KSenCoreServiceManagerStatusLogChannelBase = 1200;const TInt KSenCoreServiceManagerLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenCoreServiceManagerLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenCoreServiceManagerTLS.log" )/2> KSenCoreServiceManagerLogFile ={sizeof(L"SenCoreServiceManagerTLS.log" )/2-1,L"SenCoreServiceManagerTLS.log" };const TInt KSenFaultsLogChannel = 6000;const TInt KSenFaultsLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenFaults ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenFaults.log" )/2> KSenFaultsLog ={sizeof(L"SenFaults.log" )/2-1,L"SenFaults.log" };const TInt KSenUtilsLogChannel =7000;const TInt KSenUtilsLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenUtils ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenUtils.log" )/2> KSenUtilsLog ={sizeof(L"SenUtils.log" )/2-1,L"SenUtils.log" };const TInt KSenServConnLogChannelBase = 8000;const TInt KSenServConnLogLevel = 0; const static TLitC<sizeof(L"WsLog" )/2> KSenServConn ={sizeof(L"WsLog" )/2-1,L"WsLog" }; const static TLitC<sizeof(L"SenServicePolicy.log" )/2> KSenServConnLog ={sizeof(L"SenServicePolicy.log" )/2-1,L"SenServicePolicy.log" };const TInt KSenHttpChannelObserverLogChannelBase = 9000;const TInt KSenHttpChannelObserverLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenHttpChannelObserverLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenHttpChannelObserver.log" )/2> KSenHttpChannelObserverLogFile ={sizeof(L"SenHttpChannelObserver.log" )/2-1,L"SenHttpChannelObserver.log" };const TInt KSenLocalTransportLogChannelBase = 10000;const TInt KSenLocalTransportLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenLocalTransportLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenLocalTransport.log" )/2> KSenLocalTransportLogFile ={sizeof(L"SenLocalTransport.log" )/2-1,L"SenLocalTransport.log" };const TInt KSenPolicyLogChannelBase = 11000;const TInt KSenPolicyLogLevel = 0; const static TLitC<sizeof(L"WsLog" )/2> KSenPolicyLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" }; const static TLitC<sizeof(L"SenPolicy.log" )/2> KSenPolicyLogFile ={sizeof(L"SenPolicy.log" )/2-1,L"SenPolicy.log" }; const TInt KSenVtcpLogChannelBase = 12000;const TInt KSenVtcpLogLevel = 0; const static TLitC<sizeof(L"WsLog" )/2> KSenVtcpLogFileDir ={sizeof(L"WsLog" )/2-1,L"WsLog" }; const static TLitC<sizeof(L"SenVtcp.log" )/2> KSenVtcpLogFile ={sizeof(L"SenVtcp.log" )/2-1,L"SenVtcp.log" }; const TInt KSenVtcpObserverLogChannelBase = 13000;const TInt KSenVtcpObserverLogLevel = 0; const static TLitC<sizeof(L"WsLog" )/2> KSenVtcpObserverLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" }; const static TLitC<sizeof(L"SenVtcpObserver.log" )/2> KSenVtcpObserverLogFile ={sizeof(L"SenVtcpObserver.log" )/2-1,L"SenVtcpObserver.log" }; const TInt KSenVtcpDispatcherLogChannel = 13500;const TInt KSenVtcpDispatcherLogLevel = 0; const static TLitC<sizeof(L"WsLog" )/2> KSenVtcpDispatcherLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" }; const static TLitC<sizeof(L"SenVtcpDispatcher.log" )/2> KSenVtcpDispatcherLogFile ={sizeof(L"SenVtcpDispatcher.log" )/2-1,L"SenVtcpDispatcher.log" };const TInt KSenMessagesLogChannel = 14000;const TInt KSenMessagesLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenMessages ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenMessages.log" )/2> KSenMessagesLog ={sizeof(L"SenMessages.log" )/2-1,L"SenMessages.log" };const TInt KSenCredsLogChannel = 15000;const TInt KSenCredsLogLevelMin = 1;const TInt KSenCredsLogLevelNormal = 2;const TInt KSenCredsLogLevelMax = 3;const static TLitC<sizeof(L"WsLog" )/2> KSenCreds ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenCreds.log" )/2> KSenCredsLog ={sizeof(L"SenCreds.log" )/2-1,L"SenCreds.log" };const TInt KSenXmlLogChannel = 16000;const TInt KSenXmlLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenXml ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenXml.log" )/2> KSenXmlLog ={sizeof(L"SenXml.log" )/2-1,L"SenXml.log" };const TInt KSenClientSessionLogChannelBase = 17000;const TInt KSenClientSessionLogLevel =0;const TInt KHostletTransportLogChannel = 20000;const TInt KHostletTransportLogLevel = 0; const static TLitC<sizeof(L"WsLog" )/2> KLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenHostletTransport.log" )/2> KLogFile ={sizeof(L"SenHostletTransport.log" )/2-1,L"SenHostletTransport.log" };const TInt KSenNcimLogChannelAsync = 21000;const TInt KSenNcimLogChannelMsg = 21001;const TInt KSenNcimLogChannelGeneral = 21002;const TInt KSenNcimLogLevel = 0; const static TLitC<sizeof(L"WsLog" )/2> KSenNcimLogDir ={sizeof(L"WsLog" )/2-1,L"WsLog" }; const static TLitC<sizeof(L"SenNcimAsync.log" )/2> KSenNcimLogFileAsync ={sizeof(L"SenNcimAsync.log" )/2-1,L"SenNcimAsync.log" }; const static TLitC<sizeof(L"SenNcimMsg.log" )/2> KSenNcimLogFileMsg ={sizeof(L"SenNcimMsg.log" )/2-1,L"SenNcimMsg.log" }; const static TLitC<sizeof(L"SenNcimGen.log" )/2> KSenNcimLogFileGen ={sizeof(L"SenNcimGen.log" )/2-1,L"SenNcimGen.log" }; const TInt KSenDispatcherLogChannel = 22000;const TInt KSenDispatcherLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KSenDispactherThread ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"SenDispatcherThread.log" )/2> KSenDispactherThreadLog ={sizeof(L"SenDispatcherThread.log" )/2-1,L"SenDispatcherThread.log" }; const TInt KPoasFilterLogChannel = 30000;const TInt KPoasFilterLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KPoasLogFileDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"WsPaosFilter.log" )/2> KPoasLogFileName ={sizeof(L"WsPaosFilter.log" )/2-1,L"WsPaosFilter.log" }; const TInt KWsHttpFilterLogChannel = 31000;const TInt KWsHttpFilterLogLevel = 0;const static TLitC<sizeof(L"WsLog" )/2> KWsHttpFilterLogFileDir ={sizeof(L"WsLog" )/2-1,L"WsLog" };const static TLitC<sizeof(L"WsHttpFilter.log" )/2> KWsHttpFilterLogFileName ={sizeof(L"WsHttpFilter.log" )/2-1,L"WsHttpFilter.log" };class CSenLogger;class CWSConnectionProxy;typedef struct { RFileLogger iLog; TInt iCount; TInt iChannel; TInt iLevel; } TLog;typedef struct { CSenLogger* iLogger; CWSConnectionProxy* iProxy; } TWsTls;class CSenLogger : public CBase { public: IMPORT_C static TInt CreateL(TInt aChannel, TInt aLevel, const TDesC& aLogDir, const TDesC& aLogFileName); IMPORT_C static TInt CreateL(TInt aChannel, TInt aLevel, const TDesC& aLogDir, const TDesC& aLogFileName, TFileLoggingMode aMode); IMPORT_C static void Destroy(TInt aChannel); IMPORT_C static void Write(TInt aChannel, TInt aLevel, const TDesC8& aText); IMPORT_C static void WriteAll(TInt aChannel, TInt aLevel, const TDesC8& aText); IMPORT_C static void WriteFormat(TInt aChannel, TInt aLevel, TRefByValue<const TDesC8> aFmt,...); IMPORT_C static void WriteFormat(TInt aChannel, TInt aLevel, TRefByValue<const TDesC8> aFmt, VA_LIST& aList); IMPORT_C static void WriteWithClientId(TInt aClientId, TInt aChannel, TInt aLevel, const TDesC8& aText); IMPORT_C static void WriteAllWithClientId(TInt aClientId, TInt aChannel, TInt aLevel, const TDesC8& aText); IMPORT_C static void WriteFormatWithClientId(TInt aClientId, TInt aChannel, TInt aLevel, TRefByValue<const TDesC8> aFmt,...); IMPORT_C static void WriteFormatWithClientId(TInt aClientId, TInt aChannel, TInt aLevel, TRefByValue<const TDesC8> aFmt, VA_LIST& aList); IMPORT_C static void WriteFormatWithClientIdToMainLogs(TInt aClientId, TInt aLevel, TRefByValue<const TDesC8> aFmt,...); IMPORT_C static void WriteFormatWithClientIdToMainLogs(TInt aClientId, TInt aLevel, TRefByValue<const TDesC8> aFmt, VA_LIST& aList); IMPORT_C static void Write(TInt aChannel, TInt aLevel, const TDesC16& aText); IMPORT_C static void WriteAll(TInt aChannel, TInt aLevel, const TDesC16& aText); IMPORT_C static void WriteFormat(TInt aChannel, TInt aLevel, TRefByValue<const TDesC16> aFmt,...); IMPORT_C static void WriteFormat(TInt aChannel, TInt aLevel, TRefByValue<const TDesC16> aFmt, VA_LIST& aList); IMPORT_C static void WriteWithClientId(TInt aClientId, TInt aChannel, TInt aLevel, const TDesC16& aText); IMPORT_C static void WriteAllWithClientId(TInt aClientId, TInt aChannel, TInt aLevel, const TDesC16& aText); IMPORT_C static void WriteFormatWithClientId(TInt aClientId, TInt aChannel, TInt aLevel, TRefByValue<const TDesC16> aFmt,...); IMPORT_C static void WriteFormatWithClientId(TInt aClientId, TInt aChannel, TInt aLevel, TRefByValue<const TDesC16> aFmt, VA_LIST& aList); IMPORT_C static void WriteFormatWithClientIdToMainLogs(TInt aClientId, TInt aLevel, TRefByValue<const TDesC16> aFmt,...); IMPORT_C static void WriteFormatWithClientIdToMainLogs(TInt aClientId, TInt aLevel, TRefByValue<const TDesC16> aFmt, VA_LIST& aList); private: TInt ChannelIndex(TInt aChannel) const; static RFileLogger* Logger(TInt aChannel, TInt aLevel); IMPORT_C CSenLogger(); virtual ~CSenLogger(); private: TInt iCount; RPointerArray<TLog> iLogs; RSenPointerMap<TInt,TInt> iMap; }; #define TLSLOG_OPEN(channel, level, logdir, logfile)#define TLSLOG_OPEN_TO_MODE(channel, level, logdir, logfile, loggingmode)#define TLSLOG_L(channel, level, string)#define TLSLOG(channel, level, string)#define TLSLOG_ALL(channel, level, string)#define TLSLOG_FORMAT(parameters)#define TLSLOG_CLOSE(channel)#define CSLOG(clientid, level, string)#define CSLOG_L(clientid, level, string)#define CSLOG_FORMAT(parameters)#define CSLOG_ALL(clientid, level, string) #define CSLOG(clientid, level, string)#define CSLOG_L(clientid, level, string)#define CSLOG_FORMAT(parameters)#define CSLOG_ALL(clientid, level, string) #define CREDLOG_OPEN()#define CREDLOG_L(level, string)#define CREDLOG(level, string)#define CREDLOG_ALL(level, string)#define CREDLOG_FORMAT(parameters)#define CREDLOG_CLOSE()# 43 "x:/sf/mw/websrv/webservices/wsmessages/src/sensoapenvelope2.cpp" 2# 1 "x:/sf/mw/websrv/webservices/wsfragment/inc/wslibxml2utils.h" 1#define WS_LIBXML2_UTILS_H_INCLUDEDclass WsXmlUtils{ public: IMPORT_C void XmlEngRenameElementL(TXmlEngElement aElement, const TDesC8& aLocalName, const TDesC8& aNamespaceUri, const TDesC8& aPrefix); };# 44 "x:/sf/mw/websrv/webservices/wsmessages/src/sensoapenvelope2.cpp" 2 EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewL() { ; CSenSoapEnvelope2* pNew = CSenSoapEnvelope2::NewLC(); CleanupStack::Pop( pNew ); return pNew; } EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewLC() { ; CSenSoapEnvelope2* pNew = new (ELeave) CSenSoapEnvelope2(); CleanupStack::PushL(pNew); pNew->BaseConstructL(); return pNew; } EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewL(MSenMessageContext& aContext) { ; CSenSoapEnvelope2* pNew = CSenSoapEnvelope2::NewLC(aContext); CleanupStack::Pop(pNew); return pNew; } EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewLC(MSenMessageContext& aContext) { ; CSenSoapEnvelope2* pNew = new (ELeave) CSenSoapEnvelope2(); CleanupStack::PushL(pNew); pNew->BaseConstructL(aContext); return pNew; } EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewL(CSenSoapEnvelope2& aEnvelope) { ; CSenSoapEnvelope2* pNew = CSenSoapEnvelope2::NewLC(aEnvelope); CleanupStack::Pop(pNew); return pNew; } EXPORT_C CSenSoapEnvelope2* CSenSoapEnvelope2::NewLC(CSenSoapEnvelope2& aEnvelope) { ; CSenSoapEnvelope2* pNew = new (ELeave) CSenSoapEnvelope2(); CleanupStack::PushL(pNew); pNew->BaseConstructL(aEnvelope); return pNew; } EXPORT_C void CSenSoapEnvelope2::BaseConstructL(TSOAPVersion aVersion) { if (aVersion != ESOAP12) { CSenFragmentBase::BaseConstructL(KSenSoapEnvelopeXmlns, KSenSoapEnvelopeName, KSenSoapEnvelopePrefix); } else { CSenFragmentBase::BaseConstructL(KSenSoap12EnvelopeXmlns, KSenSoapEnvelopeName, KSenSoapEnvelopePrefix); } } EXPORT_C void CSenSoapEnvelope2::BaseConstructL(MSenMessageContext& aContext) { ipNotOwnedContext = &aContext; BaseConstructL(ESOAP11); } EXPORT_C void CSenSoapEnvelope2::BaseConstructL(MSenMessageContext& aContext, TSOAPVersion aVersion) { ipNotOwnedContext = &aContext; BaseConstructL(aVersion); } EXPORT_C void CSenSoapEnvelope2::BaseConstructL() { BaseConstructL(ESOAP11); } EXPORT_C void CSenSoapEnvelope2::BaseConstructL(CSenSoapEnvelope2& aEnvelope) { CSenFragmentBase::BaseConstructL(aEnvelope.AsElementL()); iTransactionId = aEnvelope.iTransactionId; ipNotOwnedContext = aEnvelope.ipNotOwnedContext; iFault = aEnvelope.iFault; iDirection = aEnvelope.iDirection; ipNotOwnedContext = aEnvelope.ipNotOwnedContext; if ( aEnvelope.ipSoapAction ) { ipSoapAction = aEnvelope.ipSoapAction->AllocL(); } if ( aEnvelope.ipBodyFragment ) { TXmlEngElement envelope = AsElementL(); TXmlEngElement body; RXmlEngNodeList<TXmlEngElement> list; CleanupClosePushL(list); envelope.GetElementsByTagNameL(list, KSenSoapEnvelopeBodyName, NsUri()); if ( list.Count() > 0 ) { body = list.Next(); ipBodyFragment = CSenFragmentBase::NewL(body, AsDocumentL()); } CleanupStack::PopAndDestroy(&list); } if ( aEnvelope.ipHeaderFragment ) { TXmlEngElement envelope = AsElementL(); TXmlEngElement header; RXmlEngNodeList<TXmlEngElement> list; CleanupClosePushL(list); envelope.GetElementsByTagNameL(list, KSenSoapEnvelopeHeaderName, NsUri()); if ( list.Count() > | ipHeaderFragment | [static] |