--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitools_plat/cdl_api/inc/CdlCompilerToolkit/CdlTkInterface.h Thu Dec 17 09:14:18 2009 +0200
@@ -0,0 +1,976 @@
+/*
+* 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 CDLTKINTERFACE_H
+#define CDLTKINTERFACE_H
+#pragma warning (disable:4786) // disable "identifier was truncated to '255' characters in the browser information" warning
+
+
+#include <vector>
+#include <set>
+#include <string>
+#include <CdlCompilerToolkit/CdlTkUtil.h>
+
+namespace CdlCompilerToolkit {
+
+class CCdlTkInterface;
+class CCdlTkFunctionApi;
+class CCdlTkDataApi;
+
+
+/**
+* Header information for a CDL interface
+*/
+class CCdlTkInterfaceHeader
+ {
+public:
+ /**
+ * A collection of CDL interface flags. This class has operations to allow
+ * the flags to be manipulated through their textual name, or as an array
+ * of bits.
+ */
+ class CFlags
+ {
+ public:
+ /**
+ * constructor
+ */
+ CFlags();
+
+ /**
+ * Sets a flag to be on
+ * @param aFlagName the name of the flag to be turned on
+ */
+ void SetFlag(const std::string& aFlagName);
+ /**
+ * Sets a flag to be off
+ * @param aFlagName the name of the flag to be turned off
+ */
+ void ClearFlag(const std::string& aFlagName);
+
+ /**
+ * Returns a representation of the flags as a 32-bit integer
+ * @return a 32-bit integer containing a bit patterns representing the flags
+ */
+ int FlagsAsInt() const;
+ /**
+ * Returns a string representation of the flags
+ * @return a string containing the set flags' names combined with the
+ * C++ bitwise OR operator |.
+ * If no flags are set, "0" is returned.
+ */
+ std::string FlagsAsString() const;
+
+ /**
+ * Gives the number of bit flags that this class uses.
+ * @return the number of bit flags that this class uses.
+ */
+ int Count() const;
+ /**
+ * Test whether a flag is set, using a flag index between 0 and Count()-1
+ * to identify the flag.
+ * @param aFlagIndex the index of the flag in question
+ * @return the bool value of the flag
+ */
+ bool IsSet(int aFlagIndex) const;
+ /**
+ * Test whether a flag is set, using the flag name to identify the flag
+ * @param aFlagName the name of the flag in question
+ * @return the bool value of the flag
+ */
+ bool IsSet(const std::string& aFlagName) const;
+
+ /**
+ * Adds the set flags in another CFlags object to this one.
+ * @param aOther another CFlags object
+ * @return this modified object.
+ */
+ CFlags& operator|=(const CFlags& aOther);
+
+ /**
+ * Returns the name of a flag identified by its index
+ * @param aFlagIndex the index of the flag, between 0 and Count()-1
+ * @return the name of the flag
+ */
+ std::string FlagName(int aFlagIndex) const;
+
+ private:
+ int IndexToFlagVal(int aIndex) const;
+ int FlagVal(const std::string& aFlagName) const;
+
+ private:
+ int iFlags;
+ };
+
+ /**
+ * A version number
+ */
+ class CVersion
+ {
+ public:
+ /**
+ * constructor
+ */
+ CVersion();
+ /**
+ * constructor
+ * @param aMajor the major version number
+ * @param aMinor the minor version number
+ */
+ CVersion(int aMajor, int aMinor);
+
+ /**
+ * Compare two versions
+ * @param aOther another version number
+ * @return true if this version is less than the other version
+ */
+ bool operator<(const CVersion aOther) const;
+ /**
+ * Compare two versions
+ * @param aOther another version number
+ * @return true if the two versions are equal
+ */
+ bool operator==(const CVersion aOther) const;
+
+ /**
+ * The major version number
+ * @return the major version number
+ */
+ int Major() const;
+ /**
+ * Set the major verion number
+ * @param aMajor the major version number
+ */
+ void SetMajor(int aMajor);
+ /**
+ * The minor version number
+ * @return the minor version number
+ */
+ int Minor() const;
+ /**
+ * Set the minor verion number
+ * @param aMinor the minor version number
+ */
+ void SetMinor(int aMinor);
+
+ private:
+ int iMajor;
+ int iMinor;
+ };
+
+public:
+ /**
+ * constructor
+ */
+ CCdlTkInterfaceHeader();
+ /**
+ * Merge another header in with this one. This process is normally used
+ * when colapsing an extended CDL interface into a monolithic one.
+ * The other header is checked to make sure that it does nothing illegal,
+ * like change the name or UID, or decrease the version number, before the
+ * flags are merged and the version number is copied.
+ * @param aOther the header to merge with this one.
+ */
+ void MergeExtensionHeader(const CCdlTkInterfaceHeader& aOther);
+
+ /**
+ * Get the name of the CDL interface
+ * @return the name
+ */
+ std::string Name() const;
+ /**
+ * Set the name of the CDL interface
+ * @param aName the name for the CDL interface
+ */
+ void SetName(const std::string& aName);
+
+ /**
+ * Get the UID of the CDL interface
+ * @return the UID
+ */
+ int Uid() const;
+ /**
+ * Set the UID of the CDL interface
+ * @param aUid the UID for the CDL interface
+ */
+ void SetUid(int aUid);
+
+ /**
+ * Set the version of the CDL interface.
+ * @param aVersion The version for the interface
+ */
+ void SetVersion(const CVersion& aVersion);
+ /**
+ * Get the version of the CDL interface.
+ * @return the version of the CDL interface.
+ */
+ const CVersion& Version() const;
+
+ /**
+ * Get the flags for the CDL interface.
+ * @return the flags
+ */
+ const CFlags& Flags() const;
+ /**
+ * Get the flags for the CDL interface.
+ * @return a modifiable flags object
+ */
+ CFlags& Flags();
+
+ /**
+ * Compare this header with another
+ * @param aOther a header to compare this one with
+ * @return true if they are equal
+ */
+ bool operator==(const CCdlTkInterfaceHeader& aOther) const;
+
+private:
+ std::string iName;
+ int iUid;
+ CVersion iVer;
+ CFlags iFlags;
+ };
+
+
+/**
+* A single parameter in a function API in a CDL interface. It contains
+* a type and a name.
+*/
+class CCdlTkApiParam
+ {
+public:
+ /**
+ * constructor
+ */
+ CCdlTkApiParam();
+ /**
+ * constructor
+ * @param aType the parameter type
+ * @param aName the parameter name
+ */
+ CCdlTkApiParam(const std::string& aType, const std::string& aName);
+ /**
+ * constructor
+ * @param aType the parameter type
+ * @param aName the parameter name
+ * @param aDefaultValue the default value - If the supplied value is empty, there will be no default value
+ */
+ CCdlTkApiParam(const std::string& aType, const std::string& aName, const std::string& aDefaultValue);
+
+ /**
+ * Get the parameter type
+ * @return the parameter type
+ */
+ const std::string& Type() const;
+ /**
+ * Set the parameter type
+ * @param aType the type for the parameter
+ */
+ void SetType(const std::string& aType);
+
+ /**
+ * Get the parameter name
+ * @return the parameter name
+ */
+ const std::string& Name() const;
+ /**
+ * Set the parameter name
+ * @param aName the parameter name
+ */
+ void SetName(const std::string& aName);
+
+ /**
+ * Get the default value
+ * @return the default value - If there is no default value, the return value will be empty
+ */
+ const std::string& DefaultValue() const;
+ /**
+ * Set the default value
+ * @param aDefaultValue the default value - If the supplied value is empty, there will be no default value
+ */
+ void SetDefaultValue(const std::string& aDefaultValue);
+
+ /**
+ * compare two parameters
+ * @param aOther the parameter to compare with
+ * @return true if name, type, and default value are the same
+ */
+ bool operator==(const CCdlTkApiParam& aOther) const;
+
+ /**
+ * compare two parameters
+ * @param aOther the parameter to compare with
+ * @return true if any of name, type, and default value are not the same
+ */
+ bool operator!=(const CCdlTkApiParam& aOther) const
+ {
+ return !(*this == aOther);
+ }
+
+private:
+ std::string iType;
+ std::string iName;
+ std::string iDefaultValue;
+ };
+
+
+/**
+* The parameter list for a function API in a CDL interface
+*/
+class CCdlTkApiParams : public std::vector<CCdlTkApiParam>
+ {
+public:
+ /**
+ * Finds a parameter by its name
+ * @param aParamName the name of the parameter to look for
+ * @return an iterator pointing at the parameter, or end() if not found.
+ */
+ iterator FindByName(std::string aParamName);
+ };
+
+
+/**
+* A CDL data type translation.
+* Data type translations have three parts.
+* 1) the type that the translation matches.
+* 2) the syntax for defining an instance of that type.
+* 3) the pointer reference syntax for that type.
+* The type match string may contain the text "aType". This will match against
+* any content in a type to be matched.
+* The definition and pointer reference strings may contain the variables
+* "aName" and "aType". "aName" will be replaced by the instance name.
+* "aType" will be replaced by the text in the type string that matched "aType".
+*/
+class CCdlTkDataTypeTranslation
+ {
+public:
+ /**
+ * An enum used to identify the source of a data type translation, whether
+ * it is built into the CDL compiler toolkit, or it comes from a CDL file.
+ */
+ enum TTranslationSource
+ {
+ EInbuilt,
+ EFromCdl
+ };
+
+public:
+ /**
+ * constructor
+ */
+ CCdlTkDataTypeTranslation();
+ /**
+ * constructor
+ * @param aType the type that this translation matches
+ */
+ CCdlTkDataTypeTranslation(const std::string& aType);
+ /**
+ * constructor
+ * @param aType the type that this translation matches
+ * @param aDefn the definition syntax for instances of this type.
+ * @param aPtrRef the pointer reference syntax for instances of this type.
+ * @param aSource the source of this translation.
+ */
+ CCdlTkDataTypeTranslation(const std::string& aType, const std::string& aDefn, const std::string& aPtrRef, TTranslationSource aSource);
+
+ /**
+ * Get the type match string
+ * @return the type match string
+ */
+ std::string Type() const;
+ /**
+ * Set the type match string
+ * @param aType the type match string
+ */
+ void SetType(const std::string& aType);
+ /**
+ * Get the definition syntax string
+ * @return the definition syntax string
+ */
+ std::string Definition() const;
+ /**
+ * Set the definition syntax string
+ * @param aDefn the definition syntax string
+ */
+ void SetDefinition(const std::string& aDefn);
+ /**
+ * Get the pointer reference syntax
+ * @return the pointer reference syntax
+ */
+ std::string PointerReference() const;
+ /**
+ * Set the pointer reference syntax
+ * @param aPtrRef the pointer reference syntax
+ */
+ void SetPointerReference(const std::string& aPtrRef);
+ /**
+ * Get the source of the translation
+ * @return the source of the translation
+ */
+ TTranslationSource Source() const;
+
+ /**
+ * Attempts to match a type string against the type string in this translation.
+ * Where this translation doesn't use "aType" in its type string, this is
+ * a simple comparison between they type strings.
+ * Where this translation does use "aType" in its type string, that will match
+ * any text in aType, but the rest of the type strings must match exactly.
+ * The part of aType that matches the string "aType" will be returned in
+ * aTypeVar.
+ * For example, consider when this translation's type is "vector<aType>".
+ * It will match a type "vector<int>" and "int" will be placed into aTypeVar.
+ * However it will not match "list<int>", because "list<>" does not match "vector<>".
+ * @param aType the type string to match.
+ * @param aTypeVar the text in aType that matched the type variable "aType".
+ * @return true if the match succeded.
+ */
+ bool Match(const std::string& aType, std::string& aTypeVar) const;
+
+ /**
+ * Compare two type translations.
+ * @param aOther a translation to compare
+ * @return true if type, definition syntax, pointer reference syntax and
+ * source are all the same.
+ */
+ bool operator==(const CCdlTkDataTypeTranslation& aOther) const;
+
+private:
+ std::string iType;
+ std::string iDefn;
+ std::string iPtrRef;
+ TTranslationSource iSource;
+ // member data used in Match() calculation
+ std::string iTextBeforeTypeVar;
+ std::string iTextAfterTypeVar;
+ int iTypeVarPos;
+ int iSizeAfterTypeVar;
+ int iTypeSize;
+ int iTypeSizeWithoutTypeVar;
+ };
+
+
+/**
+* A collection of data type translations
+*/
+class CCdlTkDataTypeTranslations : public std::vector<CCdlTkDataTypeTranslation>
+ {
+public:
+ /**
+ * constructor
+ * Adds all the inbuilt translations.
+ */
+ CCdlTkDataTypeTranslations();
+ /**
+ * Merges adds another collection of translations to the end of this one.
+ * Inbuilt translations are ignored, as they will already be in this collection.
+ * @param aOther another collection of translations.
+ */
+ void MergeExtensionTranslations(const CCdlTkDataTypeTranslations& aOther);
+ /**
+ * Finds the last translation in the collection that matches the type.
+ * Note, translations are searched from last to first, so that more recently
+ * added translations can overrideolder ones.
+ * @param aType the type string to match.
+ * @param aTypeVar the text in aType that matched the type variable "aType".
+ * @return a pointer to the translation for which the match succeded, or
+ * NULL if no match succeded.
+ */
+ const CCdlTkDataTypeTranslation* Find(const std::string& aType, std::string& aTypeVar) const;
+ };
+
+
+/**
+* The base class for an individual API in a CDL interface
+*/
+class CCdlTkApi
+ {
+public:
+ /**
+ * constructor
+ * @param aInterface the interface that this API belongs to
+ */
+ CCdlTkApi(CCdlTkInterface& aInterface);
+ /**
+ * destructor
+ */
+ virtual ~CCdlTkApi();
+
+ /**
+ * Create a new copy of this API
+ * @param aInterface the interface to which the new copy will belong
+ * @return a new copy of this API
+ */
+ virtual CCdlTkApi* Clone(CCdlTkInterface& aInterface) const = 0;
+
+ /**
+ * Get the return type for this API
+ * @return the return type
+ */
+ const std::string& ReturnType() const;
+ /**
+ * Set the return type for this API
+ * @param aType the return type
+ */
+ void SetReturnType(const std::string& aType);
+ /**
+ * Does this API return void?
+ * @return true if this API returns void.
+ */
+ bool IsVoidReturn() const;
+
+ /**
+ * Get the name of the API
+ * @return the name of the API
+ */
+ const std::string& Name() const;
+ /**
+ * Set the name of the API
+ * @param aName the name of the API
+ */
+ void SetName(const std::string& aName);
+
+ /**
+ * Get the line number of the source file where the API appeared
+ * @return the line number of the source file where the API appeared
+ */
+ int SourceFileLineNum() const;
+ /**
+ * Set the line number of the source file where the API appeared
+ * @param aLineNum the line number of the source file where the API appeared
+ */
+ void SetSourceFileLineNum(int aLineNum);
+
+ /**
+ * Get the comment text for the API
+ * @return the comment text for the API
+ */
+ const std::string& Comment() const;
+ /**
+ * Set the comment text for the API
+ * @param aComment the comment text for the API
+ */
+ void SetComment(const std::string& aComment);
+
+ /**
+ * Get the interface to which this API belongs
+ * @return the interface to which this API belongs
+ */
+ const CCdlTkInterface& Interface() const;
+ /**
+ * Get the interface to which this API belongs
+ * @return the interface to which this API belongs
+ */
+ CCdlTkInterface& Interface();
+
+ /**
+ * Return whether this API is a function API
+ * @return true if it is a function API, false if it is a data API
+ */
+ virtual bool IsFunc() const = 0;
+ /**
+ * Downcast this object to a function API
+ * @return this object as a function API
+ */
+ const CCdlTkFunctionApi& AsFunc() const;
+ /**
+ * Downcast this object to a data API
+ * @return this object as a data API
+ */
+ const CCdlTkDataApi& AsData() const;
+
+ /**
+ * Get the type of a pointer to this API
+ * @return the type of a pointer to this API
+ */
+ virtual std::string PointerType() const = 0;
+ /**
+ * Get the type and name list for the paramters to this API, will be
+ * empty for data APIs.
+ * @return the type and name list for the paramters to this API
+ */
+ virtual std::string ParamsTypeAndNameList() const = 0;
+
+ /**
+ * Test for inequality
+ * @param aOther an API to compare
+ * @return true if not equal
+ */
+ bool operator!=(const CCdlTkApi& aOther) const;
+ /**
+ * Test for equality
+ * @param aOther an API to compare
+ * @return true if equal
+ */
+ virtual bool operator==(const CCdlTkApi& aOther) const;
+ /**
+ * Assign the contents of another API to this one
+ * @param a
+ * @return
+ */
+ void operator=(const CCdlTkApi& aOther);
+
+private:
+ std::string iReturnType;
+ std::string iName;
+ int iSourceFileLineNum;
+ CCdlTkInterface& iInterface;
+ std::string iComment;
+ };
+
+
+/**
+* An individual data API belonging to a CDL interface
+*/
+class CCdlTkDataApi : public CCdlTkApi
+ {
+public:
+ /**
+ * constructor
+ * @param aInterface the interface to which this API belongs
+ */
+ CCdlTkDataApi(CCdlTkInterface& aInterface);
+ /**
+ * constructor
+ * @param aInterface the interface to which this API belongs
+ * @param aCopy an API to copy
+ */
+ CCdlTkDataApi(CCdlTkInterface& aInterface, const CCdlTkDataApi& aCopy);
+
+ // from CCdlTkApi
+ CCdlTkApi* Clone(CCdlTkInterface& aInterface) const;
+ bool IsFunc() const;
+ std::string PointerType() const;
+ std::string ParamsTypeAndNameList() const;
+ };
+
+
+/**
+* An individual function API belonging to a CDL interface
+*/
+class CCdlTkFunctionApi : public CCdlTkApi
+ {
+public:
+ /**
+ * constructor
+ * @param aInterface the interface to which this API belongs
+ */
+ CCdlTkFunctionApi(CCdlTkInterface& aInterface);
+ /**
+ * constructor
+ * @param aInterface the interface to which this API belongs
+ * @param aCopy an API to copy
+ */
+ CCdlTkFunctionApi(CCdlTkInterface& aInterface, const CCdlTkFunctionApi& aCopy);
+
+ /**
+ * Get the parameters list for this function
+ * @return the parameters list for this function
+ */
+ CCdlTkApiParams& Params();
+ /**
+ * Get the parameters list for this function
+ * @return the parameters list for this function
+ */
+ const CCdlTkApiParams& Params() const;
+ /**
+ * Get the list of parameter names as a comma separated string
+ * @return the list of parameter names as a comma separated string
+ */
+ std::string ParamNameList() const;
+ /**
+ * Get the list of parameter types as a comma separated string
+ * @return the list of parameter types as a comma separated string
+ */
+ std::string ParamTypeList() const;
+ /**
+ * Get a type name for this API.
+ * @return a type name for this API.
+ */
+ std::string ApiNameAsTypeName() const;
+
+ // from CCdlTkApi
+ CCdlTkApi* Clone(CCdlTkInterface& aInterface) const;
+ bool IsFunc() const;
+ std::string PointerType() const;
+ std::string ParamsTypeAndNameList() const;
+
+ bool operator==(const CCdlTkApi& aOther) const;
+
+private:
+ CCdlTkApiParams iParams;
+ };
+
+
+/**
+* A set of APIs belonging to a CDL interface
+*/
+class CCdlTkApiList : public std::vector<CCdlTkApi*>
+ {
+public:
+ /**
+ * constructor
+ */
+ CCdlTkApiList();
+ /**
+ * destructor
+ */
+ ~CCdlTkApiList();
+ /**
+ * Appends API from a CDL interface extension to this API to form a monolithic API
+ * @param aOther The API to add
+ */
+ void MergeExtendedApi(CCdlTkInterface& aInterface, const CCdlTkApiList& aOther);
+ /**
+ * Copies APIs from another API list to this one. Existing APIs are removed first.
+ * @param aOther The API list to copy
+ * @param aInterface The CDL interface to which the new APIs will belong
+ */
+ void Copy(const CCdlTkApiList& aOther, CCdlTkInterface& aInterface);
+
+ /**
+ * Finds an API by name
+ * @param aName the name of the API to find
+ * @return a pointer to the API with that name, or NULL if not found
+ */
+ CCdlTkApi* Find(const std::string& aName) const;
+ /**
+ * Compare two API lists
+ * @param aOther the API list to compare
+ * @return true if the API lists are the same, ie the same content in the same order
+ */
+ bool operator==(const CCdlTkApiList& aOther) const;
+ /**
+ * Is this API list a subset of another
+ * @param aOther the candiate superset
+ * @return true if this API list does not contain any APIs that do not appear in the other APL list
+ */
+ bool IsSubsetOf(const CCdlTkApiList& aOther) const;
+
+private:
+ CCdlTkApiList(const CCdlTkApiList& aCopy);
+ void operator=(const CCdlTkApiList& aCopy);
+ void DeleteApis();
+ };
+
+
+/**
+* The C++ section of a CDL file
+*/
+class CCdlTkCpp : public std::vector<std::string>
+ {
+public:
+ /**
+ * constructor
+ */
+ CCdlTkCpp();
+ /**
+ * Adds the contents of another C++ section to the end of this one.
+ * @param aOther the other C++ section
+ */
+ void MergeExtensionCpp(const CCdlTkCpp& aOther);
+ };
+
+
+/**
+* a CDL interface
+*/
+class CCdlTkInterface
+ {
+public:
+ /**
+ * constructor
+ */
+ CCdlTkInterface();
+ /**
+ * copy constructor
+ * @param aCopy the CDL interface to copy
+ */
+ CCdlTkInterface(const CCdlTkInterface& aCopy);
+ /**
+ * assignment operator
+ * @param aCopy the CDL interface to copy
+ */
+ void operator=(const CCdlTkInterface& aCopy);
+ /**
+ * destructor
+ */
+ ~CCdlTkInterface();
+
+ /**
+ * Colapse any extended interface into this one to form a monolithic interface
+ */
+ void MergeExtensions();
+
+ /**
+ * Get the CDL interface which this interface extends
+ * @return the CDL interface which this interface extends, or null if this is the base
+ */
+ CCdlTkInterface* Base() const;
+ /**
+ * Set the CDL interface which this interface extends
+ * @param aBase the CDL interface which this interface extends
+ */
+ void SetBase(CCdlTkInterface* aBase); // does not take ownership
+ /**
+ * Get the ultimate base CDL interface which this interface extends. That is, the base
+ * interface which itself has no base.
+ * @return the ultimate base CDL interface which this interface extends, which may be this object itself
+ */
+ CCdlTkInterface* UltimateBase();
+ /**
+ * Get the ultimate base CDL interface which this interface extends. That is, the base
+ * interface which itself has no base.
+ * @return the ultimate base CDL interface which this interface extends, which may be this object itself
+ */
+ const CCdlTkInterface* UltimateBase() const;
+
+ /**
+ * Gets the immediate extension for this interface.
+ * @return the immediate extension for this interface, or null if it's not extended.
+ */
+ CCdlTkInterface* Extension() const;
+ /**
+ * Sets the immediate extension for this interface. This function takes ownership of the extension.
+ * @param aExtension the CDL interface to be the extension for this interface.
+ */
+ void SetExtension(CCdlTkInterface* aExtension); // takes ownership
+ /**
+ * Get the tip extension for this interface. Extensions to an interface form a linked
+ * list. This function traverses to the end of the extension list and returns it.
+ * @return the latest extension for this interface, which may be this interface itself if it's not extended
+ */
+ CCdlTkInterface* UltimateExtension();
+ /**
+ * Get the tip extension for this interface. Extensions to an interface form a linked
+ * list. This function traverses to the end of the extension list and returns it.
+ * @return the latest extension for this interface, which may be this interface itself if it's not extended
+ */
+ const CCdlTkInterface* UltimateExtension() const;
+
+ /**
+ * Get the filename for the CDL file for this CDL interface.
+ * @return the filename for this interface's CDL file.
+ */
+ std::string FileName() const;
+ /**
+ * Set the filename for the CDL file for this CDL interface
+ * @param aFileName The file name for this interface's CDL file
+ */
+ void SetFileName(const std::string& aFileName);
+
+ /**
+ * Get the additional comment for this CDL interface
+ * @return the additional comment for this interface's CDL file.
+ */
+ std::string AdditionalComment() const;
+ /**
+ * Set the additional comment for this CDL interface
+ * The caller must provide sufficient annotation for the text to be treated as a
+ * comment by the compiler, ensuring that the comment is terminated correctly
+ * @param aAdditionalComment The additional commentfor this interface's CDL file
+ */
+ void SetAdditionalComment(const std::string& aAdditionalComment);
+
+ /**
+ * Get the header for this interface
+ * @return the header for this interface
+ */
+ CCdlTkInterfaceHeader& Header();
+ /**
+ * Get the header for this interface
+ * @return the header for this interface
+ */
+ const CCdlTkInterfaceHeader& Header() const;
+ /**
+ * Get the C++ section for this CDL interface
+ * @return the C++ section for this CDL interface
+ */
+ CCdlTkCpp& Cpp();
+ /**
+ * Get the C++ section for this CDL interface
+ * @return the C++ section for this CDL interface
+ */
+ const CCdlTkCpp& Cpp() const;
+ /**
+ * Get the API list for this CDL interface
+ * @return the API list for this CDL interface
+ */
+ CCdlTkApiList& ApiList();
+ /**
+ * Get the API list for this CDL interface
+ * @return the API list for this CDL interface
+ */
+ const CCdlTkApiList& ApiList() const;
+ /**
+ * Get the data type translations for this CDL interface
+ * @return the data type translations for this CDL interface
+ */
+ CCdlTkDataTypeTranslations& DataTypeTranslations();
+ /**
+ * Get the data type translations for this CDL interface
+ * @return the data type translations for this CDL interface
+ */
+ const CCdlTkDataTypeTranslations& DataTypeTranslations() const;
+
+ /**
+ * Get the C++ namespace name for this CDL interface. This is generated from the CDL interface name.
+ * @return the C++ namespace name for this CDL interface.
+ */
+ std::string NamespaceName() const;
+
+ /**
+ * Compare this interface with another
+ * @param aOther The interface to compare
+ * @return true if the interfaces are equal
+ */
+ bool operator==(const CCdlTkInterface& aOther) const;
+
+private:
+ std::string iFileName;
+ std::string iAdditionalComment;
+ CCdlTkInterfaceHeader iHeader;
+ CCdlTkCpp iCpp;
+ CCdlTkApiList iApiList;
+ CCdlTkDataTypeTranslations iDataTypeTranslations;
+ CCdlTkInterface* iBase; // not owned
+ CCdlTkInterface* iExtension; // owned
+ };
+
+
+/**
+* A collection of CDL interfaces
+*/
+class CCdlTkInterfaceList : public std::vector<CCdlTkInterface*>
+ {
+public:
+ /**
+ * constructor
+ */
+ CCdlTkInterfaceList();
+ /**
+ * destructor - deletes the interfaces
+ */
+ ~CCdlTkInterfaceList();
+
+private:
+ CCdlTkInterfaceList(const CCdlTkInterfaceList& aCopy);
+ void operator=(const CCdlTkInterfaceList& aCopy);
+ };
+
+
+} // end of namespace CdlCompilerToolkit
+
+#endif