--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsutils/src/senidentifier.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,272 @@
+/*
+* 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:      
+*
+*/
+
+
+
+
+
+
+
+
+#include "senidentifier.h"
+#include "sencertutils.h"
+
+#include "senlogger.h"
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewL()
+    {
+    CSenIdentifier* self = NewLC();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewLC()
+    {
+    CSenIdentifier* self = new (ELeave) CSenIdentifier();
+    CleanupStack::PushL(self);
+    self->ConstructL(SenIdentifier::EUnknown, KNullDesC8(), KNullDesC8());
+    return self;
+    }
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewL(const CSenIdentifier& aParent)
+    {
+    CSenIdentifier* self = NewLC(aParent);
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewLC(const CSenIdentifier& aParent)
+    {
+    CSenIdentifier* self = new (ELeave) CSenIdentifier();
+    CleanupStack::PushL(self);
+    self->ConstructL(aParent);
+    return self;
+    }
+
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewL(SenIdentifier::TIdentifierType aIdentifierType, 
+                                              const TDesC8& aIdentifierValue)
+    {
+    CSenIdentifier* self = NewLC(aIdentifierType, aIdentifierValue);
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewLC(SenIdentifier::TIdentifierType aIdentifierType, 
+                                               const TDesC8& aIdentifierValue)
+    {
+    CSenIdentifier* self = new (ELeave) CSenIdentifier();
+    CleanupStack::PushL(self);
+    self->ConstructL(aIdentifierType, aIdentifierValue, KNullDesC8());
+    return self;
+    }
+
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewL(SenIdentifier::TIdentifierType aIdentifierType, 
+                                              const TCertInfo& aCertInfo)
+    {
+    CSenIdentifier* self = NewLC(aIdentifierType, aCertInfo);
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewLC(SenIdentifier::TIdentifierType aIdentifierType, 
+                                               const TCertInfo& aCertInfo)
+    {
+    CSenIdentifier* self = new (ELeave) CSenIdentifier();
+    CleanupStack::PushL(self);
+    HBufC8* pCertInfo = SenCertUtils::CertInfoToStringLC(aCertInfo);
+    self->ConstructL(aIdentifierType, *pCertInfo, KNullDesC8);
+    CleanupStack::PopAndDestroy(); // CertInfoToStringLC
+    return self;
+    }
+
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewL(SenIdentifier::TIdentifierType aIdentifierType, 
+                                              const TDesC8& aIdentifierValue, 
+                                              const TDesC8& aFriendlyName)
+    {
+    CSenIdentifier* self = NewLC(aIdentifierType, aIdentifierValue, aFriendlyName);
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+EXPORT_C CSenIdentifier* CSenIdentifier::NewLC(SenIdentifier::TIdentifierType aIdentifierType, 
+                                               const TDesC8& aIdentifierValue, 
+                                               const TDesC8& aFriendlyName)
+    {
+    CSenIdentifier* self = new (ELeave) CSenIdentifier();
+    CleanupStack::PushL(self);
+    self->ConstructL(aIdentifierType, aIdentifierValue, aFriendlyName);
+    return self;
+    }
+
+
+void CSenIdentifier::ConstructL(SenIdentifier::TIdentifierType aIdentifierType, 
+                                const TDesC8& aIdentifierValue, 
+                                const TDesC8& aFriendlyName)
+    {
+    TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "CSenIdentifier::ConstructL - Start");
+
+    iType = aIdentifierType;
+    ipValue = aIdentifierValue.AllocL();
+    ipFriendlyName = aFriendlyName.AllocL();
+    ipStatements = CSenAttributes::NewL();
+    ipParent = this;
+    TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "CSenIdentifier::ConstructL - End");
+    }
+
+void CSenIdentifier::ConstructL(const CSenIdentifier& aParent)
+    {
+    TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "CSenIdentifier::ConstructL - Start");
+    iType = aParent.iType;
+    ipValue = aParent.Value().AllocL();
+    ipFriendlyName = aParent.ipFriendlyName->AllocL();
+    ipStatements = CSenAttributes::NewL(aParent.Statements());
+
+    // Note that all childs in chain get the root as their parent(!):
+    ipParent = CSenIdentifier::NewL(aParent.Parent()); 
+    TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "CSenIdentifier::ConstructL - End");
+    }
+
+CSenIdentifier::CSenIdentifier() : 
+    ipValue(NULL),
+    ipFriendlyName(NULL),
+    ipStatements(NULL)
+    {
+
+    iType = SenIdentifier::EUnknown;
+    }
+
+
+EXPORT_C CSenIdentifier::~CSenIdentifier()
+    {
+    delete ipValue;         // it is safe to delete NULL in Symbian C++
+    delete ipFriendlyName;
+    delete ipStatements;
+
+    delete Proxy(); // destroy the parent (proxy), if such is owned 
+    /*
+    if ( IsProxy() )  // atm equal to: delete Proxy();
+        {   
+        delete ipParent; // mm: was identifier ment to take ownership of its parent?
+        }
+    */
+    }
+
+
+EXPORT_C TPtrC8 CSenIdentifier::Value() const
+    {
+    return *ipValue;
+    }
+
+
+EXPORT_C SenIdentifier::TIdentifierType CSenIdentifier::Type() const
+    {
+    return iType;
+    }
+
+
+EXPORT_C TBool CSenIdentifier::Equals(const CSenIdentifier& otherIdentifier)
+    {
+    TBool result = EFalse;
+    result = (iType == otherIdentifier.Type()) && (0 == ipValue->Compare(otherIdentifier.Value()));
+    return(result);
+    }
+
+// == ParentFor
+EXPORT_C void CSenIdentifier::ProxyFor( CSenIdentifier* aIdentifier )
+    {
+    ipParent = aIdentifier;
+    }
+
+/*
+
+EXPORT_C TBool CSenIdentifier::IsProxy() const
+    {
+    // if parent is NULL, then this is the root
+    // and is thus not a proxy for another identifier
+
+    return(!(ipParent == NULL));
+    }
+
+// == Parent()
+EXPORT_C const CSenIdentifier* CSenIdentifier::Proxy() const
+    {
+    return(ipParent);    
+    }
+
+
+EXPORT_C const CSenIdentifier* CSenIdentifier::Root() const
+    {
+    return( (IsProxy()) ? ipParent : this );   
+    }
+*/
+
+EXPORT_C TBool CSenIdentifier::IsProxy() const
+    {
+    // If parent is this, then this is the root
+    // and thus not a proxy for another identifier
+    return(!(ipParent == this));
+    }
+
+// return the parent (or this, if this is not a proxy)
+EXPORT_C const CSenIdentifier* CSenIdentifier::Proxy() const
+    {
+    return( IsProxy() ? ipParent : NULL );    
+    }
+
+// return the root of (possible parent) 
+EXPORT_C const CSenIdentifier* CSenIdentifier::Root() const
+    {
+    return( IsProxy() ? ipParent->Root() : this );   
+    }
+
+EXPORT_C void CSenIdentifier::AddAttributeL( CSenAttribute& aAttribute )	//codescannerwarnings
+    {
+    ipStatements->AddAttributeL(aAttribute);	//codescannerwarnings
+    }
+
+
+EXPORT_C const CSenAttributes* CSenIdentifier::Attributes() const
+    {
+    return ipStatements;
+    }
+
+EXPORT_C TBool CSenIdentifier::operator==(const CSenIdentifier& a)
+    {
+    return (this==&a);
+    }
+
+const CSenIdentifier& CSenIdentifier::Parent() const
+    {
+    // if(!ipParent) User::Leave( <define leave code >
+    return *ipParent;
+    }
+
+const CSenAttributes& CSenIdentifier::Statements() const
+    {
+    // if(!ipStatements) User::Leave( <define leave code >
+    return *ipStatements;
+    }
+
+// End of file
+
+
+
+
+