ordervariant.cpp

Data Replication Prototype Using ADO

	m_pForkEntry->m_pForkEntry = this;
	m_bForked = true;
	return pEntry;
}

void COrderVariant::ConvertToEntry(CSubstRecArrayPtr& SubstRecArrayPtr)
{
	ASSERT(OV_XLINK != (m_dwFlags & OV_KIND));
	m_CopyIterator.SetData(SubstRecArrayPtr);
	m_dwFlags = (m_dwFlags & ~OV_KIND) | OV_ENTRY;
}

BOOL COrderVariant::DeleteRecord()
{ 
	ASSERT((m_dwFlags & OV_KIND) != OV_XLINK);
	return GetOrderVariantBase()->DeleteRecord(); 
}

void COrderVariant::DeleteRecords(DWORD dwFilterType)
{ 
	ASSERT((m_dwFlags & OV_KIND) != OV_XLINK);
	GetOrderVariantBase()->DeleteRecords(dwFilterType); 
}

void COrderVariant::FirstSubType()			
{ 
	if(!GetOrderVariantBase()->IsInitialized())
	{
		GetOrderVariantBase()->SetInitialized();
		GetOrderVariantBase()->FirstSubType(); 
		GetOrderVariantBase()->GetDataProvider()->FirstSubType(); 
	}
}

bool COrderVariant::NextSubType(CCopyIterator* pCI, DWORD& rDW)
{ 
	GetOrderVariantBase()->SetInitialized(false);// ?
	return GetOrderVariantBase()->NextSubType(pCI, rDW); 
}

void COrderVariant::CorrectTableData()		{ GetOrderVariantBase()->CorrectTableData(); }
BOOL COrderVariant::FindMatchByUI()			{ return GetOrderVariantBase()->FindMatchByUI(); }
bool COrderVariant::IsObsolete()				{ return GetOrderVariantBase()->IsObsolete(); }
bool COrderVariant::IsObsoleteByRefs()		{ return GetOrderVariantBase()->IsObsoleteByRefs(); }
BOOL COrderVariant::PostUpdate()				{ return GetOrderVariantBase()->PostUpdate(); }
BOOL COrderVariant::FindNextFrom()			{ return GetOrderVariantBase()->FindNextFrom(); }

BOOL COrderVariant::PostCopyAll(CSubstRecArray* pArr)
									{ return GetOrderVariantBase()->PostCopyAll(pArr); }

void COrderVariant::FreeStatements()			
{ 
	GetTblCopyTo()->FreeStatements(); 
	GetOrderVariantBase()->FreeStatements(); 
}

BOOL COrderVariant::FindByPrimaryKeyFrom(Identity lId)
											{ return GetOrderVariantBase()->FindByPrimaryKeyFrom(lId); }
void COrderVariant::OnCopyRefSpecial()		{ GetOrderVariantBase()->OnCopyRefSpecial(); }
bool COrderVariant::IsUpdateDestination()	{ return GetOrderVariantBase()->IsUpdateDestination(); }
bool COrderVariant::IsDontCopyRef()			{ return GetOrderVariantBase()->IsDontCopyRef(); }
bool COrderVariant::IsDontShortcutRef()		{ return GetOrderVariantBase()->IsDontShortcutRef(); }
bool COrderVariant::IsAbandonDependants()	{ return GetOrderVariantBase()->IsAbandonDependants(); }
bool COrderVariant::IsConvertOnly()			{ return GetOrderVariantBase()->IsConvertOnly(); }


UIChoiceKind COrderVariant::GetUIChoiceKind() 
									{ return GetOrderVariantBase()->GetUIChoiceKind(); }
void COrderVariant::SetUIChoiceKind(UIChoiceKind ck)
									{ GetOrderVariantBase()->SetUIChoiceKind(ck); }

bool COrderVariant::SetUniqueName()			{ return GetOrderVariantBase()->SetUniqueName(); }


Identity	COrderVariant::GetFieldSlaveTo()	 const
{ 
	return GetIdentityValue(const_cast<COrderVariant*>(this)->GetTblSlaveTo_(), GetFieldOffset());
} 

Identity	COrderVariant::GetFieldSlaveFrom()  const
{ 
	const CDataHandler* pBase 
		= const_cast<COrderVariant*>(this)->GetSlaveOrderVariantBase();
	return (pBase)?
		pBase->GetFieldFrom(GetFieldOffset())
		: GetIdentityValue(const_cast<COrderVariant*>(this)->GetTblSlaveFrom_(), GetFieldOffset());
} 

void	COrderVariant::SetFieldSlaveTo(Identity lId)
{ 
	CHECK_ADDRESS(this);
	SetIdentityValue(GetTblSlaveTo_(), GetFieldOffset(), lId);
} 

void	COrderVariant::SetFieldSlaveFrom(Identity lId)
{ 
	CDataHandler* pBase = GetSlaveOrderVariantBase();
	if(pBase)
		pBase->SetFieldFrom(GetFieldOffset(), lId);
	else
		SetIdentityValue(GetTblSlaveFrom_(), GetFieldOffset(), lId);
} 


