void				GetNextItem(
		POSITION				&ItemPosition, 
		OPCHANDLE				&hItem, 
		COPCDrvItem				*&pItem
		);										// Returns the next Item in the 
												// group relative to POSITION

	HRESULT				FreeAllItems(
		void
		);										// free all of the items in the group


	// Read/write and update functions
	void				GroupProcess(
		DWORD					dwTics
		);

	void				AsyncProcess(
		void
		);
	
	void				UpdateDataCache(
		void
		);

	void				CheckDataObjectOnDataTimeChange(
		void
		);
	
	void				CheckDataObjectOnDataChange(
		void
		);

	void				CheckDataObjectAsyncRead(
		void
		);
	
	void				CheckDataObjectAsyncWrite(
		void
		);
	
	void				SendStreamWithTime(
		int						nCount, 
		OPCHANDLE				*pItemHandleList, 
		DWORD					dwSize, 
		WORD					wMask, 
		DWORD					dwTid,
		OPCDATASOURCE			dwSource = OPC_DS_DEVICE
		);
	
	void				SendStream(
		int						nCount, 
		OPCHANDLE				*pItemHandleList, 
		DWORD					dwSize, 
		WORD					wMask, 
		DWORD					dwTid,
		OPCDATASOURCE			dwSource = OPC_DS_DEVICE
		);
	
	void				SendWriteStream(
		int						nCount, 
		OPCHANDLE				*pItemHandleList, 
		DWORD					dwTid
		);
	
	long				ComputeSize(
		int						nCount, 
		OPCHANDLE				*pItemHandleList
		);

	// for thread safety (just in case)
	//
	void		Lock  (void) { EnterCriticalSection(&this->m_Lock); }
	void		UnLock(void) { LeaveCriticalSection(&this->m_Lock); }


private:
	// Member Variables
	//
    long						m_lRefCount;		// Internal reference count
	LPUNKNOWN					m_pUnkOuter;		// Pointer to controlling IUnknown
	COPCDrvServer				*m_pParentServer;	// Pointer to parent server
	DWORD						m_dwRevisedRate;	// refresh rate
	FLOAT						m_Deadband;			// Percent deadband
	DWORD						m_LCID;
	LONG						m_TimeBias;
	BOOL						m_bActive;			// Status of this group
	WCHAR						*m_szName;
	OPCHANDLE					m_ServerGroupHandle;
	OPCHANDLE					m_ClientGroupHandle;

	CImpIOPCGroupStateMgt		*m_pCImpIGroupMgt;	// Group State Mgt
	CImpIOPCSyncIO				*m_pCImpISyncIO;	// Sync IO
	CImpIOPCAsyncIO				*m_pCImpIAsyncIO;	// Async IO
	CImpIOPCItemMgt				*m_pCImpIItemMgt;	// Item Mgt
	CImpIDataObject				*m_pCImpIDataObject;// Data Object

	// For managing update rate
	//
	long						m_lUpdateTime;

	// Used to keep track of the Items in this group
	DWORD						m_dwNumItems;

	DWORD						m_dwAdvfDataFlags,
								m_dwAdvfDataTimeFlags;

	// for thread safety (just in case)
	//
	CRITICAL_SECTION			m_Lock;

	// List of Items
	//
	CMap<OPCHANDLE, OPCHANDLE, COPCDrvItem*, COPCDrvItem*&> m_mapItem;

	// Marshalled AdviseSink interface pointers
	//
	IAdviseSink*				m_pdatatimeSink;
	IAdviseSink*				m_pdataSink;
	IAdviseSink*				m_pwriteSink;

public:
	// Async queues
	//
	CObList						m_AsyncWriteQueue;
	CObList						m_AsyncReadQueue;
};


