/*

* Copyright (c) 2004 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:  Commmand structs for SyncML document (DTD).

*

*/

#ifndef __SMLDTD_H__

#define __SMLDTD_H__

/*************************************************************************/

/*  Definitions                                                          */

/*************************************************************************/

#include "smldef.h"

#include "xmlelement.h"

/** 

 * PCDATA - types of synchronization data which SyncML supports

 **/

typedef enum {

  SML_PCDATA_UNDEFINED = 0,

  SML_PCDATA_STRING,                   // String type

  SML_PCDATA_OPAQUE,                   // Opaque type

  SML_PCDATA_EXTENSION,                // Extention type - specified by PcdataExtension_t

  SML_PCDATA_CDATA                     // XML CDATA type   

} SmlPcdataType_t;

/**

 * PCDATA - types of extensions for PCData elements

 */

typedef enum {

  SML_EXT_UNDEFINED = 0,

  SML_EXT_METINF, // Meta Information

  SML_EXT_DEVINF, // Device Information

  SML_EXT_DEVINFPROP, // 1.2 CHANGES: Device Info Property 

  SML_EXT_LAST    // last codepage, needed for loops!

} SmlPcdataExtension_t;

/** 

 * PCDATA - into this structure SyncML wraps the synchronization data itself

 **/ 

