API_REF/Public_API: comparison epoc32/include/metadatabase.h

equal deleted inserted replaced

-:e1b950c65cb4
+:837f303aceeb
 // Copyright (c) 2004-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 "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
+// under the terms of "Eclipse Public License v1.0"
 // which accompanies this distribution, and is available
-// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
 //
 // Initial Contributors:
 // Nokia Corporation - initial contribution.
 //
 // Contributors:
 // Description:
 // Meta-database declarations for use in storing comms data
 //
 //
 /**
 @file
-@publishedPartner
+@publishedAll
 @released
 */
 #if (!defined METADATABASE_H)
 #define       METADATABASE_H
 // NetMeta headers
 #include <comms-infras/metadata.h>
 #include <comms-infras/metatype.h>
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <metadatabase_partner.h>
+#endif
 // CommsDat headers
 #include <commsdat.h>
 Attribute flags for an element in the Meta Database
 Attributes describe access rights to the data in the database
 @publishedAll
 @released
 */
 typedef TUint32         TMDBAttributeFlags;
 /**
 The identifier for any entry in the MetaDatabase.
 It can specify
 	<TableId><ColumnId><RecordId>
 @publishedAll
 @released
 */
 typedef TUint32         TMDBElementId;
+//
+// COMMSDAT RECORD BASE CLASS
+// Contains fields common to all records
+//
+	// Element Type Ids
+/**
+Field will contain a user-defined numeric tag for a record.
+Useful for user searches and cheaper to search on a numeric tag than a string name.
+Can be null.
+This tag is not automatically connected with the record id itself,
+which is contained within the ElementId for the record and not in any field.
+@publishedAll
+@released
+*/
+	const TMDBElementId KCDTIdRecordTag			 = 0x00010000;
+/**
+Field will contain a user-defined string tag for a record.
+This is used to uniquely identify business level information within a record.
+This field is useful for user searches, however it should be noted that it would be more efficient to use the KCDTIdRecordTag field instead
+as it is quicker and cheaper to search for a number than for a string.
+@publishedAll
+@released
+*/
+const TMDBElementId KCDTIdRecordName		 = 0x00020000;
+	// Element Type Names
+	#define	KCDTypeNameRecordTag				_S("Id")
+	#define	KCDTypeNameRecordName		        _S("Name")
 class CMDBSession : public CBase