BOOL COrderVariant::FindFirstFrom(DWORD dwFilterType)
									{ return GetOrderVariantBase()->FindFirstFrom(dwFilterType); }
Identity COrderVariant::GetPrimaryKeyFrom()
									{ return GetOrderVariantBase()->GetPrimaryKeyFrom(); }
void COrderVariant::CopyData(bool bCopyPK)
									{ GetOrderVariantBase()->CopyData(bCopyPK); }

CDBTable* COrderVariant::GetTblCopyTo()
{ 
	return HandleCreateTable(
		GetCopyTableId(),
		m_pTblCopyTo,
		GetTblCopyHelper()->GetHolderTo());
}

CDataHandler* COrderVariant::GetOrderVariantBase()
{
	if(!m_pOrderVariant)
	{
		CTblCopyHelper* pTblCopyHelper = GetTblCopyHelper();
		if(pTblCopyHelper)
		{
			CDataHandlerKey key(GetCopyTableId());
			CSetVariantBases::const_iterator iter 
				= pTblCopyHelper->m_mapOrderVariants.find(static_cast<CDataHandler*>(&key));
			if(iter != pTblCopyHelper->m_mapOrderVariants.end())
				m_pOrderVariant = *iter;
			else if(m_VariantCreateFunc)
			{
				m_pOrderVariant = m_VariantCreateFunc();
				if(m_pOrderVariant)
				{
					m_pOrderVariant->SetParameters(pTblCopyHelper, GetCopyTableId());
					pTblCopyHelper->m_mapOrderVariants.insert(m_pOrderVariant);
				}
			}
		}
	}
	CHECK_ADDRESS(m_pOrderVariant);
	return m_pOrderVariant;
}

CDataHandler* COrderVariant::GetSlaveOrderVariantBase()
{
	if(OV_XLINK != (m_dwFlags & OV_KIND))
		return m_pOrderVariant;
	if(!m_pSlaveOV)
	{
		CTblCopyHelper* pTblCopyHelper = GetTblCopyHelper();
		if(pTblCopyHelper)
		{
			CDataHandlerKey key(GetTblSlaveTo());
			CSetVariantBases::const_iterator iter 
				= pTblCopyHelper->m_mapOrderVariants.find(static_cast<CDataHandler*>(&key));
			if(iter != pTblCopyHelper->m_mapOrderVariants.end())
				m_pSlaveOV = *iter;
			else
			{
				return NULL;
			}

		}
	}
	CHECK_ADDRESS(m_pSlaveOV);
	return m_pSlaveOV;
}


CDBTable* COrderVariant::GetTblSlaveFrom_() 
{
	return HandleCreateTable(
		m_idSlave,
		m_pTblSlFrom,
		GetTblCopyHelper()->GetHolderFrom());
}


CDBTable* COrderVariant::GetTblSlaveTo_() 
{
	return HandleCreateTable(
		m_idSlave,
		m_pTblSlTo,
		GetTblCopyHelper()->GetHolderTo());
}


CString COrderVariant::GetEntityName() const
{
	return (OV_XLINK == (m_dwFlags & OV_KIND))?
		m_idMaster.GetTableName() : m_idSlave.GetTableName();
}


bool IsEqual(COrderVariant* pVar1, COrderVariant* pVar2)
{
	CHECK_ADDRESS(pVar1); CHECK_ADDRESS(pVar2);
	return pVar1->m_idMaster == pVar2->m_idMaster 
		&& pVar1->m_idSlave == pVar2->m_idSlave
		&& pVar1->m_nFieldOffset == pVar2->m_nFieldOffset;
}



bool COrderVariant::HasPrimaryKey()	{ return GetTblCopyTo()->HasPrimaryKey(); }


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

CDBTable* CDataProvider::GetTblCopyTo()
{
	return HandleCreateTable(
		GetCopyTableId(),
		m_pTblCopyTo,
		GetTblCopyHelper()->GetHolderTo());
}

CTblCopyHelper* CDataProvider::GetTblCopyHelper()
{
	CHECK_ADDRESS(m_pTblCopyHelper);
	return m_pTblCopyHelper; 
}

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

CTblCopyHelper* CDataHandler::GetTblCopyHelper()	
{ 
	CHECK_ADDRESS(m_pTblCopyHelper);
	return m_pTblCopyHelper; 
}

BOOL CDataHandler::DeleteRecord()
{ 
	return GetTblCopyTo()->DeleteRecord(); 
}

void CDataHandler::DeleteRecords(DWORD dwFilterType)
{ 
	GetTblCopyTo()->DeleteRecords(dwFilterType); 
}

BOOL CDataHandler::FindMatchByUI()	
{ 
	return GetTblCopyTo()->FindFirst(fltUniqueIndex); 
}

