// Copyright (c) 2005-2009 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:

// Name          : CSIPCRRoutingTable.cpp

// Part of       : SIP Client Resolver

// Version       : 1.0

//

// INCLUDES

#include <e32base.h>

#include "CSIPCRRoutingTable.h"

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::CSIPCRRoutingTable

// -----------------------------------------------------------------------------

//

CSIPCRRoutingTable::CSIPCRRoutingTable()

    {

    }

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::NewL

// -----------------------------------------------------------------------------

//

CSIPCRRoutingTable* CSIPCRRoutingTable::NewL()

    {

    CSIPCRRoutingTable* self = new (ELeave) CSIPCRRoutingTable();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::ConstructL

// -----------------------------------------------------------------------------

//

void CSIPCRRoutingTable::ConstructL()

    {

    //create the entry object for find operations with dummy id 0

    iFindEntry = CSIPCRRoutingEntry::NewL(TUid::Uid(0));        

    }

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::~CSIPCRRoutingTable

// Destructor

// -----------------------------------------------------------------------------

//

CSIPCRRoutingTable::~CSIPCRRoutingTable()

    {

    iTable.ResetAndDestroy();

    delete iFindEntry;

    }

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::AddL

// -----------------------------------------------------------------------------

//

void CSIPCRRoutingTable::AddL( const TUid& aUid )

    {    

    // first check that this top level uid does not exist already,

    // if it does then we leave with error code KErrAlreadyExists 

	if (FindEntryIndex(aUid)!=KErrNotFound) 

	    {	    

	    User::Leave (KErrAlreadyExists);

	    }

	TUid topLevelUid;

    if (FindToplevelMatch(aUid,topLevelUid))

        {

        // This entry is already in the tree, increase reference count

	    TInt topLevelIndex = FindEntryIndex(topLevelUid);

        CSIPCRRoutingEntry* topLevelEntry = iTable[topLevelIndex];        

        CSIPCRRoutingEntry* entry = topLevelEntry->FindEntryInTree(aUid);

        if (entry)

            {

            entry->ReferenceCount()++;

            }

        }

    else

        {

        // Add a new entry in the top level

        CSIPCRRoutingEntry* entry = CSIPCRRoutingEntry::NewL(aUid);

        CleanupStack::PushL(entry);

        iTable.AppendL(entry);

        CleanupStack::Pop(entry);

        }

    }

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::FindEntryIndex

// -----------------------------------------------------------------------------

//

TInt CSIPCRRoutingTable::FindEntryIndex(const TUid& aUid)

	{

	TIdentityRelation<CSIPCRRoutingEntry> compareId(CSIPCRRoutingEntry::Compare);

    iFindEntry->SetUID(aUid);

	return (iTable.Find(iFindEntry, compareId));

	}

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::AssociateL

// -----------------------------------------------------------------------------

//

void CSIPCRRoutingTable::AssociateL( const TUid& aUid, const TUid& aAssociatedUid )

    {

    TUid associatedUidTop;

    TUid parentUidTop;

    TInt index;

    CSIPCRRoutingEntry* topLevelEntry = NULL;

    CSIPCRRoutingEntry* associatedEntryObject = NULL;

    CSIPCRRoutingEntry* uidEntry = NULL;

    TBool alreadyExists = EFalse;

    // first check that the parent uid exists..

    // if it does not then we leave with error code KErrNotFound 

    if (!FindToplevelMatch(aUid, parentUidTop))

        {        

        User::Leave(KErrNotFound);

        }

    // first check if the associated uid exists

    // if it does then we may have to move it under the right entry

    alreadyExists = FindToplevelMatch(aAssociatedUid, associatedUidTop);        

    if (alreadyExists)    

        {

        CSIPCRRoutingEntry* currentParent = NULL; 

        // search the top level entry 

	    index = FindEntryIndex(associatedUidTop);	

        topLevelEntry = iTable[index];

        // get associated uid's current parent entry..

        currentParent = topLevelEntry->FindParent(aAssociatedUid);

        // if the current parent entry is the same 

        // as the one given, then dont do anything..        

        if (currentParent->UID() == aUid)

            {

            return; 

            }

        // we need to move the existing associated entry

        // to the new location, first remove the old

        associatedEntryObject = currentParent->Detach(aAssociatedUid);

        CleanupStack::PushL(associatedEntryObject);                

        }

    // search the parent top level entry 

	index = FindEntryIndex(parentUidTop);	

    topLevelEntry = iTable[index];        

    //now get the uid entry if it is not at the top level

    if (topLevelEntry->UID() == aUid)

        {        

        uidEntry = topLevelEntry;

        }

    else

        {            

        uidEntry = topLevelEntry->FindEntryInTree(aUid);

        }

    //Finally, add the associated entry

    if (associatedEntryObject)

        {

        // moving the already allocated entry object

        // to a new location

        uidEntry->AddL(associatedEntryObject);

        CleanupStack::Pop(associatedEntryObject);                    

        }

    else

        {                

        // first time inserting this uid..

        // no object created yet            

        uidEntry->AddL(aAssociatedUid);

        }

    }

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::Remove

// -----------------------------------------------------------------------------

//

TInt CSIPCRRoutingTable::Remove( const TUid& aUid )

    {

    TUid topLevelUid(TUid::Null());

    if (!FindToplevelMatch(aUid, topLevelUid))

        {

        return KErrNotFound;

        }

	TInt topLevelIndex = FindEntryIndex(topLevelUid);

    CSIPCRRoutingEntry* topLevelEntry = iTable[topLevelIndex];    

    if (topLevelEntry->UID() == aUid)

        {

        iTable.Remove(topLevelIndex);

        delete topLevelEntry;

        return KErrNone;

        }

    CSIPCRRoutingEntry* entry = topLevelEntry->FindEntryInTree(aUid);

    if (--entry->ReferenceCount() == 0)

        {

        CSIPCRRoutingEntry* parent = topLevelEntry->FindParent(aUid);

        return (parent->Remove(aUid));

        }

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::FindMatch

// -----------------------------------------------------------------------------

//

TBool CSIPCRRoutingTable::FindMatch( const TUid& aClientUid, 

                         const TUid& aParentUid, 

                         TUid& aNextHopUid )

    {

    TUid clientUidTop;       

    TBool match = EFalse;

    TBool fContinue = ETrue;            

    // first check that the leaf uid exists..

    // if it does not then return false 

    if (!FindToplevelMatch(aClientUid, clientUidTop))

        {        

        return EFalse;

        }

    // search the top level entry 

	TInt index = FindEntryIndex(clientUidTop);	

    CSIPCRRoutingEntry* topLevelEntry = iTable[index];

    CSIPCRRoutingEntry*uidEntry = NULL;

    TUid uid = aClientUid;

    while (fContinue)

        {                        

        uidEntry = topLevelEntry->FindParent(uid);        

        if (!uidEntry)

            {

            // no match

            return EFalse;

            }             

        if (uidEntry->UID() == aParentUid)

            {

            // match..

            match = ETrue;

            aNextHopUid = uid;

            fContinue = EFalse;

            }                                    

        else if (uidEntry->UID() == clientUidTop)

            {

            // we are at the top level.. 

            // no match

            match = EFalse;

            fContinue = EFalse;

            }

        else

            {            

            // no match yet..

            // continue climbing up

            uid = uidEntry->UID();

            }

        }  

    return match;

    }

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::HasUid

// -----------------------------------------------------------------------------

//    

TBool CSIPCRRoutingTable::HasUid( const TUid& aClientUid )

    {

    TBool found = EFalse;

    TInt count = iTable.Count();

    for ( TInt i=0; i < count && !found; i++ )

        {

        CSIPCRRoutingEntry* entry = iTable[i];

        if ( entry->UID() == aClientUid ||

             entry->HasClient( aClientUid ) )

            {

            found = ETrue;

            }

        }

    return found;

    }                       

// -----------------------------------------------------------------------------

// CSIPCRRoutingTable::FindToplevelMatch

// -----------------------------------------------------------------------------

//

TBool CSIPCRRoutingTable::FindToplevelMatch( const TUid& aUid, TUid& aTopLevelUid )

    {                 

    TInt count = iTable.Count();

    if (count > 0)

        {

        CSIPCRRoutingEntry* entry = NULL;

        TInt index;

        for (index = 0; index < count; index++)

            {

            entry = iTable[index];

            // if the requested uid is top level uid itself, return it.. 

            if (entry->UID() == aUid)

                {

                aTopLevelUid = entry->UID();

                return ETrue;

                }

            // or else check the clients..

            if (entry->HasClient(aUid))

                {

                aTopLevelUid = entry->UID();

                return ETrue;

                }

            }

        }

    return EFalse;       

    }