/*

* Copyright (c) 2009 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:

*

*/

#include "CdlCompilerToolkit/CdlTkInstance.h"

#include "CdlTkPriv.h"

#include <sstream>

using namespace std;

namespace CdlCompilerToolkit {

//

// PackageErr

//

class PackageErr : public CdlCompilerToolkitErr

	{

public:

	void Show(ostream& aStream) const;

	};

void PackageErr::Show(ostream& aStream) const

	{

	aStream << "Interface does not define a package";

	}

//

// CCdlTkPackage::CRef

//

CCdlTkPackage::CRef::CRef()

: iId(KCdlTkGetInstanceIdFromHostDll), iUid(0)

	{

	}

const string& CCdlTkPackage::CRef::LocalInstanceName() const

	{

	return iLocalInstanceName;

	}

void CCdlTkPackage::CRef::SetLocalInstanceName(const string& aLocalInstanceName)

	{

	iLocalInstanceName = aLocalInstanceName;

	}

int CCdlTkPackage::CRef::Id() const

	{

	return iId;

	}

void CCdlTkPackage::CRef::SetId(int aId)

	{

	iId = aId;

	}

int CCdlTkPackage::CRef::Uid() const

	{

	return iUid;

	}

void CCdlTkPackage::CRef::SetUid(int aUid)

	{

	iUid = aUid;

	}

const string& CCdlTkPackage::CRef::DllName() const

	{

	return iDllName;

	}

void CCdlTkPackage::CRef::SetDllName(const string& aDllName)

	{

	iDllName = aDllName;

	}

const string& CCdlTkPackage::CRef::DllSourcePath() const

	{

	return iDllSourcePath;

	}

void CCdlTkPackage::CRef::SetDllSourcePath(const string& aDllSourcePath)

	{

	iDllSourcePath = aDllSourcePath;

	}

const string& CCdlTkPackage::CRef::DllInstName() const

	{

	return iDllInstName;

	}

void CCdlTkPackage::CRef::SetDllInstName(const string& aDllInstName)

	{

	iDllInstName = aDllInstName;

	}

//

// CCdlTkPackage

//

CCdlTkPackage::CCdlTkPackage(const CCdlTkInterface& aInterface)

: CCdlTkInstance(aInterface)

	{

	iContentsImpl = Impl().Find(KPackageContentsApi);

	if (!iContentsImpl)

		throw PackageErr();

	GenerateImpl();

	}

CCdlTkPackage::~CCdlTkPackage()

	{

	}

void CCdlTkPackage::AddLocalContent(const CCdlTkInstance& aInstance)

	{

	CRef ref;

	ref.SetLocalInstanceName(aInstance.Name());

	iContents.push_back(ref);

	GenerateImpl();

	}

void CCdlTkPackage::AddLocalContent(const string& aLocalInstanceName)

	{

	CRef ref;

	ref.SetLocalInstanceName(aLocalInstanceName);

	iContents.push_back(ref);

	GenerateImpl();

	}

void CCdlTkPackage::AddContent(const CCdlTkInstance& aInstance, const CCdlTkDll& aDll, const std::string& aDllSourcePath)

	{

	CRef ref;

	ref.SetId(aInstance.Id());

	ref.SetUid(aInstance.Interface().Header().Uid());

	ref.SetDllName(aDll.Name());

	ref.SetDllSourcePath(aDllSourcePath);

	ref.SetDllInstName(aInstance.DllInstanceName());

	iContents.push_back(ref);

	GenerateImpl();

	}

void CCdlTkPackage::AddContent(int aId, int aUid, const string& aDllName)

	{

	CRef ref;

	ref.SetId(aId);

	ref.SetUid(aUid);

	ref.SetDllName(aDllName);

	iContents.push_back(ref);

	GenerateImpl();

	}

void CCdlTkPackage::AddExternalContent(const string& aInstanceName, const string& aDllSourcePath, const string& aDllName)

	{

	CRef ref;

	ref.SetDllInstName(aInstanceName);

	ref.SetDllName(aDllName);

	ref.SetDllSourcePath(aDllSourcePath);

	iContents.push_back(ref);

	GenerateImpl();

	}

const CCdlTkPackage::CRefs& CCdlTkPackage::Contents() const

