/*
* Copyright (c) 2004-2007 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:  HID collection implementation
*
*/


#include <e32std.h>
#include <e32base.h>
#include <e32des8.h>
#include <e32svr.h>

#include "hidreportroot.h"
#include "debug.h"

// ======== MEMBER FUNCTIONS ========

// -----------------------------------------------------------------------------
// NewLC()
// -----------------------------------------------------------------------------
//
CCollection* CCollection::NewLC()
    {
    CCollection* self = new (ELeave) CCollection();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }
// -----------------------------------------------------------------------------
// NewL()
// -----------------------------------------------------------------------------
//
CCollection* CCollection::NewL()
    {
    CCollection* self=NewLC();
    CleanupStack::Pop();
    return self;
    }

// -----------------------------------------------------------------------------
// ConstructL()
// -----------------------------------------------------------------------------
//
void CCollection::ConstructL()
    {
    // Nothing to do here
    }

// -----------------------------------------------------------------------------
// CCollection()
// -----------------------------------------------------------------------------
//
CCollection::CCollection()
    {
    // Nothing to do here
    }

// -----------------------------------------------------------------------------
// ~CCollection()
// -----------------------------------------------------------------------------
//
CCollection::~CCollection()
    {
    iCollections.ResetAndDestroy();
    iFields.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// Type()
// -----------------------------------------------------------------------------
//
EXPORT_C TUint32 CCollection::Type() const
    {
    return iType;
    }

// -----------------------------------------------------------------------------
// UsagePage()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CCollection::UsagePage() const
    {
    return iUsagePage;
    }

// -----------------------------------------------------------------------------
// Usage()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CCollection::Usage() const
    {
    return iUsage;
    }

// -----------------------------------------------------------------------------
// CollectionCount()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CCollection::CollectionCount() const
    {
    return iCollections.Count();
    }

// -----------------------------------------------------------------------------
// FieldCount()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CCollection::FieldCount() const
    {
    return iFields.Count();
    }

// -----------------------------------------------------------------------------
// CollectionByIndex
// -----------------------------------------------------------------------------
//
EXPORT_C const CCollection* CCollection::CollectionByIndex(TInt aIndex) const
    {
    return (0 <= aIndex && aIndex < iCollections.Count()) ?
        iCollections[aIndex] : NULL;
    }

// -----------------------------------------------------------------------------
// FieldByIndex
// -----------------------------------------------------------------------------
//
EXPORT_C const CField* CCollection::FieldByIndex(TInt aIndex) const
    {
    return (0 <= aIndex && aIndex < iFields.Count()) ?
        iFields[aIndex] : NULL;
    }

// -----------------------------------------------------------------------------
// IsPhysical()
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CCollection::IsPhysical() const
    {
    return iType == EPhysical;
    }

// -----------------------------------------------------------------------------
// IsApplication()
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CCollection::IsApplication() const
    {
    return iType == EApplication;
    }

// -----------------------------------------------------------------------------
// IsLogical()
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CCollection::IsLogical() const
    {
    return iType == ELogical;
    }

// -----------------------------------------------------------------------------
// IsReport()
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CCollection::IsReport() const
    {
    return iType == EReport;
    }

// -----------------------------------------------------------------------------
// IsNamedArray()
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CCollection::IsNamedArray() const
    {
    return iType == ENamedArray;
    }

// -----------------------------------------------------------------------------
// IsUsageSwitch()
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CCollection::IsUsageSwitch() const
    {
    return iType == EUsageSwitch;
    }

// -----------------------------------------------------------------------------
// IsUsageModifier()
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CCollection::IsUsageModifier() const
    {
    return iType == EUsageModifier;
    }

// -----------------------------------------------------------------------------
// SetType()
// -----------------------------------------------------------------------------
//
void CCollection::SetType(TUint32 aType)
    {
    iType = aType;
    }

// -----------------------------------------------------------------------------
// SetUsagePage()
// -----------------------------------------------------------------------------
//
void CCollection::SetUsagePage(TInt aUsagePage)
    {
    iUsagePage = aUsagePage;
    }

// -----------------------------------------------------------------------------
// SetUsage()
// -----------------------------------------------------------------------------
//
void CCollection::SetUsage(TInt aUsage)
    {
    iUsage = aUsage;
    }
// -----------------------------------------------------------------------------
// AddFieldL()
// -----------------------------------------------------------------------------
//
CField* CCollection::AddFieldL()
    {
    CField* field = CField::NewL();
    CleanupStack::PushL(field);
    User::LeaveIfError(iFields.Append(field));
    CleanupStack::Pop(field);
    return field;
    }

// -----------------------------------------------------------------------------
// AddCollectionL()
// -----------------------------------------------------------------------------
//
CCollection* CCollection::AddCollectionL()
    {
    CCollection* collection = CCollection::NewL();
    CleanupStack::PushL(collection);
    User::LeaveIfError(iCollections.Append(collection));
    CleanupStack::Pop(collection);
    return collection;
    }





// -----------------------------------------------------------------------------
// Match()
// -----------------------------------------------------------------------------
//
TBool TReportSize::Match(const TReportSize& aFirst,
    const TReportSize& aSecond)
    {
    return (aFirst.iReportId == aSecond.iReportId) &&
        (aFirst.iType == aSecond.iType);
    }


// -----------------------------------------------------------------------------
// TReportSize()
// -----------------------------------------------------------------------------
//
TReportSize::TReportSize(TInt aReportId, CField::TType aType)
    : iReportId(aReportId), iType(aType), iSize(0)
    {
    // Nothing else to do
    }