-/*
+/**
 A session with the underlying storage server
 @publishedAll
 @released
 */
 {
 @leave  System-wide error codes if there is an unexpected error
 @pre    None
 @post   on success a session has been created and initialised
-@publishedAll
 	*/
 	IMPORT_C static CMDBSession* NewL(TVersion aRequiredVersion);
 	/**
 	As NewL and adds Session to the CleanupStack
-	@publishedAll
 	*/
 	IMPORT_C static CMDBSession* NewLC(TVersion aRequiredVersion);
 	/**
 	Virtual Destructor
-	@publishedAll
 	*/
 	IMPORT_C ~CMDBSession();
 	/**
 	Close session with storage server.
 	@publishedAll
 	@deprecated v9.1 Destructor is all that is required
 	*/
 	IMPORT_C void Close();
 	/**
-	Lookup latest data format version
+	Returns the KCDCurrentVersion constant which maps to the KCDVersion1_1
+	constant for backward compatibility reason. Please avoid using this method
+	when creating a CommsDat session object and use explicit schema version
+	instead.
 	@pre   None
 @post  None
 	@publishedAll
+	@deprecated
 	*/
 	IMPORT_C static TVersion LatestVersion();
 	/**
 	Lookup data format version currently in use by client
-	@publishedAll
 	*/
 	IMPORT_C TVersion VersionInUse();
 	/**
 @leave  Will leave with a system-wide error code if an error occurs during commit
 	@pre    None
 @post   on success the session has exclusive write access to the database
-	@publishedAll
 	*/
 	IMPORT_C void OpenTransactionL();
 	/**
 	@pre    None
 	@post   On success the database is updated with data added, modified or deleted during the transaction
 @post   On failure, any open data containers may not be in sync with the database and should be discarded or reloaded
-	@publishedAll
 	*/
 	IMPORT_C void CommitTransactionL();
 	/**
 	Cancel Transaction with database and rollback all associated changes
-Will not make any changes to the client's containers
 @leave	Will fail with KErrNotFound if not in transaction
 @pre    None - though for correct usage, ensure a transaction is already open
 	@post   Any open data containers may not be in sync with the database and should be discarded or reloaded
-	@publishedAll
 	*/
 	IMPORT_C void RollbackTransactionL();
 /**
 	Query if this session is in a transaction with the database
 	Return code will indicate
 		Not in transaction,
 		Already in transaction for this session,
 		Write-lock not available.  Another session has it.
 @pre None
-	@publishedAll
 	*/
 	IMPORT_C TInt IsInTransaction();
 /**
 @params aAttributeFlags indicates the requested access level to stored data.
 Attributes set by this call will be ignored as restrictions in all database interactions,
 	        providing the client has enough platform security capabilities to back up the request
 @pre None
-	@publishedAll
 	*/
 	IMPORT_C void SetAttributeMask(TMDBAttributeFlags aAttributeFlags);
 	/**
 @return EFalse if the flag is not set in the session mask
 This means that the attribute is obeyed in all database interactions for this session
 @pre None
-	@publishedAll
 	*/
 	IMPORT_C TBool IsSetAttributeMask(TMDBAttributeFlags aAttributeFlags);
 /**
 attribute mask and will be obeyed as restrictions in all database interactions,
 providing the client has enough platform security capabilities to back up the request
 @pre None
-	@publishedAll
 	*/
 	IMPORT_C void ClearAttributeMask(TMDBAttributeFlags aAttributeFlags);
 @return KErrNone on success or a system-wide error code
 @pre  None
-	@publishedAll
 	*/
 	IMPORT_C TInt CancelAllNotifications();
 /**
 @return KErrNone on success.  Otherwise a system-wide error code
 @pre None
-@internalComponent
 	*/
 	IMPORT_C TInt PublishProperties();
 private:
 private:
 	CMDBSessionImpl* iMDBSessionImpl;
 	friend class MMetaDatabase;
+	friend class CommsDatSchema;
 };
 class MMetaDatabase : public Meta::MMetaData
