/*
* Copyright (c) 2008 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:  Class for holding PIM item data
 *
*/


// CLASS HEADER
#include "cpimitemdata.h"

// INTERNAL INCLUDES
#include "cpimfield.h"
#include "pimpanics.h"
#include "logger.h"

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

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CPIMItemData::~CPIMItemData()
{
    JELOG2(EPim);
    delete iCategories;
    iFields.ResetAndDestroy();
}

// ---------------------------------------------------------------------------
// CPIMItemData::NewL
// Default two-phase constructor
// ---------------------------------------------------------------------------
//
CPIMItemData* CPIMItemData::NewL()
{
    JELOG2(EPim);
    CPIMItemData* self = CPIMItemData::NewLC();
    CleanupStack::Pop(self);
    return self;
}

// ---------------------------------------------------------------------------
// CPIMItemData::NewLC
// Default two-phase constructor. The newly created object is left to the
// cleanup stack
// ---------------------------------------------------------------------------
//
CPIMItemData* CPIMItemData::NewLC()
{
    JELOG2(EPim);
    CPIMItemData* self = new(ELeave) CPIMItemData();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
}

// ---------------------------------------------------------------------------
// CPIMItemData::SetValueL
// Sets new value for a specific field value in a specific index. This method
// leaves if there is no such field or field index. Also, this panics if the
// new value field type is not the same as the previous one
// ---------------------------------------------------------------------------
//
void CPIMItemData::SetValueL(const TPIMFieldData& aFieldData)
{
    JELOG2(EPim);
    // Get the data from the holder class
    TInt index = FieldIndex(aFieldData.Field());
    // Leave with KErrNotFound if there is no requested field
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(index));

    __ASSERT_DEBUG(aFieldData.FieldDataType() == iFields[index]->DataType(),
                   User::Panic(KPIMPanicCategory, EPIMPanicInvalidFieldType));

    iFields[index]->SetValueL(aFieldData);
}

// ---------------------------------------------------------------------------
// CPIMItemData::AddValueL
// Adds new value for the field. New field is generated if there is no existing
// field (i.e this is the first value which is added to this field
// ---------------------------------------------------------------------------
//
void CPIMItemData::AddValueL(const TPIMFieldData& aFieldData)
{
    JELOG2(EPim);
    // Check that if there is already a field of this type
    TInt index = FieldIndex(aFieldData.Field());
    if (index != KErrNotFound)
    {
        __ASSERT_DEBUG(
            aFieldData.FieldDataType() == iFields[index]->DataType(),
            User::Panic(KPIMPanicCategory, EPIMPanicInvalidFieldType));
        iFields[index]->AddValueL(aFieldData);
    }
    // Generate new field
    else
    {
        CPIMField* newField = CPIMField::NewLC(aFieldData);
        iFields.AppendL(newField);
        // Add new value to item and prepare for an error
        TRAPD(err, newField->AddValueL(aFieldData));
        if (err != KErrNone)
        {
            // The array must be returned to state that it was before this
            // function call to ensure leave safe function
            TInt entryIndex = iFields.Find(newField);
            iFields.Remove(entryIndex);
            User::Leave(err);
        }
        CleanupStack::Pop(newField);
    }
}

// ---------------------------------------------------------------------------
// CPIMItemData::ValueL
// Fetches a Value a specifc index of the requested field
// ---------------------------------------------------------------------------
//
const TPIMFieldData CPIMItemData::ValueL(const TPIMField aField,
        const TInt aIndex) const
{
    JELOG2(EPim);
    const TInt index = FieldIndex(aField);
    // Leave with KErrNotFound if there is no requested field
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(index));
    return iFields[index]->ValueL(aIndex);
}

// ---------------------------------------------------------------------------
// CPIMItemData::RemoveValueL
// Removes a specific value of a specific field.
// ---------------------------------------------------------------------------
//
void CPIMItemData::RemoveValueL(const TPIMField aField, const TInt aIndex)
{
    JELOG2(EPim);
    TInt index = FieldIndex(aField);
    // Leave with KErrNotFound if there is no requested field
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(index));
    iFields[index]->RemoveValueL(aIndex);
    // Remove field if this was the last value
    if (iFields[index]->CountValues() == 0)
    {
        // Remove object from array and delete it
        delete iFields[index];
        iFields.Remove(index);
    }
}

