/*
* 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:
*
*/
#ifndef CDLTKINSTANCE_H
#define CDLTKINSTANCE_H
#pragma warning (disable:4786) // disable "identifier was truncated to '255' characters in the browser information" warning
#include <CdlCompilerToolkit/CdlTkInterface.h>
#include <vector>
#include <set>
namespace CdlCompilerToolkit {
class CCdlTkDll;
class CCdlTkInstance;
const int KCdlTkGetInstanceIdFromHostDll = -1;
/**
* The implementation of a single API from a CDL interface.
*/
class CCdlTkImplementation
{
public:
/**
* constructor
* @param aInstance the customisation instance to which this implementation belongs
* @param aApi the API that this implements
*/
CCdlTkImplementation(const CCdlTkInstance& aInstance, const CCdlTkApi& aApi);
/**
* destructor
*/
~CCdlTkImplementation();
/**
* Get the implementation's definition.
* @return the implementation's definition.
*/
std::string Definition() const;
/**
* Set the implementation's definition.
* @param aDefn the implementation's definition.
*/
void SetDefinition(const std::string& aDefn);
/**
* Set the implementation's definition to be that defined by the data type translations
* provided by the interface.
*/
void SetTemplateDefinition();
/**
* Get a pointer reference for the implementation.
* @return a pointer reference for the implementation.
*/
std::string PointerReference() const;
/**
* Set a pointer reference for the implementation.
* @param aPtr a pointer reference for the implementation.
*/
void SetPointerReference(const std::string& aPtr);
/**
* Set the implementation's pointer reference to be that defined by the data type translations
* provided by the interface.
*/
void SetTemplatePointerReference();
/**
* Set both the definition and pointer reference to be that defined by the data type
* translations provided by the interface.
*/
void SetTemplate();
/**
* Set an empty definition and NULL pointer reference
*/
void SetNull();
/**
* Get the customisation instance to which this implementation belongs
* @return the customisation instance to which this implementation belongs
*/
const CCdlTkInstance& Instance() const;
/**
* Get the API which this implementation implements
* @return the API which this implementation implements
*/
const CCdlTkApi& Api() const;
/**
* Get the name of the implementation, which is also the name of API that this implements
* @return the name of the implementation
*/
const std::string& Name() const;
private:
const CCdlTkDataTypeTranslation* GetTranslation(const std::string& aType, std::string& aTypeVar);
private:
const CCdlTkInstance& iInstance;
const CCdlTkApi& iApi;
std::string iDefn;
std::string iPtr;
};
/**
* A collection of implementations of the APIs in an API list. There is one implementation
* for each API and they appear in the same order as the API list.
*/
class CCdlTkImplementations
{
private:
typedef std::vector<CCdlTkImplementation*> CImpl;
public:
/**
* constructor
* @param aInstance the customisation instance to which these implementations belong
* @param aApiList the APIs that define what implementations appear in this collection
*/
CCdlTkImplementations(const CCdlTkInstance& aInstance, const CCdlTkApiList& aApiList);
/**
* destructor
*/
~CCdlTkImplementations();
/**
* Find an implementation by name
* @param aName the name of the implemntation to find
* @return the implmentation, or NULL if none is found
*/
CCdlTkImplementation* Find(const std::string& aName) const;
/**
* Set all implementations to be null.
*/
void ClearAll();
/**
* Set all implementations to have the template definition and pointer reference syntax
* defined by the data type translations from the interface.
*/
void TemplateAll();
public:
// iterator interface
/**
* The iterator type
*/
typedef CImpl::iterator iterator;
/**
* The const iterator type
*/
typedef CImpl::const_iterator const_iterator;
/**
* begin iterator
*/
iterator begin() { return iImpl.begin(); }
/**
* begin iterator
*/
const_iterator begin() const { return iImpl.begin(); }
/**
* end iterator
*/
iterator end() { return iImpl.end(); }
/**
* end iterator
*/
const_iterator end() const { return iImpl.end(); }
private:
CImpl iImpl;
};
/**
* a customisation instance
*/
class CCdlTkInstance
{
public:
/**
* constructor
* @param aInterface the CDL interface that this instance implements
*/
CCdlTkInstance(const CCdlTkInterface& aInterface);
/**
* destructor
*/
~CCdlTkInstance();
/**
* Get the implementations that make up this instance
* @return the implementations that make up this instance
*/
CCdlTkImplementations& Impl();
/**
* Get the implementations that make up this instance
* @return the implementations that make up this instance
*/
const CCdlTkImplementations& Impl() const;
/**
* Set all implementations to be null.
*/
void ClearAllImplementations();
/**
* Set all implementations to have the template definition and pointer reference syntax
* defined by the data type translations from the interface.
*/
void TemplateAllImplementations();
/**
* Set the name of this customisation instance
* @param aName the name of this customisation instance
*/
void SetName(const std::string& aName);
/**
* Get the name of this customisation instance
* @return the name of this customisation instance
*/
const std::string& Name() const;
/**
* Get an identifier for this customisation instance that its
* host DLL can use to identify it.
* @return the fully qualified name of this customisation instance
*/
std::string DllInstanceName() const;
/**
* Turn an instance name into an identifier that a DLL can use to set
* the instance id.
* @param aName the instance name
* @return the DLL instance id string
*/
static std::string InstanceNameToDllInstanceName(const std::string& aName);
/**
* Set the id of this customisation instance to be got from the host DLL.
* The id is used to distinguish this instance from others in a customisation DLL.
* Getting the id from the host DLL optimised the lookup process.
* Note, the instance is automatically created with the this id. So, this
* function only needs to be used if the id has been previously set to another
* value.
*/
void SetId();
/**
* Set the id of this customisation instance.
* The id is used to distinguish this instance from others in a customisation DLL.
* This function does not generate as efficient code as SetId()
* @param aId the id of this customisation instance
*/
void SetId(int aId);
/**
* Get the id of this customisation instance.
* The id is used to distinguish this instance
* from others in a customisation DLL.
* @return the id of this customisation instance, which may be
* KCdlTkGetInstanceIdFromHostDll if the id is to come from the host DLL.
*/
int Id() const;
/**
* Get the interface that this instance implements.
* @return the interface that this instance implements.
*/
const CCdlTkInterface& Interface() const;
/**
* Set the extra C++ section for this instance. This may add any extra C++ code required
* by the API implementations. For instance, helper functions or #includes
* @param aExtra the extra C++ section for this instance
*/
void SetExtraCpp(const std::string& aExtra);
/**
* Get the extra C++ section for this instance. This may be extra C++ code required
* by the API implementations. For instance, helper functions or #includes
* @return the extra C++ section for this instance
*/
const std::string& ExtraCpp() const;
private:
const CCdlTkInterface& iInterface;
CCdlTkImplementations iImpl;
std::string iName;
int iId;
std::string iExtraCpp;
};
/**
* A customisation instance that implements a CDL package interface.
* a CDL package interface is one that contains the following API:
* TCdlArray<TCdlRef> contents;
*/
class CCdlTkPackage : public CCdlTkInstance
{
private:
class CRef
{
public:
CRef();
const std::string& LocalInstanceName() const;
void SetLocalInstanceName(const std::string& aLocalInstanceName);
int Id() const;
void SetId(int aId);
int Uid() const;
void SetUid(int aUid);
const std::string& DllName() const;
void SetDllName(const std::string& aDllName);
const std::string& DllSourcePath() const;
void SetDllSourcePath(const std::string& aDllSourcePath);
const std::string& DllInstName() const;
void SetDllInstName(const std::string& aDllInstName);
private:
std::string iLocalInstanceName;
int iId;
int iUid;
std::string iDllName;
std::string iDllSourcePath;
std::string iDllInstName;
};
typedef std::vector<CRef> CRefs;
public:
/**
* constructor
* @param aInterface the CDL package interface that this package implements
*/
CCdlTkPackage(const CCdlTkInterface& aInterface);
/**
* destructor
*/
~CCdlTkPackage();
/**
* Adds a customisation instance which will appear in the same DLL as this package
* @param aInstance a customisation instance to be referenced by this package
*/
void AddLocalContent(const CCdlTkInstance& aInstance);
/**
* Adds a customisation instance which will appear in the same DLL as this package
* @param aLocalInstanceName a customisation instance name to be referenced by this package
*/
void AddLocalContent(const std::string& aLocalInstanceName);
/**
* Adds a customisation instance which will appear in another DLL to this package
* @param aInstance the instance to add to this package
* @param aDll the DLL that the instance appears in.
* @param aDllSourcePath the path to the source code for the DLL that
* the instance appears in. This may be an empty string if the instance
* has an instance id other than KCdlTkGetInstanceIdFromHostDll, or if the
* instance appears in the same DLL as this package.
*/
void AddContent(const CCdlTkInstance& aInstance, const CCdlTkDll& aDll, const std::string& aDllSourcePath);
/**
* Adds a customisation instance which may appear in another DLL to this package
* @param aId the id of the customisation instance.
* @param aUid the UID of the customisation instance's interface
* @param aDllName the DLL in which the customisation instance appears. This may be
* an empty string if the instance appears in the same DLL as this package.
*/
void AddContent(int aId, int aUid, const std::string& aDllName);
/**
* Adds a customisation instance which appears in another DLL created by the
* CDL compiler, and whose source is available.
* @param aInstanceName the customisation instance name used in the other DLL
* @param aDllSourcePath the path to the other DLLs source
* @param aDllName the name of the other DLL
*/
void AddExternalContent(const std::string& aInstanceName, const std::string& aDllSourcePath, const std::string& aDllName);
private:
const CRefs& Contents() const;
void GenerateImpl();
void AddIncludesAndBuildDllSet(std::string& aDefn, std::set<std::string>& aDllNames);
void AddDllNameLits(std::string& aDefn, std::set<std::string>& aDllNames);
void AddContents(std::string& aDefn);
private:
CRefs iContents;
CCdlTkImplementation* iContentsImpl; // not owned, can't be initialised until base class is constructed
};
/**
* a customisation DLLs contents and build information
*/
class CCdlTkDll
{
public:
/**
* a collection of customisation instance names that will appear in the DLL
*/
typedef std::vector<std::string> CInstances;
/**
* a collection of libraries that the DLL needs to link to
*/
typedef std::vector<std::string> CLibraries;
public:
/**
* constructor
*/
CCdlTkDll();
/**
* destructor
*/
~CCdlTkDll();
/**
* Adds a customisation instance to the DLL
* @param aInstance a customisation instance
*/
void AddInstance(const CCdlTkInstance& aInstance);
/**
* Adds a customisation instance to the DLL
* @param aInstanceName the name of a customisation instance
*/
void AddInstance(const std::string& aInstanceName);
/**
* Gets the collection of customisation instances that appear in this DLL
* @return the collection of customisation instances that appear in this DLL
*/
const CInstances& Instances() const;
/**
* Set the name of the DLL
* @param aName the name of the DLL
*/
void SetName(const std::string& aName);
/**
* Get the name of the DLL
* @return the name of the DLL
*/
const std::string& Name() const;
/**
* Set the UID of the DLL
* @param aUid the UID of the DLL
*/
void SetUid(int aUid);
/**
* Get the UID of the DLL
* @return the UID of the DLL
*/
int Uid() const;
/**
* Set the version of the DLL
* @param aVersion the version number of the DLL
*/
void SetVersion(int aVersion);
/**
* Get the version number of the DLL
* @return the version number of the DLL
*/
int Version() const;
/**
* Add a library name to the DLL
* @param aLibName a library name
*/
void AddLibrary(const std::string& aLibName);
/**
* Get the collection of libraries that this DLL links to
* @return the collection of libraries that this DLL links to
*/
const CLibraries& Libraries() const;
/**
* Get the collection of libraries that this DLL links to
* @return the collection of libraries that this DLL links to
*/
CLibraries& Libraries();
/**
* Set any extra MMP file content that the DLL needs
* @param aExtraMmp extra MMP file content that the DLL needs
*/
void SetExtraMmp(const std::string& aExtraMmp);
/**
* Get the extra MMP file content that has been set for the DLL
* @return the extra MMP file content that has been set for the DLL
*/
const std::string& ExtraMmp() const;
private:
std::string iName;
int iUid;
CInstances iInstances;
CLibraries iLibraries;
std::string iExtraMmp;
std::set<std::string> iUniqueInstances;
int iVersion;
};
} // end of namespace CdlCompilerToolkit
#endif