Merge branch 'feature/#4528_CF_AOI_Review_Motor_Offset_기능_추가' into develop

KEJ

2023-11-24 9020bfb6f86ff853d5d5b3cee882132a244232da

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/********************************************************************
    created:    2005/03/10
    created:    10:3:2005   15:33
    filename:     E:\Project\무인?ë‹´?œìŠ¤??IOCPNetwork\HMIOCPDefinition.h
    file path:    E:\Project\무인?ë‹´?œìŠ¤??IOCPNetwork
    file base:    HMIOCPDefinition
    file ext:    h
    author:        Chae Hi-myung
    
    purpose:    Á¤Àǵé...
*********************************************************************/
 
#include <winsock2.h>
 
//typedef unsigned long    ULONG_PTR;
 
//#define        MAX_BUFFER_SIZE                8192 * 10
#define        MAX_BUFFER_SIZE                8192 * 1000
#define        SIZE_IOCONTEXT                (sizeof(WSAOVERLAPPED) + sizeof(WSABUF) + (MAX_BUFFER_SIZE + 1) + sizeof(BOOL))
#define        SIZE_SOCKETCONTEXT            16
 
enum NetworkMode { ServerMode, ClientMode};
 
// OVERLAPPED ±¸Á¶Ã¼¸¦ È®Àå
typedef struct _PERIOCONTEXT    // BulkBuffer¸¦ Â©¶ó¼­ reint...Cast Çϱ⠶§¹®¿¡ »ý¼ºÀÚ, ¼Ò¸êÀÚ°¡ È£ÃâµÇÁö ¾Ê´Â´Ù.
{
protected:
    WSAOVERLAPPED    overlapped;
    WSABUF            wsaBuf;
    char            Buffer[MAX_BUFFER_SIZE + 1];
    BOOL            bIsUse;
 
public:
    BOOL IsLocked()                    { return bIsUse; }
    void LockBuffer()                { bIsUse = TRUE; }
    void UnlockBuffer()                { bIsUse = FALSE; }
    
    int GetLen()                    { return wsaBuf.len; }
    WSAOVERLAPPED* GetOverlapped()    { return &overlapped; }
    
    void ResetOverlapped()            { ZeroMemory(&overlapped, sizeof(WSAOVERLAPPED)); }
    void ResetBuffer()                { wsaBuf.buf = Buffer; }
 
    int StringCompare(char* str)    { return strcmp(wsaBuf.buf, str); }
 
    WSABUF* GetLockedBuffer()        { return &wsaBuf; }
    char* GetBulkBuffer()            { return Buffer; }
 
    WSABUF* GetBuffer()
    {
        int nCount = 0;
        while (bIsUse)
            return NULL; 
 
        LockBuffer();
 
        return &wsaBuf;
    }
 
    void ReleaseBuffer()
    {
        ZeroMemory(&overlapped, sizeof(WSAOVERLAPPED));
 
        ZeroMemory(Buffer, MAX_BUFFER_SIZE + 1);
        wsaBuf.buf        = Buffer;
        wsaBuf.len        = MAX_BUFFER_SIZE;
 
        UnlockBuffer();
    }
 
    // º¹»ç »ý¼ºÀÚ.
    _PERIOCONTEXT(const _PERIOCONTEXT& rhs)
    {
        if(this != &rhs)
        {
            ZeroMemory(&overlapped, sizeof(WSAOVERLAPPED));
 
            ZeroMemory(Buffer, MAX_BUFFER_SIZE + 1);
            memcpy(Buffer, rhs.Buffer, MAX_BUFFER_SIZE);
 
            wsaBuf.buf    = Buffer;
            wsaBuf.len    = rhs.wsaBuf.len;
            bIsUse        = FALSE;
        }
    }
 
    // ´ëÀÔ¿¬»êÀÚ ¿À¹ö·Îµù.
    _PERIOCONTEXT& operator=(const _PERIOCONTEXT& rhs)
    {
        if(this != &rhs)
        {
            ZeroMemory(&overlapped, sizeof(WSAOVERLAPPED));
 
            ZeroMemory(Buffer, MAX_BUFFER_SIZE + 1);
            memcpy(Buffer, rhs.Buffer, MAX_BUFFER_SIZE);
 
            wsaBuf.buf    = Buffer;
            wsaBuf.len    = rhs.wsaBuf.len;
            bIsUse        = FALSE;
        }
        return *this;
    }
} PerIoContext, *pPerIoContext;
 
// IP Completion Key ·Î »ç¿ëµÇ´Â ±¸Á¶Ã¼
typedef struct _PERSOCKETCONTEXT
{
    SOCKET socket;
    pPerIoContext recvContext;
    pPerIoContext sendContext;
 
    _PERSOCKETCONTEXT()
    {
        Reset();
    }
 
    void Reset()
    {
        recvContext->ReleaseBuffer();
        sendContext->ReleaseBuffer();
        socket = INVALID_SOCKET;
    }
} PerSocketContext, *pPerSocketContext;