typedef struct sml_pcdata_s : public CXMLElement

	{

public:

	SmlPcdataType_t       contentType;   // The type of data which a PCDATA structure contains

	SmlPcdataExtension_t  extension;     // PCData Extension type

	MemSize_t             length;        // length of the data in this PCDATA structure

	VoidPtr_t             content;       // Pointer to the data itself

public:

	IMPORT_C sml_pcdata_s();

	IMPORT_C ~sml_pcdata_s();

	IMPORT_C sml_pcdata_s( const SmlPcdataType_t aType, const SmlPcdataExtension_t aExt =  SML_EXT_UNDEFINED );

	IMPORT_C void FreeContent();

	IMPORT_C void SetDataL( const TDesC8& aData );

	IMPORT_C TPtrC8 Data() const;

	IMPORT_C void TruncateL( TInt aConsumed );

	//CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	} *SmlPcdataPtr_t, SmlPcdata_t;       

/* generic list of PCData elements */

typedef struct sml_pcdata_list_s : public CBase

	{

	SmlPcdataPtr_t	data;

	struct sml_pcdata_list_s *next;

	IMPORT_C sml_pcdata_list_s();

	IMPORT_C ~sml_pcdata_list_s();

	} *SmlPcdataListPtr_t, SmlPcdataList_t;

/** 

 * Various flags which are actually declared and (EMPTY) elements in

 * SyncML. This assumes at least a 16-bit architecture for the

 * underlying OS. We need to review this if that is deemed a problem.

 **/

#define SmlArchive_f       (1<<0)	// Delete flags

#define SmlSftDel_f        (1<<1)	// Delete flags

#define SmlMoreData_f      (1<<2)	// MoreData flag

#define SmlNoResults_f     (1<<3)	// No Results flag 

#define SmlNoResp_f        (1<<4)	// No Response flag

#define SmlFinal_f         (1<<5)	// Header flag

#define SmlMetInfSharedMem_f (1<<6)	// MetInf Shared Memory Flag

#define SmlDevInfSharedMem_f (1<<7)	// DevInf Shared Memory Flag

/**

 * Chal 

 **/

typedef struct sml_chal_s : public CXMLElement

	{

public:

	SmlPcdataPtr_t           meta;

public:

	IMPORT_C sml_chal_s();

	IMPORT_C ~sml_chal_s();

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	} *SmlChalPtr_t, SmlChal_t;

/** 

 * Credentials

 **/

typedef struct sml_cred_s : public CXMLElement

	{

public:

	SmlPcdataPtr_t           meta;       // opt.

	SmlPcdataPtr_t           data; 

public:

	IMPORT_C sml_cred_s();

	IMPORT_C ~sml_cred_s();

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	} *SmlCredPtr_t, SmlCred_t;

// 1.2 CHANGES: new common use elements

typedef struct sml_item_s *SmlItemPtr_t;

typedef struct sml_field_or_record_s : public CXMLElement

	{

public:

	SmlItemPtr_t			item;

public:

	IMPORT_C sml_field_or_record_s();

	IMPORT_C ~sml_field_or_record_s();

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	}	*SmlFieldOrRecordPtr_t, SmlFieldOrRecord_t,

		*SmlFieldPtr_t, SmlField_t,

		*SmlRecordPtr_t, SmlRecord_t;

typedef struct sml_filter_s : public CXMLElement

	{

public:

	SmlPcdataPtr_t           meta;

	SmlFieldPtr_t			 field;		 // opt.

	SmlRecordPtr_t			 record;	 // opt.

	SmlPcdataPtr_t           filterType; // opt.

public:

	IMPORT_C sml_filter_s();

	IMPORT_C ~sml_filter_s();

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	}	*SmlFilterPtr_t, SmlFilter_t;

// Changes end

// 1.2 CHANGES: Source & Target divided to their own structs

/** 

 * Source location

 **/

typedef struct sml_source_s : public CXMLElement

	{

public:

	SmlPcdataPtr_t           locURI;

	SmlPcdataPtr_t           locName;    // opt.

public:

	IMPORT_C sml_source_s();

	IMPORT_C ~sml_source_s();

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	}	*SmlSourcePtr_t, SmlSource_t;

/** 

 * Target location

 **/

typedef struct sml_target_s : public CXMLElement

	{

public:

	SmlPcdataPtr_t           locURI;

	SmlPcdataPtr_t           locName;    // opt.

	SmlFilterPtr_t			 filter;	 // opt.

public:

	IMPORT_C sml_target_s();

	IMPORT_C ~sml_target_s();

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	}	*SmlTargetPtr_t, SmlTarget_t;

// Changes end

typedef struct sml_source_list_s : public CBase

	{

public:

	SmlSourcePtr_t           source;

	struct sml_source_list_s  *next;

public:

	IMPORT_C sml_source_list_s();

	IMPORT_C ~sml_source_list_s();

	} *SmlSourceListPtr_t, SmlSourceList_t;

//1.2 CHANGES: Source & Target parent

/** 

 * Source & Target parent

 **/

typedef struct sml_source_or_target_parent_s : public CXMLElement

	{

public:

	SmlPcdataPtr_t           locURI;

public:

	IMPORT_C sml_source_or_target_parent_s();

	IMPORT_C ~sml_source_or_target_parent_s();

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	}	*SmlSourceOrTargetParentPtr_t, SmlSourceOrTargetParent_t,

		*SmlSourceParentPtr_t, SmlSourceParent_t,

		*SmlTargetParentPtr_t, SmlTargetParent_t;

// Changes end

/**

 * ==============================

 * SyncML Message Header Elements

 * ==============================

 **/

/** 

 * SyncML header

 * As the header is needed for each SyncML message, it's also the parameter

 * of the startMessage call.

 **/

typedef struct sml_sync_hdr_s : public CXMLElement

	{

public:

	SmlProtoElement_t	elementType; // Internal Toolkit Field

	SmlPcdataPtr_t  version;       

	SmlPcdataPtr_t  proto;         

	SmlPcdataPtr_t  sessionID;     

	SmlPcdataPtr_t  msgID;         

	Flag_t          flags;      // NoResp

	SmlTargetPtr_t  target;

	SmlSourcePtr_t  source;

	SmlPcdataPtr_t  respURI;    // opt.

	SmlCredPtr_t    cred;       // opt.

	SmlPcdataPtr_t    meta;     // opt.

public:

	IMPORT_C sml_sync_hdr_s();

	IMPORT_C ~sml_sync_hdr_s();

	TBool NeedsCleanup() const;

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	CXMLElement::TAction EndElementL( TAny* aCallbacks, TUint8 aTag );

	} *SmlSyncHdrPtr_t, SmlSyncHdr_t;

// SyncML Body and SyncML container is not needed, as there are function calls

// (smlStartMessage(), smlEndMessage()) that let the framework know when to start and end

// the SyncML document

/**

 * =========================

 * Data description elements

 * =========================

 **/

/** 

 * Data in SyncML is encapsulated in an "item" element. 

 **/

typedef struct sml_item_s : public CXMLElement

	{

public:

	Flag_t                generatorFlags;      // internal DO NOT TOUCH!

	SmlTargetPtr_t        target;     // opt.

	SmlSourcePtr_t        source;     // opt.

// 1.2 CHANGES: SourceParent and TargetParent added

	SmlSourceParentPtr_t  sourceParent;// opt.

	SmlTargetParentPtr_t  targetParent;// opt.

// Changes end

	SmlPcdataPtr_t        meta;       // opt.

	SmlPcdataPtr_t        data;       // opt.

	Flag_t                flags;      // opt. for MoreData

public:

	IMPORT_C sml_item_s();

	IMPORT_C ~sml_item_s();

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	CXMLElement::TAction EndElementL( TAny* aCallbacks, TUint8 aTag );

	} *SmlItemPtr_t, SmlItem_t;

typedef struct sml_item_list_s : public CBase

	{

public:

	SmlItemPtr_t          item;

	struct sml_item_list_s    *next;

public:

	IMPORT_C sml_item_list_s();

	IMPORT_C ~sml_item_list_s();

	} *SmlItemListPtr_t, SmlItemList_t;

/**

 * ==============================================

 * SyncML Commands (Protocol Management Elements)

 * ==============================================

 **/

// 1.2 CHANGES: Move command added

/**

 * Generic commands:

 * Add, Copy, Replace, Delete, Move

 **/

typedef struct sml_generic_s : public CXMLElement

	{

public:

	SmlProtoElement_t	      elementType; // Internal Toolkit Field

	SmlPcdataPtr_t        cmdID;      

	Flag_t                flags;      // NoResp, Archive (Delete), SftDel (Delete)

	SmlCredPtr_t          cred;       // opt.

	SmlPcdataPtr_t        meta;       // opt.

	SmlItemListPtr_t      itemList;

public:

	IMPORT_C sml_generic_s();

	IMPORT_C ~sml_generic_s();

	TBool NeedsCleanup() const;

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	CXMLElement::TAction EndElementL( TAny* aCallbacks, TUint8 aTag );

	}	*SmlAddPtr_t, SmlAdd_t, 

		*SmlCopyPtr_t, SmlCopy_t,

		*SmlReplacePtr_t, SmlReplace_t,

		*SmlDeletePtr_t, SmlDelete_t,

		*SmlMovePtr_t, SmlMove_t,

		*SmlGenericCmdPtr_t, SmlGenericCmd_t;

// Changes end

/**

 * Alert command:

 **/

typedef struct sml_alert_s : public CXMLElement

	{

public:

	SmlProtoElement_t	      elementType; // Internal Toolkit Field

	SmlPcdataPtr_t        cmdID;      

	Flag_t                flags;      // NoResp

	SmlCredPtr_t          cred;       // opt.

	SmlPcdataPtr_t        data;       // opt.

	// FOTA

	SmlPcdataPtr_t        correlator;	// opt.

	// FOTA end	

	SmlItemListPtr_t      itemList;

public:

	IMPORT_C sml_alert_s();

	IMPORT_C ~sml_alert_s();

	TBool NeedsCleanup() const;

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	CXMLElement::TAction EndElementL( TAny* aCallbacks, TUint8 aTag );

	} *SmlAlertPtr_t, SmlAlert_t;

/**

 * Atomic/Sequence command:

 **/

typedef struct sml_atomic_s : public CXMLElement

	{

public:

	SmlProtoElement_t	      elementType; // Internal Toolkit Field

	SmlPcdataPtr_t        cmdID;     

	Flag_t                flags;      // NoResp

	SmlPcdataPtr_t        meta;       // opt.

public:

	IMPORT_C sml_atomic_s(SmlProtoElement_t aType);

	IMPORT_C ~sml_atomic_s();

	TBool NeedsCleanup() const;

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	CXMLElement::TAction EndElementL( TAny* aCallbacks, TUint8 aTag );

	}	*SmlAtomicPtr_t, SmlAtomic_t,

		*SmlSequencePtr_t, SmlSequence_t;

/**

 * Sync command:

 **/

typedef struct sml_sync_s : public CXMLElement

	{

public:

	SmlProtoElement_t	      elementType; // Internal Toolkit Field

	SmlPcdataPtr_t        cmdID;      

	Flag_t                flags;      // NoResp

	SmlCredPtr_t          cred;       // opt.

	SmlTargetPtr_t        target;     // opt.

	SmlSourcePtr_t        source;     // opt.

	SmlPcdataPtr_t        meta;       // opt.

	SmlPcdataPtr_t        noc;        // opt.

public:

	IMPORT_C sml_sync_s();

	IMPORT_C ~sml_sync_s();

	TBool NeedsCleanup() const;

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	CXMLElement::TAction EndElementL( TAny* aCallbacks, TUint8 aTag );

	} *SmlSyncPtr_t, SmlSync_t;

/**

 * Exec command:

 **/

typedef struct sml_exec_s : public CXMLElement

	{

public:

	SmlProtoElement_t	      elementType;

	SmlPcdataPtr_t        cmdID;      

	Flag_t                flags;      // NoResp

	SmlCredPtr_t          cred;       // opt.

	SmlPcdataPtr_t        meta;       // opt.

	// FOTA

	SmlPcdataPtr_t        correlator;	// opt.

	// FOTA end	

	SmlItemPtr_t          item;

public:

	IMPORT_C sml_exec_s();

	IMPORT_C ~sml_exec_s();

	TBool NeedsCleanup() const;

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	CXMLElement::TAction EndElementL( TAny* aCallbacks, TUint8 aTag );

	} *SmlExecPtr_t, SmlExec_t;

/**

 * Get and Put command:

 **/

typedef struct sml_get_put_s : public CXMLElement

	{

public:

	SmlProtoElement_t	      elementType; // Internal Toolkit Field

	SmlPcdataPtr_t        cmdID;      

	Flag_t                flags;      // NoResp

	SmlPcdataPtr_t        lang;       // opt.

	SmlCredPtr_t          cred;       // opt.

	SmlPcdataPtr_t        meta;       // opt.

	SmlItemListPtr_t         itemList;

public:

	IMPORT_C sml_get_put_s();

	IMPORT_C ~sml_get_put_s();

	TBool NeedsCleanup() const;

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	CXMLElement::TAction EndElementL( TAny* aCallbacks, TUint8 aTag );

	}	*SmlPutPtr_t, SmlPut_t,

		*SmlGetPtr_t, SmlGet_t;

/**

 * Map command:

 **/ 

typedef struct sml_map_item_s : public CXMLElement

	{

public:

	SmlTargetPtr_t           target;

	SmlSourcePtr_t           source;

	TInt 					 atomicId;

public:

	IMPORT_C sml_map_item_s();

	IMPORT_C ~sml_map_item_s();

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams()	);

	} *SmlMapItemPtr_t, SmlMapItem_t;