-/*
+/**
 Interface for interaction with a database server
 Inherited by each data set type that can be stored
 @publishedAll
+@released
 */
 {
 public:
 	IMPORT_C virtual ~MMetaDatabase();
 Ensure the ElementId for this container fully identifies the target data in the database
 <Table><Column><Record>
 Ensure that the session object has been initialised with the correct dataset version
 Ensure that the session object has appropriate access control attributes to manage the target data in the database
-	@publishedAll
 	*/
 	IMPORT_C void LoadL(CMDBSession& aSession);
 	/**
 			EFalse if no data found that the client is authorised to view
 May also leave with KErrGeneral or other general error codes.
 On failure, the container should be discarded or repopulated before it is used again
+		Please note - a case insensitive search is done in the case of text based fields
 @pre
 Populate this container where necessary with valid data to match during the find operation
 Ensure the ElementId for this container correcty identifies the target table in the database
 <Table><Column>
 Ensure that the session object has been initialised with the correct dataset version
 Ensure that the session object has appropriate access control attributes to manage the target data in the database
-	@publishedAll
 	 */
 	IMPORT_C TBool FindL(CMDBSession& aSession);
 	/**
 Ensure the ElementId for this container fully identifies the target data in the database
 <Table><Column><Record>
 Ensure that the session object has been initialised with the correct dataset version
 Ensure that the session object has appropriate access control attributes to manage the target data in the database
-	@publishedAll
 	*/
 	IMPORT_C void RefreshL(CMDBSession& aSession);
 	/**
 	        KErrAlreadyExists
 May also leave with other general error codes if there are unexpected
 problems (e.g. KErrNoMemory when out of memory)
+		Store will be atomic - all fields stored after success.  No fields stored if the function leaves
 If StoreL fails or the later commit is not successful, The data in the container will not
 match the data in the database.
 On failure, the container should be discarded or repopulated before it is used again
 Ensure the ElementId for this container fully identifies the target location in the database
 <Table><Column><Record>
 Ensure that the session object has been initialised with the correct dataset version
 Ensure that the session object has appropriate access control attributes to manage the target data in the database
-	@publishedAll
 	*/
 	IMPORT_C void StoreL(CMDBSession& aSession);
 	/**
 	Modify all fields in the database that have been changed in this container by the caller
-Only modifies existing data in the database, won't create new fields  VCT - is this true?? don't think so
 Modification is atomic for this container.  It uses an internal transaction even if
 no overall transaction set by client.
 All changed fields in the element are modified in database on success.
 No fields are altered in the database if the function leaves
 Client can request to ignore access control flags by setting the attribute mask
 CMDBSession::SetAttributeMask()
 		However, only fields that the client has capabilities to alter will be modified.in the database
 		A request to modify data in an unauthorised area will cause the function to leave.with
 KErrPermissionDenied
-If field does not exist, the function will leave with
-KErrNotFound [VCT - surely not]
 		May also leave with other general error codes if there are unexpected
 problems (e.g. KErrNoMemory when out of memory)
 On failure, the container should be discarded or repopulated before it is used again
 Populate this container with valid data for storage
 Ensure the ElementId for this container fully identifies the target data in the database
 <Table><Column><Record>
 Ensure that the session object has been initialised with the correct dataset version
 Ensure that the session object has appropriate access control attributes to manage the target data in the database
-	@publishedAll
 	*/
 	IMPORT_C void ModifyL(CMDBSession& aSession);
 	/**
 @pre    Ensure the ElementId for this container fully identifies the target data in the database
 <Table><Column><Record>
 Ensure that the session object has appropriate access control attributes to manage the target data in the database
 Ensure the ElementId for this container correcty identifies the target data in the database
-	@publishedAll
 	*/
 	IMPORT_C void DeleteL(CMDBSession& aSession);
 	/**
 @params aSession        a valid session object
 @params aRequestStatus  the requestStatus object that will be completed on notification
 @pre    None
 @post   A notification request will be outstanding
-	@publishedAll
 	*/
 	IMPORT_C TInt RequestNotification(CMDBSession&          aSession,
 									  TRequestStatus&        aRequestStatus);
 	/**
 @pres
 There is an outstanding notification request
-	@publishedAll
 	*/
 	IMPORT_C TInt CancelNotification(CMDBSession&       aSession,
 									 TRequestStatus&     aRequestStatus);
 protected:
-	explicit MMetaDatabase();
+	IMPORT_C explicit MMetaDatabase();
 private:
 /*
 @internalComponent
 */
-void DoLoadL(CMDBSessionImpl* aSession, CMDBElement* aElement, CMDBElement* aMapper, TInt& aErr, TMDBElementId aRecordId, TMDBElementId aAttributes);
+void DoLoadL(CMDBSessionImpl* aSession, CMDBElement* aElement, CMDBElement* aMapper, TInt& aErr, TMDBElementId aRecordId, TMDBElementId aAttributes, TBool isTheLoadForMapper = EFalse);
 /*
 @internalComponent
 */
-void DoLoadL(CMDBSessionImpl* aSession, CMDBElement* aElement, CMDBElement* aMapper, TInt& aErr, TMDBElementId aRecordId, TMDBElementId aAttributes, RArray<TUint32>& aMatches);
+void DoLoadL(CMDBSessionImpl* aSession, CMDBElement* aElement, CMDBElement* aMapper, TInt& aErr, TMDBElementId aRecordId, TMDBElementId aAttributes, RArray<TUint32>& aMatches, TBool isTheLoadForMapper = EFalse);
 /*
 @internalComponent
 */
 void DoFindL(CMDBSessionImpl* aSession, CMDBElement* aElement, CMDBElement* aMapper, TInt& aErr, RArray<TUint32>& candidates, RArray<TUint32>& matches);
 class CMDBElement : public CBase, public MMetaDatabase
-/*
+/**
 Every item stored in the database is represented as a CMDBElement
 This class contains the id and attributes of every item in the database
 and for individual fields it also contains the value.
 @publishedAll
 public:
 	/**
 	Default Constructor
-	@publishedAll
 	*/
 	IMPORT_C CMDBElement();
 	/**
 	Constructor
-	@publishedAll
 	*/
 	IMPORT_C CMDBElement(TMDBElementId aElementId);
 	/**
 	Destructor
-	@publishedAll
 	*/
 	IMPORT_C ~CMDBElement();
 	// Accessors
 	This identifies the meaning of the field in the database schema
 	It also identifies the type of the data stored in this element
 	and the instance of the type
-	@publishedAll
 	*/
 	IMPORT_C TMDBElementId ElementId() const;
 	/**
 	It also identifies the type of the data contained in this element
 For an element that is a Table or a Record, the ColumnId field will be set to
 KCDMaxColumnId
-	@publishedAll
 	*/
 	IMPORT_C TMDBElementId  TypeId() const;
 	/**
 	<TableId><x><x>
 	It identifies the table in the database that holds the data contained in this element
-	@publishedAll
 	*/
 	IMPORT_C TMDBElementId  TableId() const;
 /**
 	The RecordId is part of the ElementId <x><x><RecordId>
 	It identifies a particular instance of this type of Element in the database
-	@publishedAll
 	*/
 	IMPORT_C TInt RecordId() const;
 	/**
 	Returns the Attributes of an object of this type.
 	Attributes express database access rights for the data of this element
-	@publishedAll
 	*/
 	IMPORT_C TMDBAttributeFlags Attributes() const;
 // SETTER FUNCTIONS
 	/**
 	Sets the ElementId
-	@publishedAll
 	*/
 	IMPORT_C void SetElementId(TMDBElementId aElementId);
 	/**
 	Sets the TypeId
-	@publishedAll
 	*/
 	IMPORT_C void SetTypeId(TMDBElementId aElementId);
 	/**
 	Sets the RecordId
-	@publishedAll
 	*/
 	IMPORT_C void SetRecordId(TInt aRecordId);
 	/**
 	Sets one or more attributes
-	@publishedAll
 	*/
 	IMPORT_C void SetAttributes(TMDBAttributeFlags aAttributes);
 	/**
 	Clears one or more attributes
-	@publishedAll
 	*/
 	IMPORT_C void ClearAttributes(TMDBAttributeFlags aAttributes);
 	/**
 	Queries the attributes
 	Returns ETrue if all queried attributes are set
 	Returns EFalse if any queried attribute is not set.
-	@publishedAll
 	*/
 	IMPORT_C TBool IsSetAttribute(TMDBAttributeFlags aAttributes) const;
 	/**
 	Queries the state of the field value
 	Returns ETrue if the value of the element is not set
 	Returns EFalse if the element contains a value
-	@publishedAll
 	*/
 	IMPORT_C TBool IsNull() const;
 /**
 	Queries the type of the field value
 	Returns the enumeration TCDFieldValueTypes that represents the value that can be stored in this element
-	@publishedAll
 	*/
 	virtual TCDFieldValueTypes Type()=0;
 	/**
 	@internalComponent
 	*/
 TMDBElementId* Data(){return &iElementId;}
-	/**
-	@internalComponent
-	*/
-const TMDBElementId* CData(){return &iElementId;}
 protected:
 	TMDBElementId     iElementId;
 };
