XMLFoundation

// --------------------------------------------------------------------------
//					www.UnitedBusinessTechnologies.com
//			  Copyright (c) 1998 - 2002  All Rights Reserved.
//
// Source in this file is released to the public under the following license:
// --------------------------------------------------------------------------
// This toolkit may be used free of charge for any purpose including corporate
// and academic use.  For profit, and Non-Profit uses are permitted.
//
// This source code and any work derived from this source code must retain 
// this copyright at the top of each source file.
// 
// UBT welcomes any suggestions, improvements or new platform ports.
// email to: XMLFoundation@UnitedBusinessTechnologies.com
// --------------------------------------------------------------------------

#ifndef _MEMBER_MAP_ENTRY_H
#define _MEMBER_MAP_ENTRY_H

#ifndef _WIN32
	#ifndef __int64
		#define	__int64 long long
	#endif
#endif


#include "AttributeList.h"
#include "xmlDefines.h"
#include "ListAbstraction.h"

class StackFrameCheck;
class MemberHandler;
class StringAbstraction;
class XMLAttributeList;
class XMLObject;

class MemberDescriptor
{
	// a bit flag field containing NULL, DIRTY, CACHE states
	int m_memberStateFlags;

	// user defined data structure
	void *m_pUserData;

public: 
	// pointer to object that contains the member described by this structure
	XMLObject *m_ParentObject;
	
	// almost always true.  See XMLObject::IsFirstMap() in XMLObject.cpp
	int m_bFirstMap;

	void *GetItemData();
	void  SetItemData(void *);

	~MemberDescriptor();
	void Init( XMLObject *pParent );
	void GetTypeName(GString &strTypeDescription);
	bool GetMemberValue(GString &strValue);

	// Construct a Root element used to store tag-to-objectFactory mappings for the Factory Manager
	MemberDescriptor(XMLObject *pParent, const char *pzTag, ObjectFactory pFactory, const char * pzClassType);

	// This contructs the MemberDescriptor to refer to an Entity.  It causes the 
	// Entity to be serialized out by name, so that the Object can restore by the
	// value that the tokenizer will put in it's place.
	MemberDescriptor(XMLObject *pParent, const char *pzEntityName);

	// Construct an integer XMLEntry
	MemberDescriptor(XMLObject *pParent, const char *pzTag, int *pVal);
	MemberDescriptor(XMLObject *pParent, const char *pzTag, long *pVal);
	MemberDescriptor(XMLObject *pParent, const char *pzTag, __int64 *pVal);
	// Construct a string XMLEntry
	MemberDescriptor(XMLObject *pParent, const char *pzTag, void *pVal, StringAbstraction *pHandler);
	// Construct a sub-Object pointer XMLEntry
	MemberDescriptor(XMLObject *pParent, const char *pzTag, XMLObject **pObj, ObjectFactory pFactory );
	// Construct a sub-Object XMLEntry
	MemberDescriptor(XMLObject *pParent, const char *pzTag, XMLObject *pObj);
	// Construct an Object Collection XMLEntry
	MemberDescriptor(XMLObject *pParent, const char *pzTag, void *pList, ListAbstraction *pHandler, ObjectFactory pFactory);
	// Construct a member that will be controlled by supplied handler object
	MemberDescriptor(XMLObject *pParent, const char *pzTag, MemberHandler *pHandler);
	// Construct a string collection mapping entry
	MemberDescriptor(XMLObject *pParent, const char *pzTag, void *pStringCollection, StringCollectionAbstraction *pHandler);
	// Construct an integer array mapping entry
	MemberDescriptor(XMLObject *pParent, const char *pzTag, void *pIntegerArray, IntegerArrayAbstraction *pHandler);
	// Construct a member structure that contains object/key pairs (binary tree, hash etc)
	MemberDescriptor(XMLObject *pParent, const char *pzTag, void *pKeyedDSA,KeyedDataStructureAbstraction *pHandler);