	{

	return iContents;

	}

const string KArrayStart = "\

\n\

CDL_ARRAY_START(TCdlRef, contents)\n\

\t{\n";

const string KArrayEnd = "\

\t}\n\

CDL_ARRAY_END(TCdlRef, contents);\n";

void CCdlTkPackage::GenerateImpl()

	{

	string defn;

	if (iContents.empty())

		{

		defn = "EMPTY_CDL_ARRAY(TCdlRef, contents)\n";

		}

	else

		{

		set<string> dllNames;

		AddIncludesAndBuildDllSet(defn, dllNames);

		AddDllNameLits(defn, dllNames);

		CdlTkUtil::AppendString(defn, KArrayStart);

		AddContents(defn);

		CdlTkUtil::AppendString(defn, KArrayEnd);

		}

	iContentsImpl->SetDefinition(defn);

	}

const string KInclude = "#include \"$NAME\"\n";

void CCdlTkPackage::AddIncludesAndBuildDllSet(string& aDefn, set<string>& aDllNames)

	{

	for (CRefs::iterator pRef = iContents.begin(); pRef != iContents.end(); ++pRef)

		{

		CRef& ref = *pRef;

		string locInst = CdlTkUtil::ToLower(ref.LocalInstanceName());

		if (locInst.empty())

			{

			// if it's not a local instance, add its dll name to the set

			string dllName = ref.DllName();

			if (!dllName.empty())

				aDllNames.insert(dllName);

			// if the instance id comes from its host DLL, #include the host DLL ids

			if (ref.Id() == KCdlTkGetInstanceIdFromHostDll)

				{

				string include = CdlTkUtil::ToLower(ref.DllSourcePath() + KDllInstHeader);

				CdlTkUtil::AppendString(aDefn, CdlTkUtil::Replace("$NAME", include, KInclude));

				include = CdlTkUtil::ToLower(ref.DllSourcePath() + ref.DllInstName() + ".h");

				CdlTkUtil::AppendString(aDefn, CdlTkUtil::Replace("$NAME", include, KInclude));

				}

			}

		else

			{

			// #include local instances

			CdlTkUtil::AppendString(aDefn, CdlTkUtil::Replace("$NAME", locInst+".h", KInclude));

			}

		}

	}

const string KDllLit = "_LIT(_content_DLL_$CPP_NAME, \"$DLL_NAME\");\n";

void CCdlTkPackage::AddDllNameLits(string& aDefn, set<string>& aDllNames)

	{

	// add literals for all of the DLL names

	for (set<string>::iterator pDll = aDllNames.begin(); pDll != aDllNames.end(); ++pDll)

		{

		CdlTkUtil::AppendString(aDefn, 

			CdlTkUtil::Replace("$CPP_NAME", CdlTkUtil::ToCpp(*pDll), 

				CdlTkUtil::Replace("$DLL_NAME", *pDll, KDllLit)));

		}

	}

const string KLocRef = "\tLOCAL_CDL_REF($NAME),\n";

void CCdlTkPackage::AddContents(string& aDefn)

	{

	for (CRefs::iterator pRef = iContents.begin(); pRef != iContents.end(); ++pRef)

		{

		string locInst = pRef->LocalInstanceName();

		if (locInst.empty())

			{

			// if it's not a local instance use {} intialisation

			string id;

			string uid;

			if (pRef->Id() == KCdlTkGetInstanceIdFromHostDll)

				{

				id = pRef->DllInstName() + "::KCdlInstanceId";

				uid = pRef->DllInstName() + "::KCdlInterfaceUidValue";

				}

			else

				{

				id = CdlTkUtil::IntToString(pRef->Id());

				uid = pRef->Uid();

				}

			stringstream ref;

			ref << "\t{" << id << ", " << uid << ", ";

			// empty DLL name implies that the instance is in the same DLL,

			// use use a null pointer, otherwise use the literal

			string dllName = pRef->DllName();

			if (dllName.empty())

				ref << "NULL";

			else

				ref << "LIT_AS_DESC_PTR(_content_DLL_" << CdlTkUtil::ToCpp(dllName) << ")";

			ref << "},\n";

			CdlTkUtil::AppendString(aDefn, ref.str());

			}

		else

			{

			// local instances use the LOCAL_CDL_REF macro.

			CdlTkUtil::AppendString(aDefn, CdlTkUtil::Replace("$NAME", CdlTkUtil::ToCpp(locInst), KLocRef));

			}

		}

	}

}	// end of namespace CdlCompilerToolkit