Hugging Face's logo

mhussainahmad
/
kortex-api

Model card Files
xet
Community
kortex-api
File size: 5,102 Bytes 
053b80b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
124
125
126
127
128
 
/* ***************************************************************************

 * Kinova inc.

 * Project : 

 *

 * Copyright (c) 2006-2018 Kinova Incorporated. All rights reserved.

 ****************************************************************************/

#ifndef _TRANSPORT_BRIDGE_DUMMY_H_
#define _TRANSPORT_BRIDGE_DUMMY_H_

#include <string>
#include <functional>

#include "client/ITransportClient.h"
#include "ITransportServer.h"

namespace Kinova
{
    using namespace Api;
    
    namespace Helper
    {
        class TransportBridgeDummy

        {
            class TransportBridgeClientDummy : public ITransportClient
            {
                TransportBridgeDummy *m_transportBridgeDummy;
            
            public:
                TransportBridgeClientDummy(TransportBridgeDummy *transportBridgeDummy)
                {
                    m_transportBridgeDummy = transportBridgeDummy;
                }
                
                virtual ~TransportBridgeClientDummy();
                
                virtual bool connect(std::string host = "127.0.0.1", uint32_t port = kApiPort) override { return true; }
                
                virtual void disconnect() override {}
                
                virtual void send(const char *txBuffer, uint32_t txSize) override
                {
                    m_transportBridgeDummy->m_onMessageCallbackServer(m_transportBridgeDummy->m_connectionHandle, (uint8_t *) txBuffer, (int) txSize);
                }
                
                virtual void onMessage(std::function<void(const char *, uint32_t)> callbackClient) override
                {
                    m_transportBridgeDummy->m_onMessageCallbackClient = callbackClient;
                }
                
                virtual char *getTxBuffer() override { return m_transportBridgeDummy->m_bufferClientToServer; }
                
                virtual size_t getMaxTxBufferSize() override { return m_transportBridgeDummy->m_maxBufferSizeClientToServer; }
            };
            
            class TransportBridgeServerDummy : public ITransportServer
            {
                TransportBridgeDummy *m_transportBridgeDummy;
            
            public:
                TransportBridgeServerDummy(TransportBridgeDummy *transportBridgeDummy)
                {
                    m_transportBridgeDummy = transportBridgeDummy;
                }
                
                virtual ~TransportBridgeServerDummy() override {}
                
                virtual void Process() override {}
                
                
                virtual bool Send(const ClientConnectionHandle &connectionHandle, char *TXBuffer, int txLen) override
                {
                    m_transportBridgeDummy->m_onMessageCallbackClient((const char *) TXBuffer, (uint32_t) txLen);
                }
                
                virtual void OnMessage(std::function<void(const ClientConnectionHandle &, uint8_t *, int)> callbackServer) override
                {
                    m_transportBridgeDummy->m_onMessageCallbackServer = callbackServer;
                }
                
                virtual char *GetTxBuffer(size_t *pTxLen) override
                {
                    *pTxLen = m_transportBridgeDummy->m_maxBufferSizeServerToClient;
                    
                    return m_transportBridgeDummy->m_bufferServerToClient;
                }
            };
            
            ITransportServer *m_server;
            ITransportClient *m_client;
        
        public:
            static constexpr uint32_t kMaxBufferSizeServerToClient = 65507;
            static constexpr uint32_t kMaxBufferSizeClientToServer = 65507;
            
            const uint32_t m_maxBufferSizeServerToClient = kMaxBufferSizeServerToClient;
            const uint32_t m_maxBufferSizeClientToServer = kMaxBufferSizeClientToServer;
            
            char m_bufferServerToClient[kMaxBufferSizeServerToClient];
            char m_bufferClientToServer[kMaxBufferSizeClientToServer];
            
            std::function<void(const char *, uint32_t)> m_onMessageCallbackClient;
            std::function<void(const ClientConnectionHandle &, uint8_t *, int)> m_onMessageCallbackServer;
            
            struct ClientConnectionHandle m_connectionHandle;
            
            TransportBridgeDummy()
            {
                m_connectionHandle.clientId = 1;
                auto m_server = new TransportBridgeServerDummy(this);
                auto m_client = new TransportBridgeClientDummy(this);
            }
            
            virtual ~TransportBridgeDummy()
            {
                delete m_server;
                delete m_client;
            }
            
            ITransportServer *getServerTransport() { return m_server; }
            
            ITransportClient *getClientTransport() { return m_client; }
        };
        
    }
}
#endif