diff -r 000000000000 -r 62f9d29f7211 webservices/wsprovider/src/senhostletresponse.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsprovider/src/senhostletresponse.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,266 @@
+/*
+* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:           
+*
+*/
+
+
+
+
+
+
+
+
+
+
+
+#include "senhostletresponse.h"
+
+#include <SenHttpTransportProperties.h>
+#include "senvtcptransportproperties.h"
+#include <SenParser.h>
+
+#include <MSenProperties.h>
+#include <MSenMessage.h>
+#include "senmessagecontext.h"
+#include "SenSoapMessage2.h"
+
+//using namespace SenContext;
+
+EXPORT_C CSenHostletResponse* CSenHostletResponse::NewL(const TInt aRequestId)
+    {
+    CSenHostletResponse* pNew = CSenHostletResponse::NewLC(aRequestId);
+    CleanupStack::Pop();
+    return pNew;
+    }
+
+EXPORT_C CSenHostletResponse* CSenHostletResponse::NewLC(const TInt aRequestId)
+    {
+    CSenHostletResponse* pNew = new(ELeave) CSenHostletResponse(aRequestId);
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL();
+    return pNew;
+    }
+
+void CSenHostletResponse::BaseConstructL()
+    {
+    }
+
+CSenHostletResponse::CSenHostletResponse(const TInt aRequestId)
+: iRequestId(aRequestId),
+  iResponseCode(KErrNone),
+  ipOwnedResponseUtf8(NULL),
+  ipMessageContext(NULL)
+    {
+    }
+    
+EXPORT_C CSenHostletResponse::~CSenHostletResponse()
+    {
+    delete ipOwnedResponseUtf8;
+    ipOwnedResponseUtf8 = NULL;
+    delete ipMessageContext;
+    ipMessageContext = NULL;
+    }
+
+EXPORT_C void CSenHostletResponse::SetResponseUtf8L(const TDesC8& aResponseBodyUtf8,
+                                                    const TInt aResponseCode,
+                                                    MSenProperties* apResponseProperties,
+                                                    MSenMessage* apMessage)
+    {
+    HBufC8* pTemp = aResponseBodyUtf8.AllocL();
+    iResponseCode = aResponseCode;
+    delete ipOwnedResponseUtf8;
+    ipOwnedResponseUtf8 = NULL;
+    ipOwnedResponseUtf8 = pTemp;
+    
+
+    TInt error(KErrNone);
+    MSenProperties* p = NULL;
+    if( apResponseProperties && apResponseProperties->PropertiesClassType() != MSenProperties::ENotInUse )
+        {
+        p = apResponseProperties->Clone(error);
+        }
+
+    if( p )
+        {
+        // Create new message context
+        delete ipMessageContext;  
+        ipMessageContext = NULL;
+        MessageContextL( p );
+        }
+    else
+        {
+        MessageContextL();
+        }
+        
+    MSenMessageContext& ctx = MessageContextL();
+    MSenMessage* pMessage = NULL;
+    if( !apMessage ) 
+        {
+        pMessage = CSenSoapMessage2::NewL( ctx ); // ctx holds the transport properties, if such exist
+        ctx.SetMessage(pMessage, ETrue);
+        }
+    else
+        {
+        pMessage = apMessage->CloneL();
+        ctx.SetMessage(pMessage, ETrue);
+        }        
+    
+    // Set the message into context, with possible properties..
+    error = 0; // not used in release builds
+    
+/*
+    MSenProperties* pResponseProperties = NULL;
+    
+    if( apResponseProperties && apResponseProperties->PropertiesClassType() != MSenProperties::ENotInUse )
+        {
+        switch(apResponseProperties->PropertiesClassType())
+            {
+            case MSenProperties::ENotInUse:
+                {
+                break;
+                }
+                
+            
+            case MSenProperties::ESenXmlProperties:
+            case MSenProperties::ESenLayeredXmlProperties: // flatten the props
+                {
+                pResponseProperties = CSenXmlProperties::NewL(); // iSerializedMessage, *pReader);
+                break;
+                }
+            case MSenProperties::ESenTransportProperties:
+            case MSenProperties::ESenLayeredTransportProperties: // flatten the props
+                {
+                pResponseProperties = CSenTransportProperties::NewL();
+                break;
+                }
+            case MSenProperties::ESenHttpTransportProperties:
+            case MSenProperties::ESenLayeredHttpTransportProperties: // flatten the props
+                {
+                pResponseProperties = CSenHttpTransportProperties::NewL();
+                break;
+                }
+            case MSenProperties::ESenVtcpTransportProperties:
+            case MSenProperties::ESenLayeredVtcpTransportProperties: // flatten the props
+                {
+                pResponseProperties = CSenVtcpTransportProperties::NewL();
+                break;
+                }
+            default: 
+                {
+                break;
+                }
+            }
+            
+        if( ipResponseProperties )  
+            {
+            HBufC8* pSerializedProperties = apResponseProperties->AsUtf8LC();
+            if (pSerializedProperties && pSerializedProperties->Length()>0)
+                {
+                TRAPD( err, ipResponseProperties->ReadFromL(*pSerializedProperties); ) // suppress any parsing leave
+                TInt unused(err);
+                err = unused;
+                }
+            CleanupStack::PopAndDestroy(pSerializedProperties);
+            }
+        }
+*/
+    }
+
+
+EXPORT_C MSenProperties* CSenHostletResponse::ResponseProperties()
+    {
+    TInt leaveCode(KErrNone);
+    MSenMessageContext* pCtx = NULL;
+    MSenMessage* pMessage = NULL;
+    TRAP( leaveCode, pCtx = &(MessageContextL()); )
+    if( !leaveCode && pCtx )
+        {
+        TRAP( leaveCode, pMessage = pCtx->MessageL(); )
+        //pMessage = pCtx->Message();
+        if( !leaveCode && pMessage )
+            {
+            return pMessage->Properties();
+            }
+        }
+    return NULL; // not found
+    }
+    
+EXPORT_C MSenMessage* CSenHostletResponse::ResponseMessageL()
+    {
+    TInt leaveCode(KErrNone);
+    MSenMessage* pMsg = NULL;
+    TRAP( leaveCode,  pMsg = MessageContextL().MessageL(); )
+    if( leaveCode == KErrNone )
+        {
+        return pMsg;
+        }
+    leaveCode = 0; // ignored
+    return NULL;        
+    }
+    
+
+EXPORT_C HBufC8* CSenHostletResponse::ExtractResponseUtf8()
+    {
+    HBufC8* pResult = ipOwnedResponseUtf8;
+    ipOwnedResponseUtf8 = NULL;
+    return pResult;
+    }
+
+
+EXPORT_C TPtrC8 CSenHostletResponse::ResponseUtf8()
+    {
+    if(ipOwnedResponseUtf8)
+        {
+        return *ipOwnedResponseUtf8;
+        }
+    else
+        {
+        return KNullDesC8();
+        }
+    }
+
+EXPORT_C TInt CSenHostletResponse::RequestId() const
+    {
+    return iRequestId;
+    }
+
+EXPORT_C TInt CSenHostletResponse::ResponseCode() const
+    {
+    return iResponseCode;
+    }
+
+
+MSenMessageContext& CSenHostletResponse::MessageContextL(MSenProperties* apProperties)
+    {
+    if( !ipMessageContext )
+        {
+        if( apProperties )
+            ipMessageContext = CSenMessageContext::NewL(SenContext::EOutgoing, apProperties);
+        else
+            {
+            CSenXmlProperties* p = CSenXmlProperties::NewL();
+            CleanupStack::PushL(p);
+            ipMessageContext = CSenMessageContext::NewL(SenContext::EOutgoing, p);
+            CleanupStack::Pop(p);
+            }
+        }
+    return *ipMessageContext;
+    }
+    
+    
+// END OF FILE
+
+
+