// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// f32\sfat\sl_fatcache.inl
// 
//

/**
 @file
*/

#ifndef SL_FAT_CACHE_INL
#define SL_FAT_CACHE_INL




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

TUint32 CFatCacheBase::FatStartPos() const 
    {
    return iFatStartPos;
    }

TUint32 CFatCacheBase::FatSize() const 
    {
    return iFatSize;
    }

TFatType CFatCacheBase::FatType() const 
    {
    return iFatType;
    }

TBool CFatCacheBase::IsDirty() const 
    {
    return iDirty;
    }

void CFatCacheBase::SetDirty(TBool aDirty) 
    {
    iDirty = aDirty;
    }

TUint CFatCacheBase::NumFATs() const 
    {
    return iNumFATs;
    }

TUint CFatCacheBase::FAT_SectorSzLog2() const 
    {
    return iFatSecSzLog2;
    }

TUint CFatCacheBase::FAT_SectorSz() const 
    {
    return 1 << iFatSecSzLog2;
    }

TUint CFatCacheBase::FAT_ClusterSzLog2() const 
    {
    return iFatClustSzLog2;
    }
    

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

/** @return number of FAT cache sectors in this fixed cache */
TUint32 CFat12Cache::NumSectors() const   
    {
    return iSectorsInCache;
    }


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


/** @return Log2(page size in bytes) */
TUint CFatPagedCacheBase::PageSizeLog2() const 
    {
    return iPageSizeLog2;
    }

/** @return page size in bytes */
TUint CFatPagedCacheBase::PageSize() const 
    {
    return Pow2(iPageSizeLog2);
    }

/** @return Log2(size of the logical sector of the page in bytes) */    
TUint CFatPagedCacheBase::SectorSizeLog2() const 
    {
    return iSectorSizeLog2;
    }

/** @return number of the logical sector in the page */
TUint CFatPagedCacheBase::SectorsInPage() const 
    {
    return Pow2(iPageSizeLog2 - iSectorSizeLog2);
    }


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

TUint CFat16FixedCache::NumPages() const 
    {
    return (TUint)iPages.Count();
    } 

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


/** @return  the index in the FAT table this page starts from */
TUint32 CFatCachePageBase::StartFatIndex() const 
    {
    return iStartIndexInFAT;
    }

/** @return number of FAT entries in the page */
TUint32 CFatCachePageBase::EntriesInPage() const 
    {
    return iFatEntriesInPage;
    }

/** @return page state */
CFatCachePageBase::TState CFatCachePageBase::State() const
    {
    return iState;
    }

/** sets the state of the page */
void CFatCachePageBase::SetState(TState aState)
    {
    iState = aState;
    }

/** @return ETrue if the page is dirty, i.e. contains non-flushed dirty sectors */
TBool CFatCachePageBase::IsDirty() const
    {
    if(State() == EDirty)
        {
        ASSERT(iDirtySectors.HasBitsSet());
        return ETrue;
        }
    else
        {
        ASSERT(!iDirtySectors.HasBitsSet());
        return EFalse;
        }
    }

/** @return  ETrue if the page data are valid */
TBool CFatCachePageBase::IsValid() const
    {
    return (State() == EClean || State() == EDirty);
    }

/** force the page to the clean state */
void CFatCachePageBase::SetClean()
    {
    iDirtySectors.Clear(); //-- clear dirty sectors bitmap
    SetState(EClean);
    }

/** @return page size in bytes */
TUint32 CFatCachePageBase::PageSize() const 
    {
    return iCache.PageSize();
    }

/** @return number of logical sectors in the page */
TUint32 CFatCachePageBase::NumSectors() const 
    {
    return iCache.SectorsInPage();
    }

/** @return ETrue if the entry at aFatIndex belongs to this page */
TBool CFatCachePageBase::IsEntryCached(TUint32 aFatIndex) const
    {
    return (aFatIndex >= iStartIndexInFAT && aFatIndex < iStartIndexInFAT+EntriesInPage());
    } 


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






#endif //SL_FAT_CACHE_INL