//	OPCDrvGroup.cpp
//
//  This file contains the implementation of the Group object.
//
//
//	(c) COPYRIGHT 1996-1998, INTELLUTION INC.
// ALL RIGHTS RESERVED
//
//
//	Functions defined in this module:
//
//			COPCDrvGroup::COPCDrvGroup()
//			COPCDrvGroup::~COPCDrvGroup()
//			COPCDrvGroup::AddRef()
//			COPCDrvGroup::Release()
//			COPCDrvGroup::QueryInterface()
//			COPCDrvGroup::operator=()
//			COPCDrvGroup::SetActive()
//			COPCDrvGroup::GetActive()
//			COPCDrvGroup::SetUpdateRate()
//			COPCDrvGroup::GetUpdateRate()
//			COPCDrvGroup::GetItemList()
//			COPCDrvGroup::FreeItemList()
//			COPCDrvGroup::GroupProcess()
//			COPCDrvGroup::UpdateDataCache()
//
//
//
// Modification Log:
//	Vers	Date     By		Notes
//	----	-------- ---	-----
//	1.0		08/26/97 jra	Created
//	1.3		03/10/98 jra	Modified to be wizard generated and driver specific.
//
//

#define WIN32_LEAN_AND_MEAN

#include "OpcStdAfx.h"
#include "OPCDrv.h"


/////////////////////////////////////////////////////////////////////////////
// External declarations
//
extern DWORD g_dwWaitPeriod;


/////////////////////////////////////////////////////////////////////////////
// Constructor /Destructor functions
//

////////////////////////////////////////////////////////////////
// OPCGroup()
//
// Constructor for the OPC Group object.
//
////////////////////////////////////////////////////////////////
COPCDrvGroup::COPCDrvGroup(LPUNKNOWN pUnkOuter)
{
	m_lRefCount				= 0;

	// Record Parent server
	//
	m_pParentServer			= (COPCDrvServer *)pUnkOuter;
	m_pUnkOuter				= pUnkOuter;

	// Initizlize member variables
	//
	m_ServerGroupHandle		= 0;
	m_ClientGroupHandle		= 0;
	m_dwRevisedRate			= 0;
	m_bActive				= FALSE;
	m_szName				= 0;
	m_LCID					= 0;
	m_Deadband				= 0;
	m_TimeBias				= 0;

	// Clear out 'tear-off' interface ptrs
	// The interfaces will be created as needed in QueryInterface
	//
	m_pCImpIGroupMgt		= NULL;
	m_pCImpISyncIO			= NULL;
	m_pCImpIAsyncIO			= NULL;
	m_pCImpIItemMgt			= NULL;
	m_pCImpIDataObject		= NULL;

	m_lUpdateTime			= 0;

	m_dwNumItems			= 0;

	m_pdatatimeSink			= NULL;
	m_pdataSink				= NULL;
	m_pwriteSink			= NULL;

	m_dwAdvfDataFlags		= 0;
	m_dwAdvfDataTimeFlags	= 0;

	// Initialize the table to a prime number for the Item map
	m_mapItem.InitHashTable(31);

	InitializeCriticalSection(&this->m_Lock);
}


////////////////////////////////////////////////////////////////
// ~COPCDrvGroup()
//
// Destructor for the OPC Group object.
//
////////////////////////////////////////////////////////////////
COPCDrvGroup::~COPCDrvGroup(void)
{
	// Lock out this group
	//
	this->Lock();

	// Free memory associated with group name
	//
	if(m_szName)
	{
		WSTRFree(m_szName, NULL);
	}

	// Delete all the Group level tear off interfaces
	//
	if(m_pCImpIGroupMgt) 
	{
		delete m_pCImpIGroupMgt;
	}
	if(m_pCImpISyncIO) 
	{
		delete m_pCImpISyncIO;
	}
	if(m_pCImpIAsyncIO) 
	{
		delete m_pCImpIAsyncIO;
	}
	if(m_pCImpIItemMgt) 
	{
		delete m_pCImpIItemMgt;
	}
	if(m_pCImpIDataObject) 
	{
		delete m_pCImpIDataObject;
	}

	// If there is anything in either of the async queues, clear them out
	//
	POSITION posTrans;
	COPCDrvAsyncTrans *pTrans;

	posTrans = m_AsyncWriteQueue.GetHeadPosition();
	while (posTrans != NULL)
	{
		pTrans = (COPCDrvAsyncTrans *)m_AsyncWriteQueue.GetNext(posTrans);
		pTrans->RemoveFromQueue(TRUE);
	}

	posTrans = m_AsyncReadQueue.GetHeadPosition();
	while (posTrans != NULL)
	{
		pTrans = (COPCDrvAsyncTrans *)m_AsyncReadQueue.GetNext(posTrans);
		pTrans->RemoveFromQueue(TRUE);
	}

	// Also free any memory associated with the ITEMS
	//
	this->FreeAllItems();

	this->UnLock();
	DeleteCriticalSection(&this->m_Lock);
}


/////////////////////////////////////////////////////////////////////////////
// IUnknown functions
//

////////////////////////////////////////////////////////////////
// IUnknown::AddRef()
//
// Standard IUnknown implementation
//
////////////////////////////////////////////////////////////////
STDMETHODIMP_(ULONG) COPCDrvGroup::AddRef( void)
{
	InterlockedIncrement(&m_lRefCount);
	return m_pUnkOuter->AddRef();
}


////////////////////////////////////////////////////////////////
// IUnknown::Release()
//
// Standard IUnknown implementation
//
////////////////////////////////////////////////////////////////
STDMETHODIMP_(ULONG) COPCDrvGroup::Release( void)
{
	ASSERT(0 != m_lRefCount);

	DWORD		dwCurrentCount	= InterlockedDecrement(&m_lRefCount);
	LPUNKNOWN	pUnkOuter		= m_pUnkOuter;


	// If no references left for this group
	if (dwCurrentCount == 0)
	{
		// Then delete this group.
		delete this;
	}

	pUnkOuter->Release();
	return dwCurrentCount;
}


////////////////////////////////////////////////////////////////
// IUnknown::QueryInterface()
//
// Standard IUnknown implementation
//
////////////////////////////////////////////////////////////////
STDMETHODIMP COPCDrvGroup::QueryInterface(REFIID		iid, 
										  LPVOID		*ppInterface)
{
	// Make sure that we got a good pointer
	//
	if (NULL == ppInterface)
	{
		return E_INVALIDARG;
	}

	// IUnknown
	if (iid == IID_IUnknown)
	{
		*ppInterface = (IUnknown *) this;
	}
	// IOPCGroupStateMgt
	else if (iid == IID_IOPCGroupStateMgt)
	{
		if(NULL == m_pCImpIGroupMgt)
		{
			m_pCImpIGroupMgt = new CImpIOPCGroupStateMgt(this);
		}
		
		// Make sure that we got the memory from the system
		if (NULL == m_pCImpIGroupMgt)
		{
			return E_OUTOFMEMORY;
		}
		*ppInterface = m_pCImpIGroupMgt;
	}
	// IOPCSyncIO
	else if (iid == IID_IOPCSyncIO)
	{
		if(NULL == m_pCImpISyncIO)
		{
			m_pCImpISyncIO = new CImpIOPCSyncIO(this) ;
		}

		// Make sure that we got the memory from the system
		if (NULL == m_pCImpISyncIO)
		{
			return E_OUTOFMEMORY;
		}
		*ppInterface = m_pCImpISyncIO;
	}
	// IOPCAsyncIO
	else if (iid == IID_IOPCAsyncIO)
	{
		if(NULL == m_pCImpIAsyncIO)
		{
			m_pCImpIAsyncIO = new CImpIOPCAsyncIO(this) ;
		}

		// Make sure that we got the memory from the system
		if (NULL == m_pCImpIAsyncIO)
		{
			return E_OUTOFMEMORY;
		}
		*ppInterface = m_pCImpIAsyncIO;
	}
	// IOPCItemMgt
	else if (iid == IID_IOPCItemMgt)
	{
		if(NULL == m_pCImpIItemMgt)
		{
			m_pCImpIItemMgt = new CImpIOPCItemMgt(this) ;
		}

		// Make sure that we got the memory from the system
		if (NULL == m_pCImpIItemMgt)
		{
			return E_OUTOFMEMORY;
		}
		*ppInterface = m_pCImpIItemMgt;
	}
	// IDataObject
	else if (iid == IID_IDataObject)
	{
		if (NULL == m_pCImpIDataObject)
		{
			m_pCImpIDataObject = new CImpIDataObject(this);
		}

		// Make sure that we got the memory from the system
		if (NULL == m_pCImpIDataObject)
		{
			return E_OUTOFMEMORY;
		}
		*ppInterface = m_pCImpIDataObject;
	}
	// No interface available
	else
	{
		*ppInterface = NULL;
	}
	
	if (NULL == *ppInterface)
	{
		return E_NOINTERFACE;
	}

	// Addref the group for each tear off interface created.
	//
	((LPUNKNOWN)*ppInterface)->AddRef();
	return S_OK;
}


////////////////////////////////////////////////////////////////
// COPCDrvGroup::operator=()
//
// Overloaded equal operator for the group object
//
// Returns:
//	COPCDrvGroup &	Reference to the object
//
////////////////////////////////////////////////////////////////
COPCDrvGroup & COPCDrvGroup::operator=(const COPCDrvGroup &OtherGroup)
{
	this->m_ClientGroupHandle	= OtherGroup.m_ClientGroupHandle;
	this->m_dwRevisedRate		= OtherGroup.m_dwRevisedRate;
	this->m_TimeBias			= OtherGroup.m_TimeBias;
	this->m_Deadband			= OtherGroup.m_Deadband;
	this->m_LCID				= OtherGroup.m_LCID;

	return *this;
}