typedef struct sml_map_item_list_s : public CBase

	{

public:

	SmlMapItemPtr_t          	mapItem;

	struct sml_map_item_list_s  *next;

public:

	IMPORT_C sml_map_item_list_s();

	IMPORT_C ~sml_map_item_list_s();

	} *SmlMapItemListPtr_t, SmlMapItemList_t;

typedef struct sml_map_s : public CXMLElement

	{

public:

	SmlProtoElement_t	  elementType; // InternalToolkit Field

	SmlPcdataPtr_t        cmdID;   

	SmlTargetPtr_t        target;

	SmlSourcePtr_t        source;

	SmlCredPtr_t          cred;       // opt.

	SmlPcdataPtr_t        meta;       // opt.

	SmlMapItemListPtr_t   mapItemList;

public:

	IMPORT_C sml_map_s();

	IMPORT_C ~sml_map_s();

	TBool NeedsCleanup() const;

	CXMLElement* BeginElementL( TUint8 aTag, const TXMLElementParams& aParams = TXMLElementParams() );

	CXMLElement::TAction EndElementL( TAny* aCallbacks, TUint8 aTag );

	} *SmlMapPtr_t, SmlMap_t;

/**

 * Results command:

 **/

typedef struct sml_results_s : public CXMLElement

	{

public:

	SmlProtoElement_t	      elementType; // Internal Toolkit Field

	SmlPcdataPtr_t        cmdID;

	SmlPcdataPtr_t        msgRef;     // opt.

	SmlPcdataPtr_t        cmdRef;

	SmlPcdataPtr_t        meta;       // opt.

	SmlPcdataPtr_t        targetRef;  // opt.

	SmlPcdataPtr_t        sourceRef;  // opt.

	SmlItemListPtr_t      itemList;