/*

* 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: 

*

*/

#ifndef __R_DIR_H__

#define __R_DIR_H__

#include <e32std.h>

// Generalised set handling

class SetMember

	{

public:

	TBool operator==(const SetMember& aMember) {return(Compare(aMember)==0);}

	virtual SetMember* Copy() const =0;

	virtual void Close();

public:

	TInt Type() const {return iType;}

	virtual TInt Compare(const SetMember& aMember) const =0;

	virtual void DebugPrint() const =0;

protected:

	virtual ~SetMember();

	SetMember(TInt aType) : iType(aType) {TotalInSystem++;}

	SetMember(const SetMember& aMember) : iType(aMember.iType) {TotalInSystem++;}

	TBool operator<(const SetMember& aMember) {return(Compare(aMember)<0);}

	TBool operator>(const SetMember& aMember) {return(Compare(aMember)>0);}

private:

	TInt iType;

	static TInt TotalInSystem;

	};

class FiniteSet : public SetMember

	{

protected:

	enum TFiniteSetType {EFiniteSetType=100};

public:

	static FiniteSet* New(TInt aMaxCount);

	static FiniteSet* Singleton(TInt aMaxCount, const SetMember& aMember);

	virtual ~FiniteSet();

	virtual SetMember* Copy() const;

	TInt Find(const SetMember& aMember) const;

	TBool SubsetOf(const FiniteSet& aSet) const;

	TInt Intersection(const FiniteSet& aSet);

	TInt Union(const FiniteSet& aSet);

	TInt Difference(const FiniteSet& aSet);

	TInt Add(const SetMember& aMember);

	TInt Remove(const SetMember& aMember);

	SetMember* Detach(TInt anIndex);

	TInt Count() const {return iCount;}

	TBool Empty() const {return !iCount;}

	SetMember& operator[](TInt anIndex) const {return *iMembers[anIndex];}

	virtual void DebugPrint() const;

protected:

	FiniteSet(TInt aMaxCount);

	FiniteSet(const FiniteSet& aSet);

	FiniteSet* Construct();

	virtual TInt Compare(const SetMember& aMember) const;

	TInt Find(const SetMember& aMember, TInt& anIndex) const;

	TInt Insert(const SetMember& aMember, TInt anIndex);

protected:

	TInt iMaxCount;

	TInt iCount;

	SetMember** iMembers;

	};

// ROMBUILD-specific stuff

#include <e32rom.h>

class CObeyFile;

class TRomNode;

class THardwareVariant;

class RomFileStructure;

class TVariantList

	{

public:

	enum {EMaxVariants=32};

	static void Setup(CObeyFile* aObey);

	TVariantList() : iList(0)

		{}

	TVariantList(TInt aVariant)

		{iList=TUint(1<<aVariant);}

	TVariantList(THardwareVariant a);

	void Add(TInt aVariant)

		{iList|=TUint(1<<aVariant);}

	TVariantList& Union(const TVariantList aList)

		{iList|=aList.iList; return *this;}

	TVariantList& Intersection(const TVariantList aList)

		{iList&=aList.iList; return *this;}

	TBool operator==(const TVariantList aList) const

		{return(iList==aList.iList);}

	TBool operator!=(const TVariantList aList) const

		{return(iList!=aList.iList);}

	TBool operator<=(const TVariantList aList) const

		{return(iList==(iList&aList.iList));}

	TBool operator>=(const TVariantList aList) const

		{return(iList==(iList|aList.iList));}

	TBool operator[](TInt aVariant) const

		{return(iList&TUint(1<<aVariant));}

	TBool Empty() const

		{return !iList;}

	TUint Mask() const

		{return iList;}

	THardwareVariant Lookup() const;

	static void SetNumVariants(TInt aNumVariants);

	static void SetVariants(THardwareVariant* aVariants);

private:

	friend class RomFileStructure;

	TUint iList;

	static TInt NumVariants;

	static THardwareVariant Variants[EMaxVariants];

	};

class Entry : public SetMember

	{

public:

	Entry(TInt aType) : SetMember(aType), iRomNode(NULL) {}

	Entry(const Entry& anEntry) : SetMember(anEntry), iRomNode(NULL) {}

	TBool IsFile() const {return (Type()==EFile);}

	TBool IsDir() const {return (Type()==EDir);}

	TVariantList Variants() const {return iVariants;}

	TRomEntry* CreateRomEntry(char*& anAddr) const;

	void Restrict(TVariantList aList) {iVariants.Intersection(aList);}

	const char* Name() const;

protected:

	enum {EFile=0, EDir=1};

	TVariantList iVariants;

	TRomNode* iRomNode;

	};

class FileEntry : public Entry

	{

public:

	static FileEntry* New(TRomNode* aFile);

	virtual SetMember* Copy() const;

	virtual ~FileEntry();

	virtual void DebugPrint() const;

protected:

	FileEntry() : Entry(EFile) {}

	FileEntry(const FileEntry& aFileEntry);

	virtual TInt Compare(const SetMember& aMember) const;

	};

class Directory;

class DirEntry : public Entry

	{

public:

	static DirEntry* New(TRomNode* aFile, Directory* aDir);

	virtual SetMember* Copy() const;

	virtual ~DirEntry();

	Directory* Dir() const {return iDir;}

	TRomDir* CreateRomEntries(char*& anAddr) const;

	virtual void DebugPrint() const;

protected:

	DirEntry() : Entry(EDir) {}

	DirEntry(const DirEntry& aDirEntry);

	virtual TInt Compare(const SetMember& aMember) const;

protected:

	Directory* iDir;

	};

class Directory : public FiniteSet

	{

public:

	static Directory* New(TInt aMaxCount, TVariantList aList);

	TInt Compile(const FiniteSet& aSet);

	TInt Merge(const Directory& aDir);

	TVariantList Variants() const {return iVariants;}

	virtual void DebugPrint() const;

	void Open();

	virtual void Close();

protected:

	Directory(TInt aMaxCount);

private:

	Directory(const Directory &);

	~Directory();

protected:

	friend class DirEntry;

	TVariantList iVariants;

	TRomDir* iRomDir;

private:

	static TInt DirectoryCount;

private:

	TInt iAccessCount;

	TInt iIdentifier;

	};

class RomFileStructure : public FiniteSet

	{

public:

	static RomFileStructure* New(TInt aMaxCount);

	~RomFileStructure();

	void Destroy();

	TInt ProcessDirectory(TRomNode* aDir);

protected:

	RomFileStructure(TInt aMaxCount);

	};

#endif