ordervariant.h

Data Replication Prototype Using ADO

#ifndef __OrderVariant_h__
#define __OrderVariant_h__


#include "BellsMacrosX.h"

#ifdef ETLLIB_DLL
#define ETLLIB_EXPORT __declspec(dllexport)
#else
#define ETLLIB_EXPORT __declspec(dllimport)
#endif

#define _countof(array) (sizeof(array)/sizeof(array[0]))


class CTblCopyHelper;
class CDBTable;
class CDBAttrubuteDesc;

#include "identity.h"

#include "TableHolder.h"

#pragma warning(push, 3)
#include <string>
#pragma warning(pop)

#include "GrowableMap.h"

#pragma warning(disable:4097)


typedef CGrowableMap<Identity, Identity, Identity, Identity> CMapIdentities;

struct CSubstRec
{
	Identity m_lKeyTo, m_lKeyFrom;
	CSubstRec() 
	{
		m_lKeyTo = ID_NOT_DEF;
		m_lKeyFrom = ID_NOT_DEF;
	}
	CSubstRec(Identity lKeyTo, Identity lKeyFrom)
	{
		m_lKeyTo = lKeyTo;
		m_lKeyFrom = lKeyFrom;
	}
};

class CSubstRecArray : public CArray<CSubstRec, const CSubstRec&>
{
	unsigned int m_nRefs;
public:    
	CSubstRecArray()	{ m_nRefs = 0; }
	~CSubstRecArray()	{ ASSERT(0 == m_nRefs); }
	void upcount()		{ ++m_nRefs; }
	void downcount()	{ if (--m_nRefs == 0) delete this; }
	int GetNumRefs()	{ return m_nRefs; }
};

template <class T> class Ptr 
{    
	T* p;
public:
	Ptr(T* p_) : p(p_) { p->upcount(); }    
	~Ptr()			{ p->downcount(); }
	operator T*()	{ return p; }    
	T& operator*() { return *p; }
	T* operator->(){ return p; }    
	Ptr& operator=(Ptr<T> &p_) { return operator=((T *) p_); }    
	Ptr& operator=(T* p_) 
	{
		p_->upcount(); 
		p->downcount(); 
		p = p_; 

		return *this;    
	}
};

typedef Ptr<CSubstRecArray> CSubstRecArrayPtr;

class CCopyIteratorData
{
protected:
	enum
	{
		ciNotDef = 0,
		ciSingle,
		ciMultiple,
		ciByPK
	}	
	m_ciKind;

	struct Pair
	{
		Identity m_lValueTo, m_lValueFrom;
		Pair() : m_lValueTo(ID_NOT_DEF), m_lValueFrom(ID_NOT_DEF) {}
	} 
	m_pair;

	union
	{
		CSubstRecArray* m_parrSubstRec;
		CArray<Identity, Identity> * m_parrId;
	};

public:
	CCopyIteratorData()
	{
		m_ciKind = ciNotDef;
		m_parrSubstRec = NULL;
	}
};

class ETLLIB_EXPORT CCopyIterator : public CCopyIteratorData
{
public:
	CCopyIterator()	{ m_ciKind  = ciNotDef; }
	CCopyIterator(const CCopyIterator& other);
	CCopyIterator(CSubstRecArrayPtr& parrSubstRec)
	{
		SetData(parrSubstRec);
	}
	CCopyIterator(CArray<Identity, Identity>* parrId)
	{
		SetData(parrId);
	}
	CCopyIterator(Identity lPK)
	{
		SetData(lPK);
	}
	CCopyIterator(Identity lValueTo, Identity lValueFrom)
	{
		SetData(lValueTo, lValueFrom);
	}
	~CCopyIterator() { Clear(); }
	const CCopyIterator& operator = (const CCopyIterator& other);
	void Clear();
	void SetData(Identity lValueTo, Identity lValueFrom);
	void SetData(CSubstRecArrayPtr& parrSubstRec);
	void SetData(CArray<Identity, Identity>* parrId);
	void SetData(Identity lPK);
	void AddData(CSubstRecArrayPtr& parrSubstRec);
	BOOL ByPK();
	Identity GetValueTo();
	Identity GetValueFrom();
	Identity GetValueTo(int nIndex);
	Identity GetValueFrom(int nIndex);
	int GetSize();
};


#define OV_ENTRY				1
#define OV_LINK					2
#define OV_XLINK				3
#define OV_KIND					3

#define OV_PASSED				4

#define OV_LEAVE_UNIQUE			8
#define OV_LEAVE_DATA			16
#define OV_LEAVE_KIND			24

#define OV_NOT_SERIAL			32
#define OV_SERIAL				64
#define OV_SERIAL_KIND			96

#define OV_CONVERT_ONLY			128

#define OV_BY_REFERENCE			256

#define OV_UPDATE_TEMPL_REF	512

#define OV_DONT_COPY_REF		1024
#define OV_DONT_SHORTCUT_REF	2048

#define OV_USE_EXISTING			0
#define OV_ASK_CHOICE			4096
#define OV_CREATE_NEW			8192
#define OV_OVERWRITE			(OV_ASK_CHOICE | OV_CREATE_NEW)

