--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/idwsfplugin/src/idwsfserviceinstance.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,521 @@
+/*
+* Copyright (c) 2004 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 <SenXmlUtils.h>
+#include <SenCredential.h>
+#include <SenFacet.h>
+#include <SenServiceConnection.h>
+#include <SenXmlElement.h>
+
+#include "idwsfserviceinstance.h"
+
+namespace
+ {
+ const TInt KFLATBUF_SIZE = 128;
+ }
+
+CIdWsfServiceInstance* CIdWsfServiceInstance::NewL()
+ {
+ CIdWsfServiceInstance* pNew = CIdWsfServiceInstance::NewLC();
+ CleanupStack::Pop(); // pNew
+ return pNew;
+ }
+
+CIdWsfServiceInstance* CIdWsfServiceInstance::NewLC()
+ {
+ CIdWsfServiceInstance* pNew = new (ELeave) CIdWsfServiceInstance;
+ CleanupStack::PushL(pNew);
+ pNew->ConstructL(KNullDesC8(), KNullDesC8());
+ return pNew;
+ }
+
+CIdWsfServiceInstance* CIdWsfServiceInstance::NewL(const TDesC8& aUri)
+ {
+ CIdWsfServiceInstance* pNew = CIdWsfServiceInstance::NewLC(aUri);
+ CleanupStack::Pop(); // pNew
+ return pNew;
+ }
+
+CIdWsfServiceInstance* CIdWsfServiceInstance::NewLC(const TDesC8& aUri)
+ {
+ CIdWsfServiceInstance* pNew = new (ELeave) CIdWsfServiceInstance;
+ CleanupStack::PushL(pNew);
+ pNew->ConstructL(aUri, KNullDesC8());
+ return pNew;
+ }
+
+CIdWsfServiceInstance* CIdWsfServiceInstance::NewL(
+ CIdWsfServiceInstance& aTemplate)
+ {
+ CIdWsfServiceInstance* pNew = CIdWsfServiceInstance::NewLC(aTemplate);
+ CleanupStack::Pop(); // pNew
+ return pNew;
+ }
+
+CIdWsfServiceInstance* CIdWsfServiceInstance::NewLC(
+ CIdWsfServiceInstance& aTemplate)
+ {
+ CIdWsfServiceInstance* pNew = new (ELeave) CIdWsfServiceInstance;
+ CleanupStack::PushL(pNew);
+ pNew->ConstructL(aTemplate.ServiceType(), aTemplate.ProviderId());
+ return pNew;
+ }
+
+CIdWsfServiceInstance::CIdWsfServiceInstance() :
+ CSenWSDescription( EIdWsfServiceInstance ),
+ ipProviderId( NULL ),
+ ipEndpoint( NULL ),
+ ipServiceType( NULL ),
+ ipResourceId( NULL ),
+ ipMechanisms( NULL ),
+ ipCredentialRefs( NULL )
+ {
+ }
+
+void CIdWsfServiceInstance::ConstructL(const TDesC8& aUri,
+ const TDesC8& aProviderId)
+ {
+ CSenDomFragment::BaseConstructL(NewElementName());
+
+ HBufC8* pNew = NULL;
+ if (aUri != KNullDesC8)
+ {
+ pNew = aUri.AllocL();
+ }
+ ipServiceType = pNew;
+ SetProviderIdL(aProviderId);
+ }
+
+CIdWsfServiceInstance::~CIdWsfServiceInstance()
+ {
+ delete ipProviderId;
+ delete ipResourceId;
+ delete ipEndpoint;
+
+ delete ipServiceType;
+ delete ipMechanisms;
+ delete ipCredentialRefs;
+
+ iCredentialList.ResetAndDestroy();
+ iFacets.ResetAndDestroy();
+ }
+
+TBool CIdWsfServiceInstance::Matches(
+ MSenServiceDescription& aOtherServiceDescription)
+ {
+ TPtrC8 patternEndpoint = aOtherServiceDescription.Endpoint();
+ TPtrC8 thisEndpoint = Endpoint();
+
+ if(patternEndpoint.Length()>0)
+ {
+ if(!(thisEndpoint.Length()>0 && patternEndpoint == thisEndpoint))
+ {
+ return EFalse;
+ }
+ }
+
+ TPtrC8 patternContract = aOtherServiceDescription.Contract();
+ TPtrC8 thisContract = Contract();
+
+ if(patternContract.Length()>0)
+ {
+ if(!(thisContract.Length()>0 && patternContract == thisContract))
+ {
+ return EFalse;
+ }
+ }
+ return ETrue;
+ }
+
+TBool CIdWsfServiceInstance::Matches(
+ CIdWsfServiceInstance& aOtherServiceInstance)
+ {
+ if (!Matches((MSenServiceDescription&)aOtherServiceInstance)) return EFalse;
+
+ TPtrC8 patternProvider = aOtherServiceInstance.ProviderId();
+ TPtrC8 thisProvider = ProviderId();
+
+ if(patternProvider.Length()>0)
+ {
+ if(!(thisProvider.Length()>0 && patternProvider == thisProvider))
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+
+TPtrC8 CIdWsfServiceInstance::Contract()
+ {
+ if (ipServiceType)
+ return *ipServiceType;
+ else
+ return KNullDesC8();
+ }
+
+TPtrC8 CIdWsfServiceInstance::FrameworkId()
+ {
+ return KDefaultIdWsfFrameworkID();
+ }
+
+TPtrC8 CIdWsfServiceInstance::FrameworkVersion()
+ {
+ return KIdWsfFrameworkVersion();
+ }
+
+void CIdWsfServiceInstance::SetContractL(const TDesC8& aContract)
+ {
+ HBufC8* pNew = NULL;
+ if(aContract.Length()>0)
+ pNew = aContract.AllocL();
+
+ delete ipServiceType;
+ ipServiceType = pNew;
+ }
+
+void CIdWsfServiceInstance::WriteAsXMLToL(RWriteStream& /* aWriteStream */)
+ {
+ // Nothing to do, because for ID-WSF we never save ServiceInstances,
+ // only sessions.
+ return;
+ }
+
+HBufC* CIdWsfServiceInstance::AsXmlUnicodeL()
+ {
+ // Nothing to do, because for ID-WSF we never save ServiceInstances,
+ // only sessions.
+ // note: could return NULL
+ return KNullDesC().AllocL();
+ }
+
+HBufC8* CIdWsfServiceInstance::AsXmlL()
+ {
+ // Nothing to do, because for ID-WSF we never save ServiceInstances,
+ // only sessions.
+ // note: could return NULL
+ return KNullDesC8().AllocL();
+ }
+
+TPtrC8 CIdWsfServiceInstance::ProviderId()
+ {
+ if(ipProviderId)
+ return *ipProviderId;
+ else
+ return KNullDesC8();
+ }
+
+TPtrC8 CIdWsfServiceInstance::ResourceId()
+ {
+ if (ipResourceId)
+ return *ipResourceId;
+ else
+ return KNullDesC8();
+ }
+
+TPtrC8 CIdWsfServiceInstance::Endpoint()
+ {
+ if (ipEndpoint)
+ return *ipEndpoint;
+ else
+ return KNullDesC8();
+ }
+
+TPtrC8 CIdWsfServiceInstance::ServiceType()
+ {
+ if (ipServiceType)
+ return *ipServiceType;
+ else
+ return KNullDesC8();
+ }
+
+TInt CIdWsfServiceInstance::SetProviderIdL( const TDesC8& aURI )
+ {
+ TInt retVal( KErrNone );
+ HBufC8* pNew = NULL;
+ if( aURI.Length() > 0 )
+ {
+ pNew = aURI.AllocL();
+ }
+// else
+// {
+// retVal = KErrArgument;
+// }
+ delete ipProviderId;
+ ipProviderId = pNew;
+ return retVal;
+ }
+
+void CIdWsfServiceInstance::SetResourceIdL( const TDesC8& aURI )
+ {
+ HBufC8* pNew = NULL;
+ if(aURI.Length()>0)
+ pNew = aURI.AllocL();
+ delete ipResourceId;
+ ipResourceId = pNew;
+ }
+
+void CIdWsfServiceInstance::SetEndPointL(const TDesC8& aURI)
+ {
+ HBufC8* pNew = NULL;
+ if(aURI.Length()>0)
+ pNew = aURI.AllocL();
+ delete ipEndpoint;
+ ipEndpoint = pNew;
+ }
+
+void CIdWsfServiceInstance::SetServiceTypeL(const TDesC8& aURI)
+ {
+ HBufC8* pNew = NULL;
+ if(aURI.Length()>0)
+ pNew = aURI.AllocL();
+ delete ipServiceType;
+ ipServiceType = pNew;
+ }
+
+CDesC8Array& CIdWsfServiceInstance::MechanismsL()
+ {
+ if(!ipMechanisms)
+ {
+ ipMechanisms = new (ELeave) CDesC8ArrayFlat(KFLATBUF_SIZE);
+ }
+ return *ipMechanisms;
+ }
+
+CDesC8Array& CIdWsfServiceInstance::CredentialRefsL()
+ {
+ if(!ipCredentialRefs)
+ {
+ ipCredentialRefs = new (ELeave) CDesC8ArrayFlat(KFLATBUF_SIZE);
+ }
+ return *ipCredentialRefs;
+ }
+
+TBool CIdWsfServiceInstance::SupportsMechanism(const TDesC8& aURI)
+ {
+ if (ipMechanisms)
+ {
+ TInt pos;
+ return (ipMechanisms->Find(aURI, pos, ECmpNormal) == KErrNone);
+ }
+ return EFalse;
+ }
+
+CSenCredential* CIdWsfServiceInstance::Credential()
+ {
+ CSenCredential* pCredential = NULL;
+ TInt count(iCredentialList.Count());
+ for(TInt i=0; i<count && pCredential == NULL; i++)
+ {
+ pCredential = iCredentialList[i];
+ }
+ return pCredential;
+ }
+
+
+void CIdWsfServiceInstance::SetCredentialL(const TDesC8& aIdRef,
+ const CSenCredential& aCredential)
+ {
+ TInt refCount(CredentialRefsL().Count());
+ for (TInt i = 0; i < refCount; i++)
+ {
+ // Remove IDREFs and add actual credential
+ if (CredentialRefsL()[i] == aIdRef)
+ {
+ CSenCredential* pCredential = CSenCredential::NewL(aCredential);
+ iCredentialList.Append(pCredential);
+ ipCredentialRefs->Delete(i);
+ break;
+ }
+ }
+ }
+
+void CIdWsfServiceInstance::SetCredentialL(const CSenCredential& aCredential)
+ {
+ const TDesC8& idRef = ((CSenCredential&)aCredential).Id();
+ SetCredentialL(idRef, aCredential);
+ }
+
+void CIdWsfServiceInstance::AddSecurityMechL(const TDesC8& aUri)
+ {
+ MechanismsL().AppendL(aUri);
+ }
+
+void CIdWsfServiceInstance::AddCredentialRefL(const TDesC8& aIdRef)
+ {
+ CredentialRefsL().AppendL(aIdRef);
+ }
+
+TInt CIdWsfServiceInstance::HasFacetL(const TDesC8& aURI, TBool& aHasFacet)
+ {
+ aHasFacet = EFalse;
+ TInt count(iFacets.Count());
+
+ for (TInt i=0;i<count && !aHasFacet;i++)
+ {
+ if (iFacets[i]->Name() == aURI)
+ {
+ aHasFacet = ETrue;
+ }
+ }
+
+ return KErrNone;
+ }
+
+TInt CIdWsfServiceInstance::FacetValue(TDesC8& aURI, HBufC8*& aValueTo)
+ {
+ delete aValueTo;
+ aValueTo = NULL;
+
+ TInt retVal = KErrNotFound;
+ TInt count(iFacets.Count());
+
+ for (TInt i=0;i<count && retVal == KErrNotFound;i++)
+ {
+ if (iFacets[i]->Name() == aURI)
+ {
+ aValueTo = iFacets[i]->Value().Alloc();
+ if (aValueTo == NULL) retVal = KErrNoMemory;
+ else retVal = KErrNone;
+ }
+ }
+ return retVal;
+ }
+
+TInt CIdWsfServiceInstance::AddFacetL(const CSenFacet& aFacet)
+ {
+ return SetFacetL(aFacet);
+ }
+
+TInt CIdWsfServiceInstance::SetFacetL(const CSenFacet& aFacet)
+ {
+ TBool hasFacet;
+ HasFacetL(((CSenFacet&)aFacet).Name(),hasFacet);
+ if (hasFacet)
+ {
+ RemoveFacet(((CSenFacet&)aFacet).Name());
+ }
+ CSenFacet* pNewFacet = CSenFacet::NewL(((CSenFacet&)aFacet));
+ return iFacets.Append(pNewFacet);
+ }
+
+TInt CIdWsfServiceInstance::RemoveFacet(const TDesC8& aURI)
+ {
+ TInt count(iFacets.Count());
+
+ for (TInt i=0;i<count;i++)
+ {
+ if (iFacets[i]->Name() == aURI)
+ {
+ delete iFacets[i];
+ iFacets.Remove(i);
+ return KErrNone;
+ }
+ }
+
+ return KErrNotFound;
+ }
+
+TInt CIdWsfServiceInstance::FacetsL(RFacetArray& aFacetArray)
+ {
+ CSenFacet* pFacet = NULL;
+ TInt count(iFacets.Count());
+ for (TInt i=0; i<count; i++)
+ {
+ pFacet = CSenFacet::NewL(*iFacets[i]);
+ aFacetArray.Append(pFacet);
+ }
+ return KErrNone;
+ }
+
+TInt CIdWsfServiceInstance::ScoreMatchL(MSenServiceDescription& aPattern)
+ {
+ TInt score(0);
+
+ if ((aPattern.Endpoint().Length() > 0) &&
+ (aPattern.Endpoint() == Endpoint()))
+ {
+ score++;
+ }
+ if ((aPattern.Contract().Length() > 0) &&
+ (aPattern.Contract() == Contract()))
+ {
+ score++;
+ }
+
+ RFacetArray otherFacets;
+ CleanupClosePushL(otherFacets);
+ aPattern.FacetsL(otherFacets);
+
+ HBufC8* pFacetValue = NULL;
+ TPtrC8 facetName;
+
+ TInt count(otherFacets.Count());
+ for (TInt i=0; i<count; i++)
+ {
+ facetName.Set(otherFacets[i]->Name());
+ FacetValue(facetName,pFacetValue);
+ if (pFacetValue && *pFacetValue == otherFacets[i]->Value())
+ {
+ score++;
+ }
+ delete pFacetValue;
+ pFacetValue = NULL;
+ }
+
+ otherFacets.ResetAndDestroy();
+ CleanupStack::Pop(); // otherFacets
+
+ return score;
+ }
+
+// equals to CSenWSDescription implementation at the moment
+TBool CIdWsfServiceInstance::HasEqualPrimaryKeysL(MSenServiceDescription& aCandidate)
+ {
+ TBool retVal(EFalse);
+ if(aCandidate.Endpoint() == Endpoint() &&
+ aCandidate.Contract() == Contract() &&
+ aCandidate.FrameworkId() == FrameworkId())
+ {
+ retVal = ETrue;
+ }
+ return retVal;
+ }
+
+
+TBool CIdWsfServiceInstance::HasSuperClass( TDescriptionClassType aType )
+ {
+ if( aType == MSenServiceDescription::EWSDescription ) // direct superclass!
+ {
+ // If asked type is the know *direct* father/mother, return true:
+ return ETrue;
+ }
+ else
+ {
+ // Otherwise, ask from superclass (chain, recursively)
+ return CSenWSDescription::HasSuperClass( aType );
+ }
+ }
+
+
+
+// End of File