a

2026-07-03 16:05:30 +08:00
commit df489d5640
1101 changed files with 779140 additions and 0 deletions
@@ -0,0 +1,143 @@
+#pragma once
+#include <Windows.h>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+template<typename Data>
+class ConcurrentList
+{
+public:
+	ConcurrentList()
+	{
+		m_hMetex =  ::CreateMutex(NULL, FALSE, NULL);
+		m_semaMsgNum = CreateSemaphore(NULL,0,1,NULL);
+	}
+	~ConcurrentList()
+	{
+		 ::CloseHandle(m_hMetex);
+	}
+
+	void push_front(Data const &data)
+	{
+		WaitForSingleObject(m_hMetex, INFINITE);
+
+		if(IsExist(data))
+		{
+			 ::ReleaseMutex(m_hMetex);
+			return;
+		}
+
+		if(m_vector.empty())
+		{
+			m_vector.push_back(data);
+		}
+		else
+		{
+			m_vector.insert(m_vector.begin(),data);
+		}
+		::ReleaseMutex(m_hMetex);
+
+		ReleaseSemaphore(m_semaMsgNum ,  1,  NULL);
+	}
+
+	void push_back(Data const& data)  
+	{  
+		WaitForSingleObject(m_hMetex, INFINITE);
+		if (IsExist(data))
+		{
+			::ReleaseMutex(m_hMetex);
+			return;
+		}
+
+		m_vector.push_back(data);
+		::ReleaseMutex(m_hMetex);
+		ReleaseSemaphore(m_semaMsgNum ,  1,  NULL);
+	}
+	bool erase(Data const&popped_value)  
+	{  
+		WaitForSingleObject(m_hMetex, INFINITE);
+		if (m_vector.empty())
+		{  
+			::ReleaseMutex(m_hMetex);
+			return true;  
+		}  
+
+		std::vector<Data>::iterator itFind = find(m_vector.begin(),m_vector.end(),popped_value);
+		if(itFind == m_vector.end())
+		{
+			::ReleaseMutex(m_hMetex);
+			return true;
+		}
+
+		m_vector.erase(itFind);  
+		::ReleaseMutex(m_hMetex);
+		return true;  
+	}
+
+// 	bool empty() 
+// 	{  
+// 		boost::recursive_mutex::scoped_lock lock(m_mutex);
+// 		return m_vector.empty();
+// 	}    
+
+	bool PopFront( Data& dataValue )  
+	{  
+		WaitForSingleObject(m_hMetex, INFINITE);
+		if (!m_vector.empty())
+		{  
+			dataValue=m_vector[0];  
+			m_vector.erase(m_vector.begin());
+			::ReleaseMutex(m_hMetex);
+			return true;
+		}
+
+		::ReleaseMutex(m_hMetex);
+		return false;
+	}  
+
+	void wait_and_pop(Data& popped_value)  
+	{  
+		while (m_vector.empty())
+		{ 
+			WaitForSingleObject(m_semaMsgNum, INFINITE);
+		} 
+		WaitForSingleObject(m_hMetex, INFINITE);
+		popped_value=m_vector[0];  
+		m_vector.erase(m_vector.begin());
+		::ReleaseMutex(m_hMetex);
+	}  
+
+// 	Data& get_data(int iIndex)
+// 	{
+// 		boost::recursive_mutex::scoped_lock lock(m_mutex);
+// 		return m_vector[iIndex];
+// 	}
+
+	int get_size()
+	{
+		WaitForSingleObject(m_hMetex, INFINITE);
+		int iSize = m_vector.size();
+		::ReleaseMutex(m_hMetex);
+		return iSize;
+	}
+// 
+// 	void clear()
+// 	{
+// 		boost::recursive_mutex::scoped_lock lock(m_mutex);
+// 		return m_vector.clear();
+// 	}
+
+protected:  
+	bool IsExist(Data const& data)
+	{
+		if(m_vector.end () == find(m_vector.begin(),m_vector.end(),data) )
+			return false;
+
+		return true;
+	}
+protected:  
+	vector<Data>         m_vector;  
+	HANDLE               m_hMetex;
+	HANDLE               m_semaMsgNum;
+};
@@ -0,0 +1,62 @@
+// NetRequestDialog.cpp : 实现文件
+//
+
+#include "stdafx.h"
+#include "GeoMative.h"
+#include "NetRequestDialog.h"
+#include "afxdialogex.h"
+extern CGeoMativeApp theApp;
+
+// CNetRequestDialog 对话框
+
+IMPLEMENT_DYNAMIC(CNetRequestDialog, CDialog)
+
+CNetRequestDialog::CNetRequestDialog(UINT nIDTemplate,CWnd* pParent /*=NULL*/)
+: CDialog(nIDTemplate, pParent)
+{
+
+}
+
+CNetRequestDialog::~CNetRequestDialog()
+{
+}
+
+void CNetRequestDialog::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+}
+
+
+BEGIN_MESSAGE_MAP(CNetRequestDialog, CDialog)
+	ON_MESSAGE(WM_NET_RESPONSE, OnNetResponse)
+END_MESSAGE_MAP()
+
+
+// CNetRequestDialog 消息处理程序
+
+LRESULT CNetRequestDialog::OnNetResponse(WPARAM wParam, LPARAM lParam)
+{
+	PreNetResponse(wParam, lParam);
+	return 0;
+}
+
+void CNetRequestDialog::PostNetRequest(BYTE cmd, HWND hwnd, char* pData, WORD dataLen, int maxRecvLen/* = MAX_RECV_MEASURE*/, DWORD msgID /*= WM_NET_RESPONSE*/, UINT32 deviceID /*= 0xFFFFFFFF*/, BYTE deviceType/* = EN_DEV_CLOUND*/, int timeout/* = 5000*/)
+{
+	ST_REQUEST_PACKET stRequest;
+	stRequest.clsPacketBase.ucCmd = cmd;
+	stRequest.clsPacketBase.uiDevID = deviceID;
+	stRequest.clsPacketBase.ucDevType = deviceType;
+	stRequest.hWnd = hwnd;
+	stRequest.dwMsgID = msgID;
+	stRequest.iMaxRecvLen = maxRecvLen;
+	stRequest.iTimeout = timeout;
+	stRequest.wDataLen = dataLen;
+	stRequest.pData = new char[stRequest.wDataLen];
+	memcpy(stRequest.pData, pData, stRequest.wDataLen);
+	theApp.m_NetWorkOper.PutRequestPacket(stRequest);
+	if (stRequest.pData != NULL)
+	{
+		delete[] stRequest.pData;
+		stRequest.pData = NULL;
+	}
+}
@@ -0,0 +1,33 @@
+#ifndef NET_REQUEST_DIALOG_H_20181120
+#define NET_REQUEST_DIALOG_H_20181120
+#pragma once
+
+
+// CNetRequestDialog 对话框
+
+class CNetRequestDialog : public CDialog
+{
+	DECLARE_DYNAMIC(CNetRequestDialog)
+
+public:
+	CNetRequestDialog(UINT nIDTemplate, CWnd* pParent = NULL);   // 标准构造函数
+	virtual ~CNetRequestDialog();
+
+// 对话框数据
+	enum { IDD = IDD_NETREQUESTDIALOG };
+
+	afx_msg LRESULT OnNetResponse(WPARAM wParam, LPARAM lParam);
+
+	void PostNetRequest(BYTE cmd, HWND hwnd, char* pData, WORD dataLen, int maxRecvLen = MAX_RECV_MEASURE, DWORD msgID = WM_NET_RESPONSE, UINT32 deviceID = 0xFFFFFFFF, BYTE deviceType = EN_DEV_CLOUND, int timeout = 5000);
+
+protected:
+
+	virtual void PreNetResponse(WPARAM wParam, LPARAM lParam) = 0;
+
+protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
+
+	DECLARE_MESSAGE_MAP()
+};
+
+#endif
@@ -0,0 +1,228 @@
+#include "stdafx.h"
+#include "StdThread.h"
+#include <process.h>
+
+
+ProducerThread::ProducerThread()
+{
+	m_bEngineRunning = false;
+	m_hHandle = NULL;
+}
+
+ProducerThread::~ProducerThread(void)
+{
+	StopThread();
+}
+
+
+bool ProducerThread::StartThread()
+{
+	if ( !m_bEngineRunning && m_hHandle == NULL )
+	{		
+		m_hHandle = (HANDLE)_beginthreadex(NULL,0,TheThread,this,0,NULL);
+		if ( m_hHandle != NULL )
+		{
+			int  nWaitTime = 0; 
+			while (!m_bEngineRunning && nWaitTime < 3000)
+			{
+				Sleep(10);
+				nWaitTime = nWaitTime + 10;
+			}
+		}
+	}
+	return m_bEngineRunning;
+}
+
+
+bool ProducerThread::StopThread()
+{
+	if ( m_bEngineRunning )
+	{
+		m_bEngineRunning = false;
+		WaitForSingleObject(m_hHandle,INFINITE);
+	}
+	return true;
+}
+
+unsigned int ProducerThread::TheThread(void *pParam)
+{
+	ProducerThread *pThis = (ProducerThread *)pParam;
+	pThis->m_bEngineRunning = true;
+	pThis->ThreadFunction();
+	return 0;
+}
+
+
+ConsumerThread::ConsumerThread()
+{
+	m_bEngineRunning = false;
+	m_hHandle = NULL;
+}
+
+ConsumerThread::~ConsumerThread(void)
+{
+	StopThread();
+}
+
+
+bool ConsumerThread::StartThread()
+{
+	if (!m_bEngineRunning && m_hHandle == NULL)
+	{
+		m_hHandle = (HANDLE)_beginthreadex(NULL,0,TheThread,this,0,NULL);
+		if (m_hHandle != NULL)
+		{
+			int  nWaitTime = 0;
+			while (!m_bEngineRunning && nWaitTime < 3000)
+			{
+				Sleep(10);
+				nWaitTime = nWaitTime + 10;
+			}
+		}
+	}
+	return m_bEngineRunning;
+}
+
+
+bool ConsumerThread::StopThread()
+{
+	if ( m_bEngineRunning )
+	{
+		m_bEngineRunning = false;
+		m_queData.push_back( NULL );
+		WaitForSingleObject(m_hHandle,INFINITE);
+
+		void* pData = NULL;
+		while( m_queData.PopFront( pData ) )
+		{
+			if ( pData != NULL )
+			{
+				ReleaseData(pData);
+			}
+		}
+
+		m_hHandle = NULL;
+	}
+	return true;
+}
+
+void ConsumerThread::PutDataToQue( void * pData  ) 
+{
+	m_queData.push_back( pData );
+}
+
+unsigned int ConsumerThread::TheThread(void *pParam)
+{
+	ConsumerThread *pThis = (ConsumerThread *)pParam;
+	pThis->m_bEngineRunning = true;
+
+	while ( pThis->m_bEngineRunning )
+	{
+		void* pData = NULL;
+
+		pThis->m_queData.wait_and_pop( pData );
+		if ( pData != NULL )
+		{
+			pThis->ConsumeDataFromQue( pData );
+			pThis->ReleaseData( pData );
+		}
+		else
+		{
+			break;
+		}
+	}
+	return 0;
+}
+
+
+
+
+
+
+MultiConsumerThread::MultiConsumerThread()
+{
+	m_bEngineRunning = false;
+	m_vecHandle.clear();
+}
+
+MultiConsumerThread::~MultiConsumerThread(void)
+{
+	StopThread();
+}
+
+
+bool MultiConsumerThread::StartThread(int iThread)
+{
+	for(int i = 0;i < iThread ; ++i)
+	{
+		HANDLE hHandle = (HANDLE)_beginthreadex(NULL,0,TheThread,this,0,NULL);
+
+		if (hHandle != NULL)
+		{
+			m_vecHandle.push_back(hHandle);
+		}
+	}
+
+	return m_bEngineRunning;
+}
+
+
+bool MultiConsumerThread::StopThread()
+{
+	if ( m_bEngineRunning )
+	{
+		m_bEngineRunning = false;
+
+		int iSize = m_vecHandle.size();
+		for(int i = 0; i < iSize; ++i)
+		{
+			m_queData.push_back( NULL );
+		}
+		
+		vector<HANDLE>::iterator iterCur = m_vecHandle.begin();
+		vector<HANDLE>::iterator iterEnd = m_vecHandle.end();
+		for(;iterCur != iterEnd; ++iterCur)
+		{
+			WaitForSingleObject(*iterCur,INFINITE);
+			CloseHandle(*iterCur);
+		}
+
+		void* pData = NULL;
+		while( m_queData.PopFront( pData ) )
+		{
+			if ( pData != NULL )
+			{
+				ReleaseData(pData);
+			}
+		}
+	}
+	return true;
+}
+
+void MultiConsumerThread::PutDataToQue( void * pData  ) 
+{
+	m_queData.push_back( pData );
+}
+
+unsigned int MultiConsumerThread::TheThread(void *pParam)
+{
+	MultiConsumerThread *pThis = (MultiConsumerThread *)pParam;
+	pThis->m_bEngineRunning = true;
+
+	while ( pThis->m_bEngineRunning )
+	{
+		void* pData = NULL;
+
+		pThis->m_queData.wait_and_pop( pData );
+		if ( pData != NULL )
+		{
+			pThis->ConsumeDataFromQue( pData );
+			pThis->ReleaseData( pData );
+		}
+		else
+		{
+			break;
+		}
+	}
+	return 0;
+}
@@ -0,0 +1,80 @@
+#pragma once
+#include "ConcurrentList.h"
+
+class ProducerThread
+{
+public:
+	virtual bool StartThread();
+	virtual bool StopThread();
+
+protected:
+	ProducerThread();
+	virtual ~ProducerThread();
+
+protected:
+	virtual void ThreadFunction() = 0;
+
+private:
+	static unsigned int __stdcall TheThread(void *pParam);
+
+protected:
+	bool  m_bEngineRunning;
+	HANDLE m_hHandle;
+
+};
+
+class ConsumerThread
+{
+public:
+	virtual bool StartThread();
+	virtual bool StopThread();
+
+protected:
+	ConsumerThread();
+	virtual ~ConsumerThread();
+
+	void PutDataToQue(void * pData);
+
+	virtual void ReleaseData( void* pData ) = 0;
+
+	virtual void ConsumeDataFromQue( void * pData ) = 0;
+
+private:
+	static unsigned int __stdcall TheThread(void *pParam);
+
+protected:
+	ConcurrentList<void*>    m_queData; 
+ 
+private:
+	bool  m_bEngineRunning;
+    HANDLE m_hHandle;
+};
+
+
+class MultiConsumerThread
+{
+public:
+	virtual bool StartThread(int iThread);
+	virtual bool StopThread();
+
+protected:
+	MultiConsumerThread();
+	virtual ~MultiConsumerThread();
+
+	void PutDataToQue(void * pData);
+
+	virtual void ReleaseData( void* pData ) = 0;
+
+	virtual void ConsumeDataFromQue( void * pData ) = 0;
+
+private:
+	static unsigned int __stdcall TheThread(void *pParam);
+
+protected:
+	ConcurrentList<void*>    m_queData; 
+
+private:
+	bool  m_bEngineRunning;
+	vector<HANDLE> m_vecHandle;
+
+};