diff -r 000000000000 -r 62f9d29f7211 webservices/wsframework/inc/senprovider.inl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsframework/inc/senprovider.inl	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,229 @@
+/*
+* Copyright (c) 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:    Header declaration
+*
+*/
+
+
+
+
+
+
+
+
+// Interface's (abstract base class's) static factory method implementation.
+// Asks ECOM plug-in framework to instantiate appropriate concrete plug-in
+// implementation.
+
+// What to do if there are NO providers to be found - should there always be a 
+// "dummy" provider?
+
+inline CSenProvider* CSenProvider::NewL()
+    {
+    // Wish to instantiate the default provider - just a test provider...
+    const TUid KTestProviderUid = {0x10273114};
+    
+    // Find implementation behind KTestProviderUid.
+    TAny* intf = REComSession::CreateImplementationL(KTestProviderUid, 
+        _FOFF (CSenProvider, 
+        iDtor_ID_Key), 
+        NULL);
+
+    if(intf)
+        {
+        CSenProvider* provider = reinterpret_cast <CSenProvider*> (intf);
+        CleanupStack::PushL(provider);
+        provider->iCriticalSection.CreateLocal();
+        _LIT8(KTestProviderCue, "local://com.nokia.provider/TestProvider");
+        provider->iCue=KTestProviderCue().AllocL();
+        CleanupStack::Pop(); // provider
+        }
+
+    return reinterpret_cast <CSenProvider*> (intf);
+    }
+
+// Interface's (abstract base class's) static factory method implementation.
+// Asks ECOM plug-in framework to instantiate appropriate concrete plug-in
+// implementation.
+inline CSenProvider* CSenProvider::NewL(const TDesC8& aCue)
+    {
+#ifndef RD_SEN_COMPILE_SIS_PACKAGE_FILES     
+    const TUid KUidSenHostletPlugin = { 0x02000502 };
+#else
+    const TUid KUidSenHostletPlugin = { 0x10282C5D };
+#endif    
+    
+    TEComResolverParams resolverParams;
+    resolverParams.SetDataType(aCue);
+    resolverParams.SetWildcardMatch(EFalse);
+    
+    // Find implementation for our interface.
+    
+    TAny* intf = REComSession::CreateImplementationL(KUidSenHostletPlugin,
+        _FOFF (CSenProvider, iDtor_ID_Key), 
+        NULL, 
+        resolverParams); 
+    
+    if(intf)
+        {
+        CSenProvider* provider = reinterpret_cast <CSenProvider*> (intf);
+        provider->iCriticalSection.CreateLocal();
+        CleanupStack::PushL(provider);
+        provider->iCue = aCue.AllocL();
+        CleanupStack::Pop(); // provider
+        }
+    
+    return reinterpret_cast<CSenProvider*> (intf);
+    }
+
+
+// Interface's (abstract base class's) destructor
+inline CSenProvider::~CSenProvider()
+    {
+    // If in the NewL some memory is reserved for member data, it must be
+    // released here. This interface does not have any instance variables so
+    // no need to delete anything.
+    
+    // Inform the ECOM framework that this specific instance of the
+    // interface has been destroyed.
+    REComSession::DestroyedImplementation (iDtor_ID_Key);
+    delete iCue;
+    iCue = NULL;
+    iCriticalSection.Close();
+    }
+
+inline TPtrC8 CSenProvider::Endpoint() const
+    {
+    if(iCue)
+        return *iCue;
+    else
+        return KNullDesC8();
+    }
+
+// protected
+inline void CSenProvider::DescribeServiceL(CSenWSDescription& aSD)
+    {
+    aSD.SetEndPointL(Endpoint());
+    aSD.SetContractL(Contract());
+    aSD.SetFrameworkIdL(FrameworkId());
+      
+    if(Exposed())
+        {
+        CSenFacet* pExposed = CSenFacet::NewL();
+        CleanupStack::PushL(pExposed);
+        pExposed->SetNameL(KExposeLocalServiceFacet); // from MSenServiceDescription.h
+        aSD.SetFacetL(*pExposed);
+        CleanupStack::PopAndDestroy(); // pExposed
+        }
+    
+    if(Sharable())
+        {
+        CSenFacet* pSharable = CSenFacet::NewL();
+        CleanupStack::PushL(pSharable);
+        pSharable->SetNameL(KProviderSharableFacet);
+        aSD.SetFacetL(*pSharable);
+        CleanupStack::PopAndDestroy(); // pSharable
+
+       }
+    
+    if(CompleteClientMessages())
+        {
+        CSenFacet* pCompleteClientMsgs = CSenFacet::NewL();
+        CleanupStack::PushL(pCompleteClientMsgs);
+        pCompleteClientMsgs->SetNameL(KProviderCompleteClientMsgsFacet);
+        aSD.SetFacetL(*pCompleteClientMsgs);
+        CleanupStack::PopAndDestroy(); // pCompleteClientMsgs
+        }
+
+    if(LoadOnStartup())
+        {
+        CSenFacet* pLoadOnStartup = CSenFacet::NewL();
+        CleanupStack::PushL(pLoadOnStartup);
+        pLoadOnStartup->SetNameL(KProviderLoadOnStartupFacet);
+        aSD.SetFacetL(*pLoadOnStartup);
+        CleanupStack::PopAndDestroy(); // pLoadOnStartup
+        }
+
+    if(Threadsafe())
+        {
+        CSenFacet* pThreadsafe = CSenFacet::NewL();
+        CleanupStack::PushL(pThreadsafe);
+        pThreadsafe->SetNameL(KProviderThreadsafeFacet);
+        aSD.SetFacetL(*pThreadsafe);
+        CleanupStack::PopAndDestroy(); // pLoadOnStartup
+        }
+    
+    if(Reinitializable())
+        {
+        CSenFacet* pReinitializable = CSenFacet::NewL();
+        CleanupStack::PushL(pReinitializable);
+        pReinitializable->SetNameL(KProviderReinitializableFacet);
+        aSD.SetFacetL(*pReinitializable);
+        CleanupStack::PopAndDestroy(); // pReinitializable
+        }
+    
+    if(StayOnBackground())
+        {
+        CSenFacet* pStayOnBackgroudnd = CSenFacet::NewL();
+        CleanupStack::PushL(pStayOnBackgroudnd);
+        pStayOnBackgroudnd->SetNameL(KProviderStayOnBackgroundFacet);
+        aSD.SetFacetL(*pStayOnBackgroudnd);
+        CleanupStack::PopAndDestroy(); // pStayOnBackgroudnd
+        }
+    }
+  
+inline TBool CSenProvider::Exposed() const
+    {
+    return EFalse;
+    }
+    
+inline TBool CSenProvider::Sharable() const
+    {
+    return EFalse;
+    }
+
+inline TBool CSenProvider::CompleteClientMessages() const
+    {
+    return EFalse;
+    }
+
+
+inline TBool CSenProvider::LoadOnStartup() const
+    {
+    return EFalse;
+    }
+
+inline TBool CSenProvider::Threadsafe() const
+    {
+    return ETrue;
+    }
+
+inline TBool CSenProvider::Reinitializable() const
+    {
+    return EFalse;
+    }
+
+inline TBool CSenProvider::StayOnBackground() const
+    {
+    return EFalse;
+    }
+
+inline TInt CSenProvider::ReinitL()
+    {
+    return KErrNotSupported;
+    }
+
+// END OF FILE
+
+