	// tree nodes alphebetically sorted by Tag
	MemberDescriptor *Left;    
	MemberDescriptor *Right;

	// This is the Key for searching the tree, supplied by the derived class.
	// This is the tag that the XML Parser uses to obtain storage for element data
	// when it encounters a new tag in the XML.
	GString strTagName;

	// Always NULL unless pointing to member sub-object of type Collection.
	ObjectFactory m_pfnFactoryCreate; 

	// XML serialization support for the member that this entry describes
	void MemberToXML(GString& xml, int nTabs, StackFrameCheck *pStack,int nSerializeFlags);
	static void TabifyXML(GString& xml, int nTabs );

	// Object's attributes are stored in the object, not in this descriptor
	// so if IsSubObject() is true, m_pAttributes will always be null. Most 
	// member variables have no attributes, so only when a member with 
	// attributes is encountered is m_pAttributes allocated. 
	XMLAttributeList *m_pAttributes;

	// Access to attributes of the member.
	void AddAttribute( const char * pzName, const char * pzValue );
	void AddAttribute( const char * pzName, int nValue );
	const char *FindAttribute( const char *pzAttName );
	
	void SetAsTempObject(XMLObject *pO);


	// Native, and user defined datatype support
	enum DataTypes 
	{ 
		XMLObj, 
		XMLObjPtr,
		UserString,
		UserStringCollection,
		UserIntegerArray,
		XMLObjList,
		Int,
		Long,
		Int64, 
		Str, 
		Root, 
		Bool, 
		ManagedByDerivedClass,
		KeyedDataStructure,
		EntityReference
	} DataType;

	// This member may represent 0-n objects. These methods provide 
	// information about, and access to the Contained Objects.
	bool IsSubObject();
	bool IsSimpleType();

	
	// If this member contains 1 or more objects, the following set
	// of methods abstract a common interface no matter what the 
	// specific type of object container is.
	int AddContainedObject( XMLObject *pO );
	int  GetObjectContainmentCount();
	void RemoveLastContainedObject( xmlObjectIterator iter );
	XMLObject *GetNextContainedObject( xmlObjectIterator iter );
	XMLObject *GetFirstContainedObject( xmlObjectIterator *iter );
	void ReleaseObjectIterator( xmlObjectIterator iter );


	// When the XML Parser sets the data, it is setting the initial value
	// so it is not considered dirty, however when an application developer
	// sets the state of a member variable, it is now dirty.
	void Set(const char * pzData, int nDataLen, bool bSetDirty, bool bUpdateCleanMembers);

	bool IsDirty();
	bool IsNull();
	bool IsCached();
	bool IsSerializable();

	void SetSerializable( bool bSerialize );
	void SetDirty( );

	// These are mutually exclusive and store the location of 
	// XMLObject derived member data.  
	// If the derived type is a collection, pObjectList contains 
	//     storage for objects created from the m_pfnFactoryCreate.
	// pObject points to a member sub-Object in the derived class.
	union DERIVED_DATA_STORAGE
	{
		const char *pClassName;
		char **ppNativeString;
		bool *pBool;
		XMLObject *pObject;
		XMLObject **ppObject;
		void *pUserString;
		void *pXMLObjList;
		void *pUserStringCollection;
		void *pUserIntegerArray;
		int *pInt;
		long *pLong;
		void *pKeyedDSA;
		__int64 *pInt64;
	}m_Member;  

	// abstration handlers are used make atomic list and string operations, 
	// for MFC and Rouge Wave interoperability
	union DERIVED_DATA_MANAGEMENT_ABSTRACTION
	{
		ListAbstraction *pListHandler;
		StringAbstraction *pStringHandler;
		MemberHandler *pMemberHandler;
		StringCollectionAbstraction *pStrListHandler;
		IntegerArrayAbstraction *pIntArrayHandler;
		KeyedDataStructureAbstraction *pKeyDSA;
	}m_DataAbstractor;
};

#endif //_MEMBER_MAP_ENTRY_H