-///////////////////////////////////////////////////////////////////////////////////////
+//
 //  COMMSDAT CONTAINERS
 //
 /**
 Commsdat Container classes qualifying numeric values
-@internalComponent
+@publishedAll
 */
 class CMDBNumFieldBase : public CMDBElement
 {
 public:
 	/**
 	/**
 	Constructor setting Field's ElementId
 	*/
 	IMPORT_C CMDBNumFieldBase(TMDBElementId aFieldId);
 /**
 	Assignment operator for field value
 	*/
 	IMPORT_C CMDBNumFieldBase& operator=(const TInt aValue);
 IMPORT_C void SetMaxLengthL(TInt aLength);
 TMDBElementId GetL();
 EXP_DATA_VTABLE
+private:
 	virtual TCDFieldValueTypes Type()
 		{
 		return EInt;
 		}
 /**
 A thin template that guards typed data access in a single CMDBElement
 This class describes a single numeric field in the database
 @publishedAll
+@released
 */
 {
 public:
 	/**
 	Default Constructor
-	@publishedAll
 	*/
 	inline CMDBField()
 		{
 		}
 	/**
 	Constructor setting Field's ElementId
-	@publishedAll
 	*/
 	inline CMDBField(TMDBElementId aFieldId)
 		: CMDBNumFieldBase(aFieldId)
 		{
 		}
 	/**
 	Assignment operator for field value
-	@publishedAll
 	*/
 	inline CMDBField<TYPE>& operator=(const TYPE& aValue)
 	{
 	return (CMDBField<TYPE>&)CMDBNumFieldBase::operator=((TInt&)aValue);
 	}
 	    return (CMDBField<TYPE>&)CMDBNumFieldBase::operator=(aValue);
 	}
 	/**
 	Conversion operator for field value
-	@publishedAll
 	*/
 	inline operator TYPE&()
 	{
 		return (TYPE&)iValue;
 	}
 	/**
 	Conversion operator for field value
-	@publishedAll
 	*/
 	inline CMDBField<TYPE>& GetL()
 	{
 		if(IsNull() && !(ElementId() & KCDChangedFlag))
 			{
 		return (TYPE&)iValue;
 	}
 	/**
 	Function for setting a value
-	@publishedAll
 	*/
 	inline void SetL(const TYPE& aValue)
 	{
 	CMDBNumFieldBase::operator=(aValue);
 	}
 };
-//////////////////
+//
 /**
 Base Container class qualifying a text field
-@internalComponent
+@publishedAll
 */
 class CMDBTextFieldBase : public CMDBElement
 {
 public:
 	/**
 IMPORT_C void SetMaxLengthL(TInt aLength);
 EXP_DATA_VTABLE
+private:
 	virtual TCDFieldValueTypes Type()
 		{
 		return EText;
 		}
 /**
 A thin template that guards typed data access in a single CMDBElement
 This class describes a single field in the database
 @publishedAll
+@released
 */
 {
 public:
 	/**
 	Default Constructor
-	@publishedAll
 	*/
 	inline CMDBField()
 		{
 		}
 	/**
 	Constructor setting Field's ElementId
-	@publishedAll
 	*/
 	inline CMDBField(TMDBElementId aFieldId)
 		: CMDBTextFieldBase(aFieldId)
 		{
 		}
 return *this;
 	}
 	/**
 	Conversion operator for field value
-	@publishedAll
 	*/
 	inline operator const TDesC&()
 	{
 if (! iValue)
 return KNullDesC;
 		return *(HBufC*)iValue;
 	}
 	/**
 	Conversion operator for field value
-	@publishedAll
 	*/
 	inline TDesC& GetL()
 	{
 		if(IsNull() && !(ElementId() & KCDChangedFlag))
 			{
 		return *(HBufC*)iValue;
 	}
 	/**
 	Function for setting a value
-	@publishedAll
 	*/
 	inline void SetL(const TDesC& aValue)
 	{
 	SetMaxLengthL(aValue.Length());
 	CMDBTextFieldBase::operator=(aValue);
 };
-//////////////////
+//
 /**
 Container class for qualifying binary values
-@internalComponent
+@publishedAll
 */
 class CMDBBinFieldBase : public CMDBElement
 {
 public:
 	/**
 	To allocate space for field data.
 	*/
 	IMPORT_C void SetMaxLengthL(TInt aLength);
 EXP_DATA_VTABLE
+private:
 	virtual TCDFieldValueTypes Type()
 		{
 		return EDesC8;
 		}
 };
 /**
 A thin template that guards typed data access in a single CMDBElement
 This class describes a single field in the database
 @publishedAll
+@released
 */
 {
 public:
 	/**
 	Default Constructor
-	@publishedAll
 	*/
 	inline CMDBField()
 		{
 		}
 	/**
 	Constructor setting Field's ElementId
-	@publishedAll
 	*/
 	inline CMDBField(TMDBElementId aFieldId)
 		: CMDBBinFieldBase(aFieldId)
 		{
 		}
 	}
 	/**
 	Conversion operator for field value
-	@publishedAll
 	*/
 	inline operator const TDesC8&()
 	{
 		    if (! iValue)
 return KNullDesC8;
 		return *(HBufC8*)iValue;
 	}
 /**
 	Conversion operator for field value
-	@publishedAll
 	*/
 	inline TDesC8& GetL()
 	{
 		if(IsNull() && !(ElementId() & KCDChangedFlag))
 			{
 	return *(HBufC8*)iValue;
 	}
 	/**
 	Function for setting a value
-	@publishedAll
 	*/
 	inline void SetL(const TDesC8& aValue)
 	{
 	SetMaxLengthL(aValue.Length());
 	CMDBBinFieldBase::operator=(aValue);
 };
-///////////////////////////////////////////////////////////////////////////////////////////////
+//
 /**
 Base class for CMDBRecordLink
-@internalComponent
+@publishedAll
 */
 class CMDBRecordLinkBase : public CMDBNumFieldBase
 {
 public :
 	Conversion operator for field value
 	which gets the id of the element list
 	*/
 	IMPORT_C operator TMDBElementId();
+protected:
+	EXP_DATA_VTABLE
+private:
 TCDFieldValueTypes Type()
 		{
 		return ELink;
 		}
-protected:
-	EXP_DATA_VTABLE
 public:
 	// the record referenced by the link id stored in the value of this field.
 	CMDBElement*     iLinkedRecord;
 The value of a CMDBRecordLink field as stored in the database is the
 ElementId (<Table><Record>) of the linked record.
 The linked record itself can be viewed via the iLinkedRecord member and its accessors
-iLinkedRecord must be created explicitly by the client - either on construction,
+If a record is loaded then the iLinkedRecord must be created explicitly
-or by use of the CreateLinkL or SetLinkL functions. Often the linked record is not
+by the client - either on construction, or by use of the CreateLinkL or
-required by a caller.  So creating it automatically would just waste memory
+SetLinkL functions. Often the linked record is not required by a caller.
+So creating it automatically would just waste memory
+However in the case of an explicit load of a LinkedRecord field the ILinkedRecord
+is created.
 When instantiating iLinkedRecord directly take care to match the object's type to the Type
 ID that will be found at the linking element.  It is better to use the CreateLinkL or
 SetLinkL functions to ensure type safety
 */
 {
 public :
 	/**
 	Constructor/Destructor
-	@publishedAll
 	*/
 	inline CMDBRecordLink()
 		: CMDBRecordLinkBase() {}
 	/**
 	Constructor
-	@publishedAll
 	*/
 	inline CMDBRecordLink(TMDBElementId aLinkingFieldId)
 		: CMDBRecordLinkBase(aLinkingFieldId) {}
 	/**
 	Constructor
-	@publishedAll
 	*/
 	inline CMDBRecordLink(TMDBElementId aLinkingFieldId, RECORD_TYPE* aLinkedRecord)
 		: CMDBRecordLinkBase(aLinkingFieldId, (CMDBElement*)aLinkedRecord) {}
-	/**
-	@publishedAll
-	*/
 	inline CMDBRecordLink& operator=(const TMDBElementId aValue)
 	{
 		return (CMDBRecordLink&)CMDBRecordLinkBase::operator=(aValue);
 	}
 // SETTERS
 	/**
 	Set the field value (this will be validated on StoreL)
-	@publishedAll
 	*/
 	inline void SetL(const TMDBElementId aValue)
 		{
 		CMDBRecordLinkBase::operator=(aValue);
 		}
 // OPERATORS
 	/**
 	conversion operator for linked record of this type
-	@publishedAll
 	*/
 	inline operator RECORD_TYPE*()
 	{
 		return static_cast<RECORD_TYPE*>(iLinkedRecord);
 	}
 };
 enum TFieldTypeAttributes
 /**
 To express type information for all MetaDatabase fields
-@publishedAll
+*/
-@released
+	{
-*/
+	ENoAttrs,	//< No attributes associated with this field.
-	{
+	ENotNull, 	//< Ensures the field contains a value and must not be null.
-	ENoAttrs,	///< No attributes associated with this field.
-	ENotNull, 	///< Ensures the field contains a value and must not be null.
 	};
 typedef struct
 /**
 To express type information for all MetaDatabase fields
-@publishedAll
+*/
-@released
+	{
-*/
+		const TMDBElementId	        iTypeId;		//< Identifier for the field.
-	{
+		const TInt                  iValType;		//< The field type value e.g.EText, EMedText.
-		const TMDBElementId	        iTypeId;		///< Identifier for the field.
+	    const TFieldTypeAttributes	iTypeAttr;		//< The field attribute, either ENoAttrs or ENotNull.
-		const TInt                  iValType;		///< The field type value e.g.EText, EMedText.
+const TText * const         iTypeName;		//< Name of the field type.
-	    const TFieldTypeAttributes	iTypeAttr;		///< The field attribute, either ENoAttrs or ENotNull.
-const TText * const         iTypeName;		///< Name of the field type.
 	} SRecordTypeInfo;
 #define MDB_GENERIC_TYPE_INFO(a, b, c, d) SGenericRecordTypeInfo(a, b, c, d)
 typedef TBuf<64> TGenericTypeName;
 typedef struct SGenericRecordTypeInfoTag
 /**
 To express type information for all MetaDatabase fields
-@publishedAll
-@released
 */
 	{
 	     SGenericRecordTypeInfoTag()
 	     : iTypeId(0), iValType(0), iTypeAttr(ENoAttrs) {}
 	                                     TFieldTypeAttributes aAttrType,
 	                               const TGenericTypeName&    aTypeName)
 	     : iTypeId(aId), iValType(aVal), iTypeAttr(aAttrType), iTypeName(aTypeName) {}
-		 TMDBElementId	       iTypeId;			///< Identifier for the field type.
+		 TMDBElementId	       iTypeId;			//< Identifier for the field type.
-		 TInt                  iValType;		///< The field type value e.g.EText, EMedText.
+		 TInt                  iValType;		//< The field type value e.g.EText, EMedText.
-	     TFieldTypeAttributes  iTypeAttr;		///< The type's attribute, either ENoAttrs or ENotNull
+	     TFieldTypeAttributes  iTypeAttr;		//< The type's attribute, either ENoAttrs or ENotNull
-TGenericTypeName	   iTypeName;		///< Name of the field type.
+TGenericTypeName	   iTypeName;		//< Name of the field type.
 	} SGenericRecordTypeInfo;
 class CMDBRecordBase : public CMDBNumFieldBase
 @publishedAll
 @released
 */
 {
 public:
-		/**
-		@internalComponent
-		*/
 	IMPORT_C CMDBRecordSetBase();
-		/**
-		@internalComponent
-		*/
 	IMPORT_C CMDBRecordSetBase(TMDBElementId aElementId);
-		/**
-		@internalComponent
-		*/
 	IMPORT_C ~CMDBRecordSetBase();
 inline CMDBRecordSetBase& operator=(const TPtrC& aValue)
 {
 return (CMDBRecordSetBase&)CMDBTextFieldBase::operator=(aValue);
 /**
 Use this class to express a list of records of a particular MetaDatabase Element type
 Records can be ordered using the standard RPointerArray functions
 @publishedAll
+@released
 */
 {
 public:
 	inline CMDBRecordSet(){}
 private:
 };
 } //end namespace CommsDat
 #endif  // METADATABASE_H

branch	Symbian3
changeset 4	837f303aceeb
parent 2	2fe1408b6811