// ---------------------------------------------------------------------------
// CPIMItemData::CountValues
// Counts the values in the requested field
// ---------------------------------------------------------------------------
//
TInt CPIMItemData::CountValues(const TPIMField aField) const
{
    JELOG2(EPim);
    TInt index = FieldIndex(aField);
    // Leave with KErrNotFound if there is no requested field
    if (index != KErrNotFound)
    {
        return iFields[index]->CountValues();
    }
    // Else return zero
    return 0;
}

// ---------------------------------------------------------------------------
// CPIMItemData::FieldsL
// Returns fields that currently have more than zero values. The returned
// array is left to the cleanup stack
// ---------------------------------------------------------------------------
//
CArrayFix<TPIMField>* CPIMItemData::FieldsLC() const
{
    JELOG2(EPim);
    CArrayFixFlat<TPIMField>* fields =
        new(ELeave) CArrayFixFlat<TPIMField> (5);
    CleanupStack::PushL(fields);

    TInt fieldCount = iFields.Count();
    for (TInt i = 0; i < fieldCount; i++)
    {
        fields->AppendL(iFields[i]->FieldType());
    }
    return fields;
}

// ---------------------------------------------------------------------------
// CPIMItemData::SetLabelL
// Other items were commented in the header
// ---------------------------------------------------------------------------
//
void CPIMItemData::SetLabelL(const TPIMField aField, const TInt aIndex,
                             const TInt aArrayIndex, const TDesC& aLabel)
{
    JELOG2(EPim);
    TInt index = FieldIndex(aField);
    // Leave with KErrNotFound if there is no requested field
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(index));
    iFields[index]->SetLabelL(aIndex, aArrayIndex, aLabel);
}

// ---------------------------------------------------------------------------
// CPIMItemData::LabelL
// Other items were commented in the header
// ---------------------------------------------------------------------------
//
const TPtrC CPIMItemData::LabelL(const TPIMField aField, const TInt aIndex,
                                 const TInt aArrayIndex) const
{
    JELOG2(EPim);
    TInt index = FieldIndex(aField);
    // Leave with KErrNotFound if there is no requested field
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(index));
    return iFields[index]->Label(aIndex, aArrayIndex);
}

// ---------------------------------------------------------------------------
// CPIMItemData::Reset
// Resets the item data. All fields and categories are removed
// ---------------------------------------------------------------------------
//
void CPIMItemData::Reset()
{
    JELOG2(EPim);
    iCategories->Reset();
    iFields.ResetAndDestroy();
    // All data is now deleted but the arrays are ready for reuse. see
    // documentation of RPointerArrray and CDesCArray.
}

// ---------------------------------------------------------------------------
// CPIMItemData::SetAttributesL
// Other items were commented in the header
// ---------------------------------------------------------------------------
//
void CPIMItemData::SetAttributesL(const TPIMField aField, const TInt aIndex,
                                  TPIMAttribute aAttributes)
{
    JELOG2(EPim);
    TInt index = FieldIndex(aField);
    // Leave with KErrNotFound if there is no requested field
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(index));
    iFields[index]->SetAttributesL(aIndex, aAttributes);
}

// ---------------------------------------------------------------------------
// CPIMItemData::LabelL
// Other items were commented in the header
// ---------------------------------------------------------------------------
//
TInt CPIMItemData::AttributesL(const TPIMField aField, const TInt aIndex) const
{
    JELOG2(EPim);
    TInt index = FieldIndex(aField);
    // Leave with KErrNotFound if there is no requested field
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(index));
    return iFields[index]->AttributesL(aIndex);
}

// ---------------------------------------------------------------------------
// CPIMItemData::SetInternalAttributesL
// Sets internal attributes for a specific field and index. Internal
// attributes are not visible from the Java-side so this function provides
// the only access to set internal attributes to an item
// ---------------------------------------------------------------------------
//
void CPIMItemData::SetInternalAttributesL(const TPIMField aField,
        const TInt aIndex, CArrayFix<TUid>* aInternalAttributes)
{
    JELOG2(EPim);
    TInt index = FieldIndex(aField);
    // Leave with KErrNotFound if there is no requested field
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(index));
    iFields[index]->SetInternalAttributesL(aIndex, aInternalAttributes);
}

// ---------------------------------------------------------------------------
// CPIMItemData::InternalAttributes
// Gets internal attributes for a specific field and index. Internal
// attributes are not visible from the Java-side so this function provides
// the only access to get internal attributes to an item
// ---------------------------------------------------------------------------
//
const CArrayFix<TUid>& CPIMItemData::InternalAttributesL(
    const TPIMField aField, const TInt aIndex) const
{
    JELOG2(EPim);
    TInt index = FieldIndex(aField);
    // Leave with KErrNotFound if there is no requested field
    __ASSERT_ALWAYS(index != KErrNotFound, User::Leave(index));
    return iFields[index]->InternalAttributesL(aIndex);
}

// ---------------------------------------------------------------------------
// CPIMItemData::FindCategory
// Other items were commented in the header
// ---------------------------------------------------------------------------
//
TInt CPIMItemData::FindCategory(const TDesC& aCategoryName) const
{
    JELOG2(EPim);
    TInt index(0);
    if (iCategories->Find(aCategoryName, index, ECmpNormal) == 0)
    {
        return index;
    }
    return KErrNotFound;
}

// ---------------------------------------------------------------------------
// CPIMItemData::AddNewCategoryL
// Other items were commented in the header
// ---------------------------------------------------------------------------
//
void CPIMItemData::AddNewCategoryL(const TDesC& aCategoryName)
{
    JELOG2(EPim);
    iCategories->AppendL(aCategoryName);
}

// ---------------------------------------------------------------------------
// CPIMItemData::RemoveCategory
// Other items were commented in the header
// ---------------------------------------------------------------------------
//
TBool CPIMItemData::RemoveCategory(const TDesC& aCategoryName)
{
    JELOG2(EPim);
    TInt index = FindCategory(aCategoryName);
    if (index != KErrNotFound)
    {
        iCategories->Delete(index);
        return ETrue;
    }
    return EFalse;
}

// ---------------------------------------------------------------------------
// CPIMItemData::Categories
// Other items were commented in the header
// ---------------------------------------------------------------------------
//
const CDesCArray& CPIMItemData::Categories() const
{
    JELOG2(EPim);
    return *iCategories;
}

// ---------------------------------------------------------------------------
// CPIMItemData::HasField
// Other items were commented in the header
// ---------------------------------------------------------------------------
//
TBool CPIMItemData::HasField(const TPIMField aField) const
{
    JELOG2(EPim);
    return (FieldIndex(aField) != KErrNotFound);
}

// ---------------------------------------------------------------------------
// CPIMItemData::CPIMItemData
// Default C++ constructor
// ---------------------------------------------------------------------------
//
inline CPIMItemData::CPIMItemData()
{
    JELOG2(EPim);
    // Nothing to do at the moment...
}

// ---------------------------------------------------------------------------
// CPIMItemData::ConstructL
// Default second phase constuctor. Does the leaving operations in item
// construction procedure
// ---------------------------------------------------------------------------
//
inline void CPIMItemData::ConstructL()
{
    JELOG2(EPim);
    iCategories = new(ELeave) CDesCArrayFlat(5);  // Array granularity
}

// ---------------------------------------------------------------------------
// CPIMItemData::FindField
// Searches requested field type. If there is no such field, KErrNotFound is
// returned
// ---------------------------------------------------------------------------
//
TInt CPIMItemData::FieldIndex(const TPIMField aField) const
{
    JELOG2(EPim);
    TInt count = iFields.Count();
    for (TInt i = 0; i < count; i++)
    {
        if (iFields[i]->FieldType() == aField)
        {
            return i;
        }
    }
    return KErrNotFound;
}

// End of file