/*
* Copyright (c) 2006 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:   Implements CNcdChildEntity class
*
*/


#include <e32cmn.h>
#include <s32strm.h>
#include <s32mem.h>

#include "ncdchildentity.h"
#include "ncdnodeidentifier.h"
#include "catalogsutils.h"
#include "catalogsconstants.h"


CNcdChildEntity* CNcdChildEntity::NewL( 
    TInt aIndex,
    const CNcdNodeIdentifier& aNodeIdentifier,
    TBool aTransparent,
    CNcdNodeFactory::TNcdNodeType aNodeType )
    {
    CNcdChildEntity* self = 
        CNcdChildEntity::NewLC( aIndex, aNodeIdentifier, aTransparent, aNodeType );
    CleanupStack::Pop( self );
    return self;        
    }
    
CNcdChildEntity* CNcdChildEntity::NewLC( 
    TInt aIndex,
    const CNcdNodeIdentifier& aNodeIdentifier,
    TBool aTransparent,
    CNcdNodeFactory::TNcdNodeType aNodeType )
    {
    CNcdChildEntity* self = 
        new( ELeave ) CNcdChildEntity( aIndex, aTransparent, aNodeType );
    CleanupStack::PushL( self );
    self->ConstructL( aNodeIdentifier );
    return self;
    }

CNcdChildEntity* CNcdChildEntity::NewLC( RReadStream& aReadStream )
    {
    CNcdChildEntity* self = 
        new( ELeave ) CNcdChildEntity();
    CleanupStack::PushL( self );
    self->InternalizeL( aReadStream );
    return self;        
    }

CNcdChildEntity* CNcdChildEntity::NewL( RReadStream& aReadStream )
    {
    CNcdChildEntity* self = NewLC( aReadStream );
    CleanupStack::Pop( self );
    return self;        
    }

CNcdChildEntity* CNcdChildEntity::NewL( const CNcdChildEntity& aChildEntity )
    {
    CNcdChildEntity* self = 
        CNcdChildEntity::NewLC( aChildEntity );
    CleanupStack::Pop( self );
    return self;        
    }

CNcdChildEntity* CNcdChildEntity::NewLC( const CNcdChildEntity& aChildEntity )
    {
    CNcdChildEntity* self = 
        new( ELeave ) CNcdChildEntity( aChildEntity.Index(),
            aChildEntity.IsTransparent(), aChildEntity.NodeType() );
    CleanupStack::PushL( self );
    self->ConstructL( aChildEntity.Identifier() );
    return self;
    }

const CNcdNodeIdentifier& CNcdChildEntity::Identifier() const
    {
    return *iIdentifier;
    }
    
void CNcdChildEntity::SetIdentifierL( const CNcdNodeIdentifier& aIdentifier )
    {
    CNcdNodeIdentifier* temp = CNcdNodeIdentifier::NewL( aIdentifier );
    delete iIdentifier;
    iIdentifier = temp;
    }
    
TInt CNcdChildEntity::Index() const
    {
    return iIndex;
    }

void CNcdChildEntity::InternalizeL( RReadStream& aReadStream )
    {
    iIndex = aReadStream.ReadInt32L();
    delete iIdentifier;
    iIdentifier = NULL;
    iIdentifier = CNcdNodeIdentifier::NewL( aReadStream );
    iTransparent = aReadStream.ReadInt8L();
    iNodeType =
        static_cast<CNcdNodeFactory::TNcdNodeType>( aReadStream.ReadInt8L() );
    }

void CNcdChildEntity::ExternalizeL( RWriteStream& aWriteStream ) const
    {
    aWriteStream.WriteInt32L( iIndex );
    iIdentifier->ExternalizeL( aWriteStream );
    aWriteStream.WriteInt8L( iTransparent );
    aWriteStream.WriteInt8L( iNodeType );
    }
        

TBool CNcdChildEntity::Equals( const CNcdChildEntity& aObject ) const
    {
    // iTransparent is ignored in equality checks
    return iIdentifier->Equals( aObject.Identifier() ) &&
        iIndex == aObject.Index();
    }
    
TBool CNcdChildEntity::IsTransparent() const
    {
    return iTransparent;
    }
    
void CNcdChildEntity::SetTransparent( TBool aTransparent )
    {
    iTransparent = aTransparent;
    }
    
CNcdNodeFactory::TNcdNodeType CNcdChildEntity::NodeType() const
    {
    return iNodeType;
    }
    
void CNcdChildEntity::SetNodeType( CNcdNodeFactory::TNcdNodeType aNodeType )
    {
    iNodeType = aNodeType;
    }

CNcdChildEntity::CNcdChildEntity( 
    TInt aIndex,
    TBool aTransparent,
    CNcdNodeFactory::TNcdNodeType aNodeType ) 
    : iIndex( aIndex ),
      iTransparent( aTransparent ),
      iNodeType( aNodeType )
    {
    }
    
CNcdChildEntity::CNcdChildEntity()
    {
    }

void CNcdChildEntity::ConstructL( const CNcdNodeIdentifier& aIdentifier )
    {
    iIdentifier = CNcdNodeIdentifier::NewL( aIdentifier );
    }

CNcdChildEntity::~CNcdChildEntity()
    {
    delete iIdentifier;
    }