/*

* 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