bool CDataHandler::SetUniqueName()
{
	class CMakeCopyName : public IStringIterator
	{
		const int m_nInstance;
	public:
		CMakeCopyName(int nInstance) : m_nInstance(nInstance) {}
		virtual bool VisitString(wstring& str) const
		{
			MakeCopyName(str, m_nInstance);
			return true;
		}
	};

	CTableHolder tempHolder;
	tempHolder.SetDBManager(GetTblCopyHelper()->GetHolderTo()->GetDBManager());
	CDBTable* pTblTemp = NULL;
	if(!HandleCreateTable(GetCopyTableId(), pTblTemp, &tempHolder))
		return false;
	int nInstance = -1;
	pTblTemp->CopyDataFromTable(GetTblCopyTo());
	while(pTblTemp->FindFirst(fltUniqueIndex))
	{
		pTblTemp->CopyDataFromTable(GetTblCopyTo());
		if(!pTblTemp->IterateThruStrings(CMakeCopyName(++nInstance), fltUniqueIndex))
			return false;
	}
	if(nInstance != -1)
	{
		CMakeCopyName makeName(nInstance);
		GetTblCopyTo()->IterateThruStrings(makeName, fltUniqueIndex);
	}
	return true;
}

CDBTable* CDataHandler::GetTblCopyTo()
{
	return HandleCreateTable(
		GetCopyTableId(),
		m_pTblCopyTo,
		GetTblCopyHelper()->GetHolderTo());
}

CDataProvider* CDataHandler::GetDataProvider()
{
	if(!m_pDataProvider)
	{
		CTblCopyHelper* pTblCopyHelper = GetTblCopyHelper();
		if(pTblCopyHelper)
		{
			CDataHandlerKey key(GetCopyTableId());
			CSetDataProviders::const_iterator iter 
				= pTblCopyHelper->m_DataProviders.find(static_cast<CDataProvider*>(&key));
			if(iter != pTblCopyHelper->m_DataProviders.end())
			{
				m_pDataProvider = *iter;
				SetCopyTableId(m_pDataProvider, GetCopyTableId());
			}
			else if(m_ProviderCreateFunc)
			{
				m_pDataProvider = m_ProviderCreateFunc();
				if(m_pDataProvider)
				{
					m_pDataProvider->SetParameters(pTblCopyHelper, GetCopyTableId());
					pTblCopyHelper->m_DataProviders.insert(m_pDataProvider);
				}
			}
		}
	}
	CHECK_ADDRESS(m_pDataProvider);
	return m_pDataProvider;
}


void CDataHandler::FreeStatements()							{ GetDataProvider()->FreeStatements(); }
BOOL CDataHandler::FindNextFrom()						{ return GetDataProvider()->FindNextFrom(); }
BOOL CDataHandler::FindByPrimaryKeyFrom(Identity lId)	{ return GetDataProvider()->FindByPrimaryKeyFrom(lId); }
Identity CDataHandler::GetFieldFrom(size_t nOffset) const		
	{ return GetDataProvider()->GetFieldFrom(nOffset); }
void CDataHandler::SetFieldFrom(size_t nOffset, Identity lId)		
	{ GetDataProvider()->SetFieldFrom(nOffset, lId); }
BOOL CDataHandler::FindFirstFrom(DWORD dwFilterType){ return GetDataProvider()->FindFirstFrom(dwFilterType); }
Identity CDataHandler::GetPrimaryKeyFrom()					{ return GetDataProvider()->GetPrimaryKeyFrom(); }
void CDataHandler::CopyData(bool bCopyPK)				{ GetDataProvider()->CopyData(bCopyPK); }


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

void CGenericDataProvider::FreeStatements() 
{ 
	GetTblCopyFrom()->FreeStatements(); 
}

BOOL CGenericDataProvider::FindNextFrom()		
{ 
	return GetTblCopyFrom()->FindNext(); 
}

BOOL CGenericDataProvider::FindByPrimaryKeyFrom(Identity lId) 
{ 
	return GetTblCopyFrom()->FindByPrimaryKey(lId); 
}

CDBTable* CGenericDataProvider::GetTblCopyFrom()
{ 
	return HandleCreateTable(
		GetCopyTableId(),
		m_pTblCopyFrom,
		GetTblCopyHelper()->GetHolderFrom());
}

Identity CGenericDataProvider::GetFieldFrom(size_t nOffset) const
{
	return GetIdentityValue(GetTblCopyFrom(), nOffset);
}

void CGenericDataProvider::SetFieldFrom(size_t nOffset, Identity lId)
{
	SetIdentityValue(GetTblCopyFrom(), nOffset, lId);
}

BOOL CGenericDataProvider::FindFirstFrom(DWORD dwFilterType)
{
	return GetTblCopyFrom()->FindFirst(dwFilterType);
}

Identity CGenericDataProvider::GetPrimaryKeyFrom()
{
	return GetTblCopyFrom()->GetPrimaryKey();
}

void CGenericDataProvider::CopyData(bool bCopyPK)
{
	GetTblCopyTo()->CopyDataFromTable(GetTblCopyFrom(), bCopyPK);
}