#define OV_INITIALIZED			0x4000
#define OV_ABANDON_DEPENDANTS	0x8000

enum LeaveKind
{
	lkDeleteAll		= 0,
	lkLeaveUnique	= OV_LEAVE_UNIQUE,
//	lkLeaveUnique means don't delete recs at all; if record matching by UI is found, use it.
	lkLeaveData		= OV_LEAVE_DATA
//	lkLeaveData means don't delete recs at all; add new records always w/o checking by UI.
};

enum SerialKind
{
	skNotDefined	= 0,
	skNotSerial		= OV_NOT_SERIAL,
	skSerial			= OV_SERIAL
};

enum UIChoiceKind
{
	uiAskChoice		= OV_ASK_CHOICE,
	uiUseExisting	= OV_USE_EXISTING,// by default
	uiCreateNew		= OV_CREATE_NEW,
	uiOverwrite		= OV_OVERWRITE
};


void MakeCopyName(std::wstring& strName, int nInstance);


typedef CDBTable* (*TableObjCreator) (CTableHolder*);

class ETLLIB_EXPORT CTableId
{
public:
	CTableId() 
	{ 
		m_pfnCreator = NULL; 
		m_pszTableName = NULL; 
	}
	CTableId(TableObjCreator pfnCreator,
				LPCWSTR pszTableName
				)
	: m_pfnCreator(pfnCreator)
	, m_pszTableName(pszTableName)
	{
	}
	bool operator == (const CTableId& other) const;
	bool operator != (const CTableId& other) const
	{
		return !(*this == other);
	}
	bool operator < (const CTableId& other) const;
	bool operator == (const CDBTable* other) const;
	bool operator != (const CDBTable* other) const
	{
		return !(*this == other);
	}

	CString GetTableName() const { return m_pszTableName; }
	bool operator ! () const	  { return NULL == m_pszTableName; }
	CDBTable* GetDBTable(CTableHolder* pHolder) const;

	UINT GetHashKey() const { return HashKey(m_pszTableName); }

private:
	TableObjCreator m_pfnCreator;
	LPCWSTR	m_pszTableName;
};

template<class T> class CreateTableId
{
	LPCWSTR m_pszTableName;

	static CDBTable* CreateTable (CTableHolder* pHolder)
	{
		return new T(pHolder);
	}

public:
	CreateTableId()
		: m_pszTableName(T::g_szTableName)
	{}
	operator const CTableId&()
	{
		static char buf[sizeof(CTableId)];// Zero filled according to the C++ standard
		const CTableId& id = *reinterpret_cast<const CTableId*>(buf);
		if(!id)
			::new(buf) CTableId(
					CreateTable
					, m_pszTableName
					);
		return id;
	}
};


template<> AFX_INLINE UINT AFXAPI HashKey<const CTableId&>(const CTableId& key)
{
	return key.GetHashKey();
}


#define BOOL_PROP(Name, Mask)			\
bool Is##Name() const					\
	{ return !!(m_dwFlags & Mask); }	\
void Set##Name(bool bValue = true)		\
{										\
	if(bValue)							\
		m_dwFlags |= Mask;				\
	else								\
		m_dwFlags &= ~Mask;				\
}

class COrderVariant;


class CDataHandlerKey
{
public:
	CDataHandlerKey() {}
	CDataHandlerKey(const CTableId& id) : m_id(id) {}
	CTableId	GetCopyTableId() const { return m_id; }

protected:
	static void SetCopyTableId(CDataHandlerKey* pKey, const CTableId& id)
	{
		pKey->m_id = id;
	}
	CTableId		m_id;
};



class ETLLIB_EXPORT CDataProvider
: public CDataHandlerKey
{
public:
	CDataProvider()
	{
		m_pTblCopyHelper	= NULL;
		m_pTblCopyTo		= NULL;
	}
	virtual ~CDataProvider() {}

	void SetParameters(CTblCopyHelper* pTblCopyHelper,
				const CTableId&	id)	
	{ 
		m_pTblCopyHelper	= pTblCopyHelper; 
		m_id = id;
	}
	CTblCopyHelper* GetTblCopyHelper();

	virtual void FreeStatements() = 0;

	virtual BOOL FindNextFrom() = 0;
	virtual BOOL FindByPrimaryKeyFrom(Identity lId) = 0;

	virtual Identity GetFieldFrom(size_t) const = 0;
	virtual void SetFieldFrom(size_t, Identity) = 0;


	virtual BOOL FindFirstFrom(DWORD dwFilterType) = 0;
	virtual Identity GetPrimaryKeyFrom() = 0;
	virtual void CopyData(bool bCopyPK) = 0;

	virtual void FirstSubType()	{}	//	To be used also for lazy initialization

protected:
	CDBTable* GetTblCopyTo();
	const CDBTable* GetTblCopyTo() const 	
	{ 
		return const_cast<CDataProvider*>(this)->GetTblCopyTo(); 
	}

private:
	CTblCopyHelper* m_pTblCopyHelper;
	CDBTable* m_pTblCopyTo;
};

class ETLLIB_EXPORT CGenericDataProvider
: public CDataProvider
{
public:
	CGenericDataProvider()
	{
		m_pTblCopyFrom		= NULL;