/////////////////////////////////////////////////////////////////////////////
// COPCDrvItem object
//
// This class is an implementation of a specific Item Class.
// This implementation does NOT represent a required OPC object or interface.
// It is used to simplify the storing and updating of data. We derive both
// from IUnknown and CObject
//
/////////////////////////////////////////////////////////////////////////////
class COPCDrvItem :		public IUnknown,
						public CObject
{
	friend class COPCDrvServer;
	friend class COPCDrvGroup;
	friend class CImpIOPCSyncIO;
	friend class CImpIOPCAsyncIO;
	friend class CImpIDataObject;
  

public:
	COPCDrvItem(COPCDrvGroup *ParentGroup);
	~COPCDrvItem(void);

	// the IUnknown Functions
	STDMETHODIMP         QueryInterface(
		REFIID				iid, 
		LPVOID				*ppInterface
		);
	
	STDMETHODIMP_(ULONG) AddRef(
		void
		);
	
	STDMETHODIMP_(ULONG) Release(
		void
		);

	// Operator overloads
	COPCDrvItem &		operator=(
		const COPCDrvItem	&OtherItem
		);

	// Member Utility Functions (Note these are NOT an OPC required interface!)
	HRESULT				Init(
		int					j, 
		OPCITEMDEF			*ItemDef, 
		OPCITEMRESULT		*ItemRes
		);
	
	void				SetActive(
		BOOL				bActive
		);
	
	BOOL				GetActive(void)
		{ return this->m_bActive; }		// Returns the active state of the item
	
	void				SetHandle(
		OPCHANDLE			hClient
		);
	
	OPCHANDLE			GetHandle(
		void
		);
	
	HRESULT				SetDatatype(
		VARTYPE				vtNewType,
		BOOL				bInit = FALSE
		);
	
	VARTYPE				GetDatatype(
		void
		);
	
	COPCDrvItem	*		Clone(
		COPCDrvGroup		*newparent
		);
	
	void				IAGet(
		OPCITEMATTRIBUTES	*pIA
		);
	
	HRESULT				GetValue(
		OPCDATASOURCE		ds, 
		VARIANT				*vReadData, 
		WORD				*w, 
		FILETIME			*ftLastRead
		);
	
	HRESULT				WriteValue(
		VARIANT				*vWriteData
		);
	
	void				UpdateDataCache(
		void
		);

	void				ReadValue(
		void
		);
	
	BOOL				CheckDeviceRead(
		HRESULT				*hr
		);
	
	BOOL				CheckDeviceWrite(
		HRESULT				*hr
		);
	
	void				MarkAsChanged(
		WORD				wFlag
		);
	
	void				ClearChanged(
		WORD				wFlag
		);
	
	BOOL				Changed(
		WORD				wFlag
		);

	int					GetDataSize(
		void
		);

	void		Lock  (void) { EnterCriticalSection(&this->m_Lock); }
	void		UnLock(void) { LeaveCriticalSection(&this->m_Lock); }

public:
	//
	// Public members
	//

	// DMACS specific structures
	IODNAME			m_IodName;
	IOREC			m_IoRec;
	IOREC2			m_IoRec2;
	IOVSPEC			m_IovSpec;
	
	AEGUREC			m_AEguRec;
	DEGUREC			m_DEguRec;
	EGUREC			m_EguRec;

	IOSTAT			m_IoStat;

private:
	// Member Variables
	long			m_lRefCount;
	COPCDrvGroup	*m_pParentGroup;		// The group that owns this item

	OPCHANDLE		m_hServerItemHandle;	// Item generated handle used internally
	OPCHANDLE		m_hClientItemHandle;	// Client's handle

	VARTYPE			m_vtCanonical;			// Canonical data type (returned by driver)
	WCHAR			*m_szItemID;			// Item ID (ex "ITK:D1:5|LIN,0,100,Unsigned")
	WCHAR			*m_szAccessPath;		// Access path (not used)
	VARTYPE			m_vtRequested;			// Requested data type
	BOOL			m_bActive;

	VARIANT			m_vReturnedData;		// Data read from NIO
	WORD			m_wQuality;				// Data quality for this item
	FILETIME		m_ftLastWriteTime,		// used for last write
					m_ftLastReadTime;		// used for last read

	WORD			m_AsyncMask;			// bit mask used by Async operations V2.0

	WORD			m_wNumElements;			// Number of elements to read (used mainly
											// for ASCII strings, VT_BSTR)

	BOOL			m_bLastKnown;			// Flag to indicate if we have a last known 
											// value
	char			*m_pTempBuff;			// Temporary buffer used for string writes

	// Private utility functions
	BOOL				DidDataChange(
		VARIANT				&vNewData,
		WORD				wOldQuality,
		short				nOldIoStatus
		);									// Used to determine if the data has changed
											// for asynchronous reads

	HRESULT				ParseItemIDOptions(
		CString				strItemID,		// signal conditioning portion of ItemID
		CString&			strSigCond,		// returned signal conditioning
		CString&			strLoEGU,		// returned Lo EGU
		CString&			strHiEGU,		// returned Hi EGU
		CString&			strHWOptions	// returned Hardware Options
		);

	short				GetNIOBlockType(
		VARTYPE				vtRequestedDataType
		);									// Saves the NIO block type dependant on
											// the requested datatype

	// for thread safety (just in case)
	CRITICAL_SECTION	m_Lock;
};


/////////////////////////////////////////////////////////////////////////////
// Implementation of an IEnumString Interface for the Server
//
/////////////////////////////////////////////////////////////////////////////
class CImpIEnumString : public IEnumString
{

public:
	CImpIEnumString(LPUNKNOWN, ULONG, LPOLESTR*, IMalloc*);
	~CImpIEnumString(void);

	// the IUnknown Functions
	STDMETHODIMP			QueryInterface(
		REFIID					iid, 
		LPVOID					*ppInterface
		);

	STDMETHODIMP_(ULONG)	AddRef(
		void
		);
	
	STDMETHODIMP_(ULONG)	Release(
		void
		);

	// the IEnumString Functions
	STDMETHODIMP			Next (
		ULONG					Celt,
		LPOLESTR				*pRgelt,
		ULONG					*pCeltFetched
		);
        
	STDMETHODIMP			Skip (
		ULONG					celt
		);
        
	STDMETHODIMP			Reset(
		void
		);
        
	STDMETHODIMP			Clone(
		IEnumString				**ppenum
		);


private:
	// Member Variables
	long					m_lRefCount;		// Object reference count
	LPUNKNOWN				m_pUnkRef;			// IUnknown for ref counting
	ULONG					m_lCurrentElement;	// Current element
	ULONG					m_lNumStrings;		// Number of strings in us
	LPOLESTR				*m_lpOLEStrings;	// copy of the strings
	IMalloc					*m_pIMalloc;		// memory allocator to use
};


/////////////////////////////////////////////////////////////////////////////
//
// Used to manage asyncronous reads, writes and refreshes.
//
/////////////////////////////////////////////////////////////////////////////
class COPCDrvAsyncTrans : public CObject
{
public:
	COPCDrvAsyncTrans(
		COPCDrvGroup	*pParent
		);

	~COPCDrvAsyncTrans(
		);

	// Initialize the transaction
	//
	HRESULT				Init(
		DWORD				dwTransType,
		OPCDATASOURCE		dwReadType,
		DWORD				dwNumHandles,
		OPCHANDLE			*pHandles,
		VARIANT				*pvData = NULL
		);

	// Add the transaction to the parent group's queue
	//
	HRESULT				AddToQueue(
		void
		);

	// Remove the transaction from the parent group's queue
	//
	HRESULT				RemoveFromQueue(
		BOOL				bDelete = FALSE
		);

	// Return the transaction ID
	//
	DWORD				GetTransactionID(
		void
		)	{ return m_dwTransactionID; }

	// Return a pointer to the handle list
	//
	OPCHANDLE *			GetHandleList(
		void
		)	{ return m_pHandleList; }

	// Return a pointer to the data list
	//
	VARIANT	*			GetDataList(
		void
		)	{ return m_pvWriteData; }

	// Return the number of handles
	//
	DWORD				GetNumHandles(
		void
		)	{ return m_dwNumHandles; }

	// Return info about the transaction
	//
	HRESULT				GetListInfo(
		DWORD				*dwNum,
		OPCHANDLE			**ppdwList,
		VARIANT				**ppvList = NULL
		)	{ *dwNum = m_dwNumHandles; *ppdwList = m_pHandleList;
			  if (ppvList) *ppvList = m_pvWriteData; return S_OK; }

	// Cancel the pending transaction
	//
	HRESULT				Cancel(
		void
		)	{ return RemoveFromQueue(TRUE); }

private:
	COPCDrvGroup	*m_pParentGroup;
	POSITION		m_PosInList;
	DWORD			m_dwTransactionID;
	DWORD			m_dwNumHandles;
	OPCHANDLE		*m_pHandleList;
	VARIANT			*m_pvWriteData;

public:
	// Public properties. These shouldn't be set directly!!
	//
	DWORD			m_dwTransType;
	OPCDATASOURCE	m_dwReadType;
};


#endif	// OPCDrv__H__