ordervariant.h

Data Replication Prototype Using ADO

	}

	virtual void FreeStatements();

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

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


	virtual BOOL FindFirstFrom(DWORD dwFilterType);
	virtual Identity GetPrimaryKeyFrom();
	virtual void CopyData(bool bCopyPK);
	
protected:
	CDBTable* GetTblCopyFrom();
	const CDBTable* GetTblCopyFrom() const
	{ 
		return const_cast<CGenericDataProvider*>(this)->GetTblCopyFrom(); 
	}

private:
	CDBTable* m_pTblCopyFrom;
};

template<class T> class CTypedGenericDataProvider
: public CGenericDataProvider
{
};


//////////////////////////////////////////////////////////////////////////

typedef CDataProvider* (*ProviderCreateFunc)();

class ETLLIB_EXPORT CDataHandler
: public CDataHandlerKey
{
public:
	CDataHandler()
	{
		m_dwFlags = 0;
		m_pTblCopyHelper	= NULL;
		m_pTblCopyTo		= NULL;
		m_pDataProvider	= NULL;
		m_ProviderCreateFunc = NULL;
	}
	virtual ~CDataHandler() {}

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

	CDataProvider* GetDataProvider();
	const CDataProvider* GetDataProvider() const
		{ return const_cast<CDataHandler*>(this)->GetDataProvider(); }

//	Data receiver-specific methods
	virtual BOOL DeleteRecord();
	virtual void DeleteRecords(DWORD dwFilterType);
	virtual BOOL FindMatchByUI();
	virtual bool SetUniqueName();

	void FreeStatements();
	BOOL FindNextFrom();
	BOOL FindByPrimaryKeyFrom(Identity lId);
	Identity GetFieldFrom(size_t) const;
	void SetFieldFrom(size_t, Identity);
	BOOL FindFirstFrom(DWORD dwFilterType);
	Identity GetPrimaryKeyFrom();
	void CopyData(bool bCopyPK);
	
	virtual void CorrectTableData() {}
	virtual BOOL PostUpdate() { return TRUE; }
	virtual BOOL PostCopyAll(CSubstRecArray*) { return TRUE; }
	virtual void SetIDs()			{}

	virtual void FirstSubType()	{}	//	To be used also for lazy initialization
	virtual bool NextSubType(CCopyIterator*, DWORD&)	{ return false; }
	virtual bool IsObsolete()		{ return false; }
	virtual bool IsObsoleteByRefs()	{ return false; }
	virtual void OnCopyRefSpecial()	{}
	virtual void OnRefAdded( Identity )	{}

//	Properties
	LeaveKind GetLeaveData()		{ return LeaveKind(m_dwFlags & OV_LEAVE_KIND); }
	void		 SetLeaveData(LeaveKind lk)		
											{ m_dwFlags = (m_dwFlags & ~OV_LEAVE_KIND) | lk; }
	BOOL_PROP(ConvertOnly, OV_CONVERT_ONLY)
	BOOL_PROP(UpdateDestination, OV_UPDATE_TEMPL_REF)
	BOOL_PROP(DontCopyRef, OV_DONT_COPY_REF)
	BOOL_PROP(DontShortcutRef, OV_DONT_SHORTCUT_REF)
	BOOL_PROP(Initialized, OV_INITIALIZED)
	BOOL_PROP(AbandonDependants, OV_ABANDON_DEPENDANTS)

	UIChoiceKind GetUIChoiceKind(){ return UIChoiceKind(m_dwFlags & OV_OVERWRITE); }
	void SetUIChoiceKind(UIChoiceKind ck) { m_dwFlags = (m_dwFlags & ~OV_OVERWRITE) | ck; }

protected:
	CDBTable* GetTblCopyTo();


	ProviderCreateFunc m_ProviderCreateFunc;

private:
	CTblCopyHelper* m_pTblCopyHelper;
	CDBTable* m_pTblCopyTo;
	DWORD			m_dwFlags;
	CDataProvider* m_pDataProvider;
};


typedef CDataHandler* (*VariantCreateFunc)();

class COrderVariantKey
{
public:
	COrderVariantKey()
	{
		m_dwFlags = 0; 
	}
	COrderVariantKey(const CTableId& id)
	: m_idSlave(id)
	{
		m_dwFlags = 0; 
	}

	CTableId GetTblSlaveTo() const	{ return m_idSlave; }
	CTableId	GetTblMasterTo() const	{ return m_idMaster; }
	CTableId	GetCopyTableId() const	
	{ 
		return (OV_XLINK == (m_dwFlags & OV_KIND))? m_idMaster : m_idSlave;
	}
	bool IsOrderVariant() const		{ return m_dwFlags != 0; }

protected:
	DWORD			m_dwFlags;
	CTableId		m_idMaster, m_idSlave;
};

class ETLLIB_EXPORT COrderVariant : public COrderVariantKey
{
	friend bool ETLLIB_EXPORT IsEqual(COrderVariant* pVar1, COrderVariant* pVar2);
public:
	COrderVariant()						
	{ 
		m_pTblCopyTo		= NULL;
		m_pTblSlTo			= NULL;
		m_pTblSlFrom		= NULL;
		m_dwFilterType = 0; 
		m_dwFlags = 0; 
		m_pMapId				= NULL;
		m_pTblCopyHelper	= NULL;
		m_pForkEntry		= NULL;
		m_bForked			= false;
		m_pOrderVariant	= NULL;
		m_pSlaveOV			= NULL;
		m_VariantCreateFunc = NULL;
		m_nFieldOffset		= 0;
	}
	~COrderVariant()						
	{
		if(m_pForkEntry)
			m_pForkEntry->m_pForkEntry = NULL;
	}

	void SetTblCopyHelper(CTblCopyHelper* pTblCopyHelper)	
											{ m_pTblCopyHelper = pTblCopyHelper; }
	CTblCopyHelper* GetTblCopyHelper();

	DWORD		 GetFilterType()		{ return m_dwFilterType; }
	void		 SetPassed()			{ m_dwFlags |= OV_PASSED; }
	BOOL_PROP(ByReference, OV_BY_REFERENCE)
	SerialKind GetSerialKind()    { return SerialKind(m_dwFlags & OV_SERIAL_KIND); }
	void SetSerialKind(SerialKind sk) { m_dwFlags |= sk; }
	bool			IsAccessory()			{ return 0 == m_dwFilterType;	 }

	BOOL IsPassed();

	LeaveKind GetLeaveData();

	UIChoiceKind GetUIChoiceKind();
	void SetUIChoiceKind(UIChoiceKind ck);

	bool IsEntry()		{ return OV_ENTRY == (m_dwFlags & OV_KIND); }
	bool IsLink()		{ return OV_LINK == (m_dwFlags & OV_KIND); }
	bool IsXLink()		{ return OV_XLINK == (m_dwFlags & OV_KIND); }

	CDBTable* GetTblCopyTo();

	Identity	 GetFieldSlaveTo() const;
	Identity	 GetFieldSlaveFrom() const;
	void		 SetFieldSlaveTo(Identity);
	void		 SetFieldSlaveFrom(Identity);

	Identity	GetPrimaryKeyFrom();

	Identity	GetIteratorValueTo()		{ return m_CopyIterator.GetValueTo();   }
	Identity	GetIteratorValueFrom()	{ return m_CopyIterator.GetValueFrom(); }

	void		CopyData(bool bCopyPK = true);

	void AddCouple();
	BOOL Convert();

	bool		 IsSelfLink()				{ return m_idMaster == m_idSlave; }

	void AddSubstRecs(CSubstRecArrayPtr& SubstRecArrayPtr)
	{
		m_CopyIterator.AddData(SubstRecArrayPtr);
	}
	COrderVariant* ForkEntry(CSubstRecArrayPtr& );// { return NULL; }
	void ConvertToEntry(CSubstRecArrayPtr& SubstRecArrayPtr);

	BOOL DeleteRecord();
	void DeleteRecords(DWORD dwFilterType);

	void SetIDs();

	void FirstSubType();
	void CorrectTableData();
	BOOL FindMatchByUI();
	BOOL FindFirstFrom(DWORD dwFilterType);
	bool IsObsolete();	
	bool IsObsoleteByRefs();
	BOOL PostUpdate();
	BOOL FindNextFrom();
	bool NextSubType(CCopyIterator* pCI, DWORD& rDW);
	BOOL PostCopyAll(CSubstRecArray* pArr);
	void FreeStatements();
	BOOL FindByPrimaryKeyFrom(Identity lId);
	void OnCopyRefSpecial();
	bool IsUpdateDestination();
	bool IsDontCopyRef();
	bool IsDontShortcutRef();
	bool IsAbandonDependants();
	bool IsConvertOnly();

	CCopyIterator m_CopyIterator;
	CMapIdentities* m_pMapId;

	const CDataHandler* OrderVariantBase() const
	{
		return const_cast<COrderVariant*>(this)->GetOrderVariantBase();
	}
	CString GetEntityName() const;

	size_t GetFieldOffset() const { return m_nFieldOffset; }

	bool IsForked()					{ return m_bForked; }

	bool SetUniqueName();

	bool HasPrimaryKey();

protected:
	CDataHandler* GetOrderVariantBase();
	CDataHandler* GetSlaveOrderVariantBase();
	CDBTable*		 GetTblSlaveTo_();
	CDBTable*		 GetTblSlaveFrom_();

	DWORD			m_dwFilterType;

	VariantCreateFunc m_VariantCreateFunc;

	size_t		m_nFieldOffset;

private:
	CTblCopyHelper* m_pTblCopyHelper;
	CDataHandler* m_pOrderVariant;
	CDataHandler* m_pSlaveOV;

	CDBTable*	m_pTblCopyTo;
	CDBTable*			m_pTblSlTo;
	CDBTable*			m_pTblSlFrom;

//	Mutual reference between link and entry
	COrderVariant* m_pForkEntry;
	bool			m_bForked;
};

#undef BOOL_PROP


typedef COrderVariant COrderEntry;
typedef COrderVariant COrderLink;
typedef COrderVariant CXLink;


template<class T> class COrderVariantBase : public CDataHandler
{
public:
	COrderVariantBase()		{ m_ProviderCreateFunc = GetDataProvider; }
protected:
	T* GetTypedTblCopyTo()	{ return static_cast<T*>(GetTblCopyTo()); }
private:
	static CDataProvider* GetDataProvider()	
		{ return new CTypedGenericDataProvider<T>(); }	
};

template<class T> class CTypedOrderVariant : public COrderVariantBase<T>
{
};


//////////////////////////////////////////////////////////////////////////

template<class T> class CTypedOrderVarDesc : public CTypedOrderVariant<T>
{
};


template<class T> class CTypedEntryLink : public COrderVariant
{
public:
	CTypedEntryLink( CCopyIterator		CopyIterator,
							const CTableId&	idSlave,
							size_t	nFieldOffset,
							DWORD	dwFilterType = fltAutoNumber | fltPrimaryKey)
	{
		m_CopyIterator		= CopyIterator;
		m_idSlave			= idSlave;
		m_nFieldOffset		= nFieldOffset;
		m_dwFilterType		= dwFilterType;
		m_dwFlags		  |= OV_ENTRY;
		CommonConstruct();
	}

	CTypedEntryLink(  const CTableId&	idMaster,
							const CTableId&	idSlave,
							size_t				nFieldOffset,
							DWORD					dwFilterType)
	{
		m_idMaster			= idMaster;
		m_idSlave			= idSlave;
		m_nFieldOffset		= nFieldOffset;
		m_dwFilterType		= dwFilterType;
		m_dwFlags		  |= OV_LINK;
		CommonConstruct();
	}

	CTypedEntryLink(	bool					bByReference,
							const CTableId&	idMaster,
							const CTableId&	idSlave,
							size_t				nFieldOffset)
	{
		m_idMaster			= idMaster;
		m_idSlave			= idSlave;
		m_nFieldOffset		= nFieldOffset;
		m_dwFlags		  |= OV_XLINK;
		if(bByReference)
			SetByReference();
		CommonConstruct();
	}

protected:
	void CommonConstruct()	{ m_VariantCreateFunc = DoGetOrderVariantBase; }

	static CDataHandler* DoGetOrderVariantBase() 
	{ return new CTypedOrderVarDesc<T>; }
};

#endif //__OrderVariant_h__