/*

* 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:  Domain, category, event & command object implementations

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    "MediatorServerObjects.h"

#include    "MediatorCommon.h"

#include    "MediatorServer.h"

#include    "MediatorServiceDefs.h"

#include    "Debug.h"

// =============================================================================

// ============================ DOMAIN FUNCTIONS ===============================

// =============================================================================

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

// CDomain::CDomain

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

//

CDomain::CDomain()

    {

    }

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

// CDomain::ConstructL

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

//

void CDomain::ConstructL( TUid aDomain )

    {

    iDomain = aDomain;

    iSearchCategory = CCategory::NewL( TUid() ); // just assign some arbitrary domain, updated in search

    }

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

// CDomain::NewL

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

//

CDomain* CDomain::NewL( TUid aDomain )

    {

    CDomain* self = new( ELeave ) CDomain;

    CleanupStack::PushL( self );

    self->ConstructL( aDomain );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDomain::~CDomain

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

//

CDomain::~CDomain()

    {

    iCategoryList.ResetAndDestroy();

    delete iSearchCategory;

    }

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

// CDomain::DomainUid

// (other items were commented in a header).

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

//

TUid CDomain::DomainUid() const

    {

    return iDomain;

    }

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

// CDomain::SetDomainUid

// (other items were commented in a header).

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

//

void CDomain::SetDomainUid( TUid aDomain )

    {

    iDomain = aDomain;

    }

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

// CDomain::AddCategoryL

// (other items were commented in a header).

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

//     

void CDomain::AddCategoryL( const CCategory* aNewCategory )

    {

    __ASSERT_DEBUG( aNewCategory, CMediatorServer::PanicServer( EMediatorServerIllegalParameter ) );

    TInt index = 0;     // not used here

    if ( FindCategory( aNewCategory->CategoryUid(), index ) )

        {

        ERROR_TRACE(Print(_L("CDomain::AddCategoryL: category %d already exists in domain %d\n"), aNewCategory->CategoryUid().iUid,

                                                                                                  iDomain.iUid ) );    

        User::Leave( KErrAlreadyExists );

        }

    iCategoryList.AppendL( aNewCategory );

    }

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

// CDomain::AddCategoryL

// (other items were commented in a header).

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

//     

CCategory* CDomain::AddCategoryL( const TUid aCategory )

    {

    CCategory* newCategory = CCategory::NewL( aCategory );

    CleanupStack::PushL( newCategory );

    TInt index = 0;

    if ( FindCategory( newCategory, index ) )

        {

        ERROR_TRACE(Print(_L("CDomain::AddCategoryL: category %d already exists in domain %d\n"), aCategory.iUid,

                                                                                                  iDomain.iUid ) );    

        User::Leave( KErrAlreadyExists );

        }

    iCategoryList.AppendL( newCategory );

    CleanupStack::Pop( newCategory );   // ownership is changed

    return newCategory;

    }

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

// CDomain::RemoveCategory

// (other items were commented in a header).

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

//       

TInt CDomain::RemoveCategory( const TUid aCategory )

    {

    TInt error = KErrMediatorCategoryNotFound;

    // Find the category

    TInt index = 0;

    CCategory* category = FindCategory( aCategory, index );

    if ( category )

        {

        // Make temporary pointer to it, remove it from list and delete.

        CCategory* category = iCategoryList[ index ];

        iCategoryList.Remove( index );

        delete category;

        error = KErrNone;

        }

    return error;

    }

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

// CDomain::GetCategory

// 

// (other items were commented in a header).

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

//  

const CCategory* CDomain::GetCategory( const TUid aCategory )

    {

    TInt index = 0;

    return FindCategory( aCategory, index );

    }

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

// CDomain::GetCategory

// 

// (other items were commented in a header).

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

//      

CCategory* CDomain::GetCategory( TInt aIndex )

    {

    CCategory* categoryPtr = NULL;

    if ( aIndex >= 0 && aIndex < CategoryCount() )

        {

        categoryPtr = iCategoryList[aIndex];

        }

    return categoryPtr;

    }

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

// CDomain::CategoryCount

// 

// (other items were commented in a header).

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

//     

TInt CDomain::CategoryCount()

    {

    return iCategoryList.Count();

    }

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

// CDomain::FindCategory

// 

// (other items were commented in a header).

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

//     

CCategory* CDomain::FindCategory( const TUid aCategory, TInt& aIndex )

    {

    iSearchCategory->SetCategoryUid( aCategory );

    return FindCategory( iSearchCategory, aIndex );

    }    

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

// CDomain::FindCategory

// 

// (other items were commented in a header).

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

//     

CCategory* CDomain::FindCategory( const CCategory* aCategory, TInt& aIndex )

    {

    // Create utilities to be used in find

    TIdentityRelation<CCategory> relation( CompareCategories );

	// Find the item from array

    aIndex = iCategoryList.Find( aCategory, relation );	

    // Then return it, if found. 

    CCategory* category = NULL;

    if ( aIndex != KErrNotFound )

        {

        category = iCategoryList[aIndex];

        }

	return category;

    }

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

// CDomain::GetCategoriesL

// 

// (other items were commented in a header).

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

//      

void CDomain::GetCategoriesL( RCategoryList& aCategories )

    {

    // Loop through category list and append to return list.

    for ( TInt index = 0; index < iCategoryList.Count(); index++ )

        {

        aCategories.AppendL( iCategoryList[index]->CategoryUid() );

        }

    }

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

// CDomain::CompareCategories

// Compares categories and returns boolean according to comparison

// (other items were commented in a header).

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

//    

TBool CDomain::CompareCategories( const CCategory& aLeftCategory, 

                                  const CCategory& aRightCategory )

    {

    return aLeftCategory.CategoryUid() == aRightCategory.CategoryUid();

    }

// =============================================================================

// ============================ CATEGORY FUNCTIONS =============================

// =============================================================================

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

// CCategory::CCategory()

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

//

CCategory::CCategory()

    {

    }

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

// CCategory::ConstructL

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

//

void CCategory::ConstructL( TUid aCategory )

    {

    iCategory = aCategory;

    iSearchCommand = CCommand::NewL(0); // arbitrary id, updated in search

    iSearchEvent = CEvent::NewL(0); // arbitrary id, updated in search

    }

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

// CCategory::NewL

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

//

CCategory* CCategory::NewL( TUid aCategory )

    {

    CCategory* self = new( ELeave ) CCategory;

    CleanupStack::PushL( self );

    self->ConstructL( aCategory );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCategory::~CCategory

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

//

CCategory::~CCategory()

    {

    iEventList.ResetAndDestroy();

    iCommandList.ResetAndDestroy();

    delete iSearchCommand;

    delete iSearchEvent;

    }

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

// CCategory::CategoryUid

// 

// (other items were commented in a header).

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

//

TUid CCategory::CategoryUid() const

    {

    return iCategory;

    }

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

// CCategory::SetCategoryUid

// 

// (other items were commented in a header).

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

//    

void CCategory::SetCategoryUid( TUid aCategory )

    {

    iCategory = aCategory;

    }

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

// CCategory::AddEventL

// Adds new event to eventlist

// (other items were commented in a header).

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

//     

TInt CCategory::AddEvent( const CEvent* aNewEvent )

    {

    __ASSERT_DEBUG( aNewEvent, CMediatorServer::PanicServer( EMediatorServerIllegalParameter ) );

    TInt error = FindEvent( *aNewEvent );

    if ( error == KErrNotFound )

        {

#ifdef _DEBUG

        TRACE(Print(_L("[Mediator Server]\t CCategory::AddEvent id %d\n"), aNewEvent->Id() ));

        for ( TInt index = 0; index < ECapability_Limit; index ++ )

            {

            TCapabilitySet caps = aNewEvent->Policy();

            TBool required = caps.HasCapability( (TCapability) index );

            if ( required )

                {

                TRACE(Print(_L("[Mediator] CCategory::AddEvent: Capability %d required\n"), index ));

                }

            }

#endif // _DEBUG

        error = iEventList.Append( aNewEvent );

        }

    else

        {

        error = KErrMediatorEventAlreadyExists;

        }

    return error;

    }

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

// CCategory::AddCommandL

// Adds new command to commandList

// (other items were commented in a header).

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

//     

TInt CCategory::AddCommand( const CCommand* aNewCommand )

    {

    __ASSERT_DEBUG( aNewCommand, CMediatorServer::PanicServer( EMediatorServerIllegalParameter ) );

    TInt error = FindCommand( *aNewCommand );

    if ( error == KErrNotFound )

        {

#ifdef _DEBUG

        TRACE(Print(_L("[Mediator Server]\t CCategory::AddCommand id %d\n"), aNewCommand->Id() ));

        for ( TInt index = 0; index < ECapability_Limit; index ++ )

            {

            TCapabilitySet caps = aNewCommand->Policy();

            TBool required = caps.HasCapability( (TCapability) index );

            if ( required )

                {

                TRACE(Print(_L("[Mediator] CCategory::AddCommand: Capability %d required\n"), index ));

                }

            }

#endif // _DEBUG

        error = iCommandList.Append( aNewCommand );

        }

    else

        {

        error = KErrMediatorCommandAlreadyExists;

        }

    return error;

    }

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

// CCategory::RemoveEvent

// Removes item from the category

// (other items were commented in a header).

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

// 

void CCategory::RemoveEvent( TInt aIndex )

    {

    if ( aIndex >= 0 && aIndex < iEventList.Count() )

        {

        iEventList.Remove( aIndex );

        }

    }

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

// CCategory::RemoveCommand

// Removes item from the category

// (other items were commented in a header).

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

// 

void CCategory::RemoveCommand( TInt aIndex )

    {

    if ( aIndex >= 0 && aIndex < iCommandList.Count() )

        {

        iCommandList.Remove( aIndex );

        }

    }

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

// CCategory::FindEvent

// Returns item specified by Id

// (other items were commented in a header).

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

//         

CEvent* CCategory::FindEvent( const TInt aId, TInt& aIndex )

    {

    iSearchEvent->SetId( aId );

    aIndex = FindEvent( *iSearchEvent );

    // Then return it, if found. 

    CEvent* event = NULL;

    if ( aIndex != KErrNotFound )

        {

        event = iEventList[aIndex];

        }

	return event;

    }    

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

// CCategory::GetEvent

// Returns item specified by index

// (other items were commented in a header).

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

//    

CEvent* CCategory::GetEvent( TInt aIndex )

    {

    CEvent* eventPtr = NULL;

    if ( aIndex >= 0 && aIndex < EventCount() )

        {

        eventPtr = iEventList[aIndex];

        }

    return eventPtr;

    }

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

// CCategory::GetCommand

// Returns item specified by index

// (other items were commented in a header).

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

//    

CCommand* CCategory::GetCommand( TInt aIndex )

    {

    CCommand* commandPtr = NULL;

    if ( aIndex >= 0 && aIndex < CommandCount() )

        {

        commandPtr = iCommandList[aIndex];

        }

    return commandPtr;

    }

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

// CCategory::FindCommand

// Returns item specified by Id

// (other items were commented in a header).

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

//       

CCommand* CCategory::FindCommand( const TInt aId, TInt& aIndex )

    {

    iSearchCommand->SetId( aId );

    aIndex = FindCommand( *iSearchCommand );

    // Then return it, if found. 

    CCommand* command = NULL;

    if ( aIndex != KErrNotFound )

        {

        command = iCommandList[aIndex];

        }

	return command;

    }    

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

// CCategory::FindEvent

// Finds event from the event list

// (other items were commented in a header).

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

//    

TInt CCategory::FindEvent( const CEvent& aEvent )

    {

    // Create utilities to be used in find

    TIdentityRelation<CEvent> relation( CompareEvents );

	// Find the event from array	

	return iEventList.Find( &aEvent, relation );

    }

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

// CCategory::FindCommand

// Finds item from the item list

// (other items were commented in a header).

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

//    

TInt CCategory::FindCommand( const CCommand& aCommand )

    {

    // Create utilities to be used in find

    TIdentityRelation<CCommand> relation( CompareCommands );