/*
* Copyright (c) 2005-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:  CContact implementation
*
*/


// INCLUDE FILES
#include "contact.h"
#include "ldapcontact.h"
#include "contactlink.h"
#include "contactstore.h"
#include "storebookmark.h"
// Meaning full errors for ldap has not yet been defined, published
// #include <vpbkerror.h>      // Virtual phonebook errors

// -----------------------------------------------------------------------------
// LDAP Store namespace
// -----------------------------------------------------------------------------
namespace LDAPStore {

// -----------------------------------------------------------------------------
// CContact::CContact
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CContact::CContact(CContactStore& aStore,TBool aOwns)
:   iOwnsContact(aOwns), iStore(aStore)
    {
    // No implementation required
    }
// -----------------------------------------------------------------------------
// CContact::ConstructL
// CContactStore constructor for performing 2nd stage construction
// -----------------------------------------------------------------------------
//
void CContact::ConstructL(CLDAPContact* aContact)
    {
    iFields.SetContact(*this,*aContact);
    }

// -----------------------------------------------------------------------------
// CContact::NewLC
// CContact two-phased constructor.
// -----------------------------------------------------------------------------
//
CContact* CContact::NewLC(CContactStore& aStore,CLDAPContact* aContact,TBool aOwns)
    {
    CContact* self = new (ELeave) CContact(aStore,aOwns);
    CleanupStack::PushL(self);
    self->ConstructL(aContact);
    self->iContact = aContact;
    return self;
    }
// -----------------------------------------------------------------------------
// CContact::NewL
// CContact two-phased constructor.
// -----------------------------------------------------------------------------
//
CContact* CContact::NewL(CContactStore& aStore,CLDAPContact* aContact,TBool aOwns)
    {
    CContact* self = CContact::NewLC(aStore,aContact,aOwns);
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CContact::~CContact
// CContact Destructor
// -----------------------------------------------------------------------------
//
CContact::~CContact()
    {
    // LDAP Contact
    if (iContact && iOwnsContact)
        {
        delete iContact;
        iContact = NULL;
        }
    }

// -----------------------------------------------------------------------------
//                          CContact public methods
// -----------------------------------------------------------------------------
// CContact::Index
// Returns contact index.
// -----------------------------------------------------------------------------
//
TInt CContact::Index() const
    {
    return iIndex;
    }
// -----------------------------------------------------------------------------
// CContact::SetIndex
// Sets contact index.
// -----------------------------------------------------------------------------
//
void CContact::SetIndex(TInt aIndex)
    {
    iIndex = aIndex;
    }

// -----------------------------------------------------------------------------
// CContact::Store
// Returns the store of this contact.
// -----------------------------------------------------------------------------
//
CContactStore& CContact::Store() const
    {
    return iStore;
    }

// -----------------------------------------------------------------------------
// CContact::LDAPContact
// Returns the contact inside this contact.
// -----------------------------------------------------------------------------
//
CLDAPContact& CContact::LDAPContact() const
    {
    return *iContact;
    }

// -----------------------------------------------------------------------------
// CContact::Contact
// Returns the contact inside this contact.
// -----------------------------------------------------------------------------
//
CLDAPContact* CContact::Contact() const
    {
    return iContact;
    }

// -----------------------------------------------------------------------------
//                      MVPbkObjectHierarchy implementation
// -----------------------------------------------------------------------------
// CContact::ParentObject
// Returns parent of this contact - store
// -----------------------------------------------------------------------------
//
MVPbkObjectHierarchy& CContact::ParentObject() const
    {
    return iStore;
    }

// -----------------------------------------------------------------------------
//                      MVPbkBaseContact implementation
// -----------------------------------------------------------------------------
// CContact::Fields
// Returns this contact's fields (read only).
// -----------------------------------------------------------------------------
//
const MVPbkStoreContactFieldCollection& CContact::Fields() const
    {
    return iFields;
    }

// -----------------------------------------------------------------------------
// CContact::IsSame
// Returns true if this is same contact.
// -----------------------------------------------------------------------------
//
TBool CContact::IsSame(const MVPbkStoreContact& aOtherContact) const
    {
    // From same store
    if (&ParentStore() == &aOtherContact.ParentStore())
        {
        // Cast to contact
        const CContact& other = static_cast<const CContact&>(aOtherContact);
        // Same index
        return (other.Index() == Index());
        }
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CContact::CreateLinkLC
// Creates link representing this contact.
// -----------------------------------------------------------------------------
//
MVPbkContactLink* CContact::CreateLinkLC() const
    {
    return CContactLink::NewLC(iStore,Index());
    }

// -----------------------------------------------------------------------------
// CContact::DeleteL
// -----------------------------------------------------------------------------
//
void CContact::DeleteL(MVPbkContactObserver& /* aObserver */) const
    {
    // Cannot delete, contact is from read only store
    User::Leave(KErrAccessDenied);
    }

// -----------------------------------------------------------------------------
// CContact::MatchContactStore
// -----------------------------------------------------------------------------
//
TBool CContact::MatchContactStore(const TDesC& aContactStoreUri) const
    {
    return iStore.MatchContactStore(aContactStoreUri);
    }

// -----------------------------------------------------------------------------
// CContact::MatchContactStoreDomain
// -----------------------------------------------------------------------------
//
TBool CContact::MatchContactStoreDomain(const TDesC& aContactStoreDomain) const
    {
    return iStore.MatchContactStoreDomain(aContactStoreDomain);
    }

// -----------------------------------------------------------------------------
// CContact::CreateBookmarkLC
// Bookmark this contact.
// -----------------------------------------------------------------------------
//
MVPbkContactBookmark* CContact::CreateBookmarkLC() const
    {
    return CStoreBookmark::NewLC(iStore,Index());
    }

// -----------------------------------------------------------------------------
//                      MVPbkStoreContact implementation
// -----------------------------------------------------------------------------
// CContact::ParentStore
// Returns this contact's parent store.
// -----------------------------------------------------------------------------
//
MVPbkContactStore& CContact::ParentStore() const
    {
    return iStore;
    }

// -----------------------------------------------------------------------------
// CContact::Fields
// Returns this contact's fields.
// -----------------------------------------------------------------------------
//
MVPbkStoreContactFieldCollection& CContact::Fields()
    {
    return iFields;
    }

// -----------------------------------------------------------------------------
// CContact::CreateFieldLC
// Create field
// -----------------------------------------------------------------------------
//
MVPbkStoreContactField* CContact::CreateFieldLC(
    const MVPbkFieldType& /* aFieldType */) const
    {
    // Cannot create ldap fields like this
    User::Leave(KErrAccessDenied);
    return NULL;
    }

// -----------------------------------------------------------------------------
// CContact::AddFieldL
// Add field
// -----------------------------------------------------------------------------
//
TInt CContact::AddFieldL(MVPbkStoreContactField* /* aField */)
    {
    // Cannot add fields
    User::Leave(KErrAccessDenied);
    return KErrAccessDenied;
    }

// -----------------------------------------------------------------------------
// CContact::RemoveField
// Remove field
// -----------------------------------------------------------------------------
//
void CContact::RemoveField(TInt /* aIndex */)
    {
    // Cannot remove - this is not yet defined, should be coming
    // VPbkError::Panic(VPbkError::EInvalidAccessToReadOnlyContact);
    }

// -----------------------------------------------------------------------------
// CContact::RemoveAllFields
// Remove all field
// -----------------------------------------------------------------------------
//
void CContact::RemoveAllFields()
    {
    // Cannot remove - this is not yet defined, should be coming
    // VPbkError::Panic(VPbkError::EInvalidAccessToReadOnlyContact);
    }

// -----------------------------------------------------------------------------
// CContact::LockL
// -----------------------------------------------------------------------------
//
void CContact::LockL(MVPbkContactObserver& /* aObserver */) const
    {
    // Read only
    User::Leave(KErrAccessDenied);
    }

// -----------------------------------------------------------------------------
// CContact::CommitL
// -----------------------------------------------------------------------------
//
void CContact::CommitL(MVPbkContactObserver& /* aObserver */) const
    {
    // Read only
    User::Leave(KErrAccessDenied);
    }

// -----------------------------------------------------------------------------
// CContact::GroupsJoinedLC
// -----------------------------------------------------------------------------
//
MVPbkContactLinkArray* CContact::GroupsJoinedLC() const
    {
    // No groups
    return NULL;
    }
   
// -----------------------------------------------------------------------------
// CContact::Group
// -----------------------------------------------------------------------------
//
MVPbkContactGroup* CContact::Group()
    {
    // No groups
    return NULL;
    }    

// -----------------------------------------------------------------------------
// CContact::MaxNumberOfFieldL
// -----------------------------------------------------------------------------
//
TInt CContact::MaxNumberOfFieldL(const MVPbkFieldType& /* aType */) const
    {
    return KVPbkStoreContactUnlimitedNumber;
    }

} // End of namespace LDAPStore
// -----------------------------------------------------------------------------
//  End of File
// -----------------------------------------------------------------------------