Upload 167 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+kortex_api/lib/release/KortexApiCpp_without_protobuf.lib filter=lfs diff=lfs merge=lfs -text
+kortex_api/lib/release/KortexApiCpp.lib filter=lfs diff=lfs merge=lfs -text

kortex_api/include/client/FrameHandler.h

@@ -0,0 +1,67 @@
+#ifndef _FRAME_HANDLER_H_
+#define _FRAME_HANDLER_H_
+#undef _HAS_STD_BYTE
+#include <iostream>
+#include <list>
+#include <future>
+#include <memory>
+#include <queue>
+#include <chrono>
+
+#include "common/HeaderInfo.h"
+#include "messages/Frame.pb.h"
+
+using namespace std::chrono;
+
+namespace Kinova {
+    namespace Api {
+        struct CallbackTimeoutStruct {
+            uint32_t m_timeout;
+            steady_clock::time_point m_registeredTimePoint;
+
+            explicit CallbackTimeoutStruct(uint32_t timeout)
+                : m_timeout(timeout) {
+                m_registeredTimePoint = time_point_cast<milliseconds>(steady_clock::now());
+            }
+
+            bool checkExpiry() {
+                uint32_t duration = duration_cast<milliseconds>(steady_clock::now() - m_registeredTimePoint).count();
+                return (duration >= m_timeout);
+            }
+        };
+
+        typedef std::function<void (const Kinova::Api::Frame &)> MessageCallback;
+        typedef std::queue<std::pair<uint32_t, CallbackTimeoutStruct> > TimeoutClockByMeesageCallbackQueue;
+
+        class FrameHandler {
+        public:
+            explicit FrameHandler(uint32_t maxCallbackTimeout = 60000);
+
+            ~FrameHandler() = default;
+
+            std::future<Frame> registerMessage(uint32_t msgId);
+
+            // TODO sfforget 2018-05-30 Add error callback
+            void registerMessageCallback(uint32_t msgId, const MessageCallback &callback);
+
+            Error manageReceivedMessage(Frame &msgFrame);
+
+            void setMessageException(HeaderInfo &headerInfo, Error &error);
+
+        private:
+            void cleanDanglingCallback();
+
+            std::mutex m_mutex;
+            uint32_t m_maxCallbackTimeout;
+            // IdGenerator<uint32_t> m_apiIdGenerator;
+
+            // TODO cleanup messages without response from server to avoid memory leak.
+            // todoErr add the validation information beside the message promise
+            std::unordered_map<uint32_t, std::shared_ptr<std::promise<Frame> > > m_messagePromises;
+            TimeoutClockByMeesageCallbackQueue m_timeoutClockByCallback;
+            std::unordered_map<uint32_t, MessageCallback> m_messageCallbacks;
+        };
+    }
+}
+
+#endif // _MESSAGE_MANAGER_H_

kortex_api/include/client/IRouterClient.h

@@ -0,0 +1,55 @@
+#ifndef _I_ROUTER_CLIENT_H_
+#define _I_ROUTER_CLIENT_H_
+
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+
+#include "ITransportClient.h"
+#include "common/KError.h"
+
+using namespace std;
+
+namespace Kinova
+{
+namespace Api
+{
+    typedef std::function<void (const Kinova::Api::Frame&)> MessageCallback;
+
+    typedef struct
+    {
+        bool andForget;
+        uint32_t delay_ms;
+        uint32_t timeout_ms;
+    
+    } RouterClientSendOptions;
+
+    class IRouterClient
+    {
+    public:
+        virtual ~IRouterClient() {}
+
+        virtual void reset() = 0;
+        virtual void registerBridgingCallback(std::function<void (Frame &)> bridgingCallback) = 0;
+        virtual void registerNotificationCallback( uint32_t serviceId, function<Error (Frame&)> ) = 0;
+        virtual void registerErrorCallback( function<void(KError)> callback ) = 0;
+        virtual void registerHitCallback(std::function<void (FrameTypes)> hitSessionCallback) = 0;
+
+        virtual future<Frame> send(const std::string& txPayload, uint32_t serviceVersion, uint32_t funcId, uint32_t deviceId, const RouterClientSendOptions& options ) = 0;
+        virtual Error sendWithCallback(const std::string& txPayload, uint32_t serviceVersion, uint32_t funcId, uint32_t deviceId, MessageCallback callback) = 0;
+        virtual Error sendMsgFrame(const Frame& msgFrame) = 0;
+
+        virtual uint16_t getConnectionId() = 0;
+        virtual void SetActivationStatus(bool isActive) = 0;
+
+        virtual ITransportClient* getTransport() = 0;
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // _I_ROUTER_CLIENT_H_

kortex_api/include/client/ITransportClient.h

@@ -0,0 +1,61 @@
+#ifndef _I_TRANSPORT_CLIENT_H_
+#define _I_TRANSPORT_CLIENT_H_
+
+
+#include <string>
+#include <functional>
+#include <exception>
+
+#include <cmath>
+
+using namespace std;
+
+namespace Kinova
+{
+namespace Api
+{
+    // enums
+    enum TransportReadyStateEnum 
+    {
+        CONNECTING = 0,
+        OPEN = 1,
+        CLOSING = 2,
+        CLOSED = 3,
+        UNINITIALIZED = 4,
+        RECONNECTING = 5,
+    };
+
+    // interface
+    class ITransportClient
+    {
+    public:
+        TransportReadyStateEnum readyState;
+
+        virtual ~ITransportClient() {}
+
+        virtual bool connect(std::string host, uint32_t port) = 0;
+        virtual void disconnect() = 0;
+
+        virtual void send(const char* txBuffer, uint32_t txSize) = 0;
+        virtual void onMessage(std::function<void (const char*, uint32_t)> callback) = 0;
+
+        // virtual void onClose(ConnectionClose eventClose)> callback) = 0;
+        // virtual void onError(ConnectionError error)> callback) = 0;
+
+        // virtual bool isClosed() = 0;
+        // virtual bool isClosing() = 0;
+        // virtual bool isConnecting() = 0;
+        // virtual bool isOpen() = 0;
+        // virtual bool isUninitialized() = 0;
+
+        virtual char* getTxBuffer(uint32_t const& allocation_size) = 0;
+        virtual size_t getMaxTxBufferSize() = 0;
+
+        virtual void getHostAddress(std::string &host, uint32_t &port) = 0;
+    };
+
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // _I_TRANSPORT_CLIENT_H_

kortex_api/include/client/NotificationHandler.h

@@ -0,0 +1,96 @@
+#ifndef _NOTIFICATION_HANDLER_H_
+#define _NOTIFICATION_HANDLER_H_
+
+
+#include <memory>
+#include <map>
+#include <vector>
+#include <functional>
+#include <future>
+
+#include "common/KBasicException.h"
+#include "common/KDetailedException.h"
+
+#include "messages/Frame.pb.h"
+
+#include "ITransportClient.h"
+#include "IRouterClient.h"
+
+namespace Kinova
+{
+namespace Api
+{
+
+    struct AbstractCallbackFunction
+    {
+        AbstractCallbackFunction() = default;
+        virtual ~AbstractCallbackFunction() = default;
+
+        virtual Error call(Frame& msgFrameNotif) = 0;
+    };
+
+    template <class DataType>
+    struct CallbackFunction : public AbstractCallbackFunction
+    {
+        static constexpr bool isOk = std::is_base_of<::google::protobuf::Message, DataType>::value;
+        static_assert(isOk, "DataType must inherit from ::google::protobuf::Message");
+
+        std::function< void (DataType) > m_callbackFct;
+
+        CallbackFunction(std::function< void(DataType) > callback) : AbstractCallbackFunction() { m_callbackFct = callback; }
+        virtual ~CallbackFunction() override {}
+
+        virtual Error call(Frame& msgFrameNotif) override
+        {
+            Error error;
+            error.set_error_code(ErrorCodes::ERROR_NONE);
+
+            DataType decodedMsgNotif;
+            if( !decodedMsgNotif.ParseFromString(msgFrameNotif.payload()) )
+            {
+                HeaderInfo headerInfo( msgFrameNotif.header() );
+
+                error.set_error_code(ERROR_PROTOCOL_CLIENT);
+                error.set_error_sub_code(PAYLOAD_DECODING_ERR);
+                error.set_error_sub_string(string("The data payload could not be deserialized : notification for serviceId=") + to_string(headerInfo.m_serviceInfo.serviceId) + " \n");
+            }
+            else
+            {
+                // todo ???  thread(m_callbackFct, move(decodedMsgNotif)).detach();
+                thread(m_callbackFct, decodedMsgNotif).detach();
+            }
+
+            return error;
+        }
+    };
+
+    // todoErr add the validation information beside the callback
+    typedef std::unordered_map< uint32_t, std::unique_ptr<AbstractCallbackFunction>> CallbackMap;
+
+    class NotificationHandler
+    {
+        CallbackMap     m_callbackMap;
+        std::mutex      m_mutex;
+
+    public:
+        NotificationHandler();
+        ~NotificationHandler();
+
+        template <class DataType>
+        void addCallback( uint32_t idKey, std::function<void(DataType)> callback )
+        {
+            std::lock_guard<std::mutex> w_scoped(m_mutex);
+            std::unique_ptr<AbstractCallbackFunction> fct{new CallbackFunction<DataType>(callback)};
+            m_callbackMap[idKey] = std::move(fct);
+        }
+
+        void clearIdKeyCallbacks( uint32_t idKey );
+        void clearAll();
+
+        Error call(Frame& msgFrameNotif);
+    };
+
+}
+}
+
+#endif // _NOTIFICATION_HANDLER_H_

kortex_api/include/client/RouterClient.h

@@ -0,0 +1,73 @@
+#ifndef _ROUTER_CLIENT_H_
+#define _ROUTER_CLIENT_H_
+
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+
+#include "ITransportClient.h"
+#include "IRouterClient.h"
+
+#include "FrameHandler.h"
+
+
+using namespace std;
+
+namespace Kinova
+{
+namespace Api
+{
+
+    typedef map< uint32_t, function<Error (Frame&)> > NotificationServices;
+
+    class RouterClient : public IRouterClient
+    {
+	private:
+        ITransportClient* const m_transport;
+    
+        NotificationServices        m_notificationServices;
+        function<void(KError)>      m_errorCallback;
+        function<void(FrameTypes)>  m_hitSessionCallback;
+        function<void(Frame&)>      m_bridgingCallback;
+
+        FrameHandler            m_frameHandler;
+        uint16_t                m_msgId;
+        uint16_t                m_sessionId;
+
+        //A flag indicating if the instance can be used.
+        bool                    m_isActive;
+
+        std::mutex              m_send_mutex;
+
+    public:
+        RouterClient(ITransportClient* transport, function<void (KError)> errorCallback);
+        virtual ~RouterClient();
+
+        virtual void reset() override;
+        virtual void registerBridgingCallback(std::function<void (Frame &)> bridgingCallback) override;
+        virtual void registerNotificationCallback( uint32_t serviceId, function<Error (Frame&)> ) override;
+        virtual void registerErrorCallback( function<void(KError)> callback ) override;
+        virtual void registerHitCallback(std::function<void (FrameTypes)> hitSessionCallback) override;
+
+        virtual future<Frame> send(const std::string& txPayload, uint32_t serviceVersion, uint32_t funcId, uint32_t deviceId, const RouterClientSendOptions& options ) override;
+        virtual Error sendWithCallback(const std::string& txPayload, uint32_t serviceVersion, uint32_t funcId, uint32_t deviceId, MessageCallback callback) override;
+        virtual Error sendMsgFrame(const Frame& msgFrame) override;
+
+        virtual uint16_t getConnectionId() override;
+        virtual void SetActivationStatus(bool isActive) override;
+
+        virtual ITransportClient* getTransport() override {return m_transport;}
+
+    private:
+        uint16_t generateNewMsgId();
+        void frameHandler(const void *rxBuffer, uint32_t rxSize);
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // _ROUTER_CLIENT_H_

kortex_api/include/client/SessionManager.h

@@ -0,0 +1,48 @@
+#ifndef _SESSION_MANAGER_H_
+#define _SESSION_MANAGER_H_
+
+#include <iostream>
+#include <list>
+#include <future>
+#include <memory>
+#include <functional>
+
+#include "IRouterClient.h"
+#include "messages/Frame.pb.h"
+#include "messages/Session.pb.h"
+#include "client_stubs/SessionClientRpc.h"
+
+namespace Kinova
+{
+namespace Api
+{
+    class SessionManager : public Session::SessionClient
+    {
+    public:
+        SessionManager() = delete;
+        explicit SessionManager(IRouterClient* router, std::function<void()> connectionTimeoutCallback = nullptr);
+        virtual ~SessionManager();
+
+        void CreateSession(const Session::CreateSessionInfo& info);
+        void CloseSession();
+        Session::ConnectionList GetConnections();
+
+    private:
+        void Hit(FrameTypes hitType);
+        void ThreadSessionValidation();
+    
+        std::function<void()>           m_connectionTimeoutCallback;
+        
+        std::thread                     m_thread;
+        std::atomic<bool>               m_hasBeenSent { false };
+        std::atomic<bool>               m_hasBeenReceived { false };
+        std::atomic<bool>               m_threadRunning { false };
+        Session::CreateSessionInfo      m_sessionInfo;
+
+        void checkTransport();
+    };
+
+}
+}
+
+#endif // _MESSAGE_MANAGER_H_

kortex_api/include/client/TransportClientTcp.h

@@ -0,0 +1,139 @@
+/* ***************************************************************************
+ * Kinova inc.
+ *
+ * Copyright (c) 2006-2018 Kinova Incorporated. All rights reserved.
+ ****************************************************************************/
+
+#ifndef __TRANSPORT_CLIENT_TCP_H__
+#define __TRANSPORT_CLIENT_TCP_H__
+
+#if defined(_OS_WINDOWS)
+// ---- win ----
+#include <stdio.h>
+#include <winsock2.h>
+#elif defined(_OS_UNIX)
+// --- linux ---
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/select.h>
+#include <sys/fcntl.h>
+
+#include <iostream>
+#include <unistd.h>
+#include <ctime>
+#include <stdio.h>
+#include <unistd.h>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#else
+#pragma message("WARNING: Unknown OS Type!")
+#endif
+
+#include <atomic>
+#include <thread>
+#include <mutex>
+
+#include <string>
+#include <functional>
+#include <exception>
+
+#include <iostream>
+#include <chrono>
+
+#include "ITransportClient.h"
+#include "common/KinovaTcpUtilities.h"
+#include "common/WindowsNetworking.h"
+
+namespace Kinova
+{
+namespace Api
+{
+    class TransportClientTcp : public ITransportClient
+    {
+    private:
+        const uint32_t kApiPort					= 10000;
+        // Configuration        m_config;
+        bool                    m_isInitialized;
+        struct sockaddr_in      m_socketAddr{};
+        socklen_t               m_socketAddrSize{};
+        int32_t                 m_socketFd{};
+        #if defined(_OS_WINDOWS)
+        WSADATA                 m_wsa{};
+        #endif
+
+        bool                    m_isUsingRcvThread;
+        std::atomic<bool>       m_isRunning { true };
+        std::mutex              m_sendMutex;
+
+        // ---- non-blocking ----
+        fd_set          m_original_rx{};
+        fd_set          m_readfds{};
+
+        int             numfd{};
+        struct hostent  *m_host{};
+        struct timeval  m_tv{};
+        // ----------------------
+
+        // 65535 - 20 (ip header) - 20 (tcp header) = 65495 bytes
+        static constexpr uint32_t kMaxTxBufferSize = 65495;
+        static constexpr uint32_t kMaxRxBufferSize = 65495;
+        static constexpr uint32_t kMaxBufferSize = 16777216;
+
+        bool                 m_bIsReceiving { false };
+        uint32_t             m_nTotalBytesRead {0};
+        uint32_t             m_nTotalBytesToRead {0};
+        uint8_t*             m_tx_buffer;
+        uint8_t*             m_rx_buffer;
+
+        uint32_t             m_current_buffer_size_rx = { kMaxRxBufferSize };
+        uint32_t             m_current_buffer_size_tx = { kMaxTxBufferSize };
+
+
+        KinovaTcpUtilities m_utilities_object;
+
+        std::function<void (const char*, uint32_t) > m_onMessageCallback;
+
+
+    public:
+        TransportReadyStateEnum readyState;
+        std::thread             m_receiveThread;
+
+        explicit TransportClientTcp(bool isUsingRcvThread = true);
+        ~TransportClientTcp() override;
+
+        bool connect(std::string host = "127.0.0.1", uint32_t port = 10000) override;
+        void disconnect() override;
+
+        void send(const char* txBuffer, uint32_t txSize) override;
+        void onMessage(std::function<void (const char*, uint32_t)> callback) override;
+
+        char* getTxBuffer(uint32_t const& allocation_size) override;
+        size_t getMaxTxBufferSize() override { return kMaxBufferSize; }
+
+        int processReceive(long rcvTimeout_usec);
+        int processReceive(struct timeval rcvTimeout_tv);
+
+        virtual void getHostAddress(std::string &host, uint32_t &port) override {
+            host = mHostAddress;
+            port = mHostPort;
+        };
+
+    private:
+
+        std::string mHostAddress;
+        uint32_t mHostPort;
+
+        void receiveThread(std::atomic<bool> &program_is_running);
+        
+        int callReceiveFrom();
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // __TRANSPORT_CLIENT_H__

kortex_api/include/client/TransportClientUdp.h

@@ -0,0 +1,148 @@
+/* ***************************************************************************
+ * Kinova inc.
+ * Project :
+ *
+ * Copyright (c) 2006-2018 Kinova Incorporated. All rights reserved.
+ ****************************************************************************/
+
+#ifndef __TRANSPORT_CLIENT_UDP_H__
+#define __TRANSPORT_CLIENT_UDP_H__
+
+#if defined(_OS_WINDOWS)
+// ---- win ----
+#include <stdio.h>
+#include <winsock2.h>
+#elif defined(_OS_UNIX)
+// --- linux ---
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>      // host struct
+#include <sys/select.h> // use select() for multiplexing
+#include <sys/fcntl.h>  // for non-blocking
+
+#include <iostream>
+#include <unistd.h>
+#include <ctime>
+#include <stdio.h>
+#include <unistd.h>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#else
+#warning Unknown OS type!
+#endif
+
+#include <atomic>
+#include <thread>
+#include <mutex>
+
+#include <string>
+#include <functional>
+#include <exception>
+
+#include <iostream>
+#include <chrono>
+
+#include "ITransportClient.h"
+
+#if defined(_OS_WINDOWS) // todogr
+typedef int32_t socklen_t;
+#endif
+
+namespace Kinova
+{
+namespace Api
+{
+    const uint32_t kApiPort					= 10000;
+
+    class TransportClientUdp : public ITransportClient
+    {
+        // Configuration        m_config;
+        bool                   	m_isInitialized;
+        struct sockaddr_in      m_socketAddr;
+        socklen_t               m_socketAddrSize;
+        int32_t                 m_socketFd;
+        #if defined(_OS_WINDOWS)
+        WSADATA                 m_wsa;
+        #endif
+
+        bool                    m_isUsingRcvThread;
+        std::atomic<bool>       m_isRunning { true };
+        std::mutex              m_sendMutex;
+
+        // ---- non-blocking ----
+        fd_set          m_original_rx;
+        fd_set          m_readfds;
+
+        int             numfd;
+        struct hostent  *m_host;
+        struct timeval  m_tv;
+        // ----------------------
+
+        // 65535 - 20 (ip header) - 8 (udp header) = 65507 bytes
+        static constexpr uint32_t kMaxTxBufferSize = 65507;
+        static constexpr uint32_t kMaxRxBufferSize = 65507;
+
+        char m_txBuffer[kMaxTxBufferSize];
+        char m_rxBuffer[kMaxRxBufferSize];
+
+        std::function<void (const char*, uint32_t) > m_onMessageCallback;
+
+        // int32_t m_countTx;
+        // int32_t m_countRx;
+        // ChronoClock m_start;
+        // ChronoClock m_elapsed;
+
+    public:
+        TransportReadyStateEnum readyState;
+        std::thread             m_receiveThread;
+
+        TransportClientUdp(bool isUsingRcvThread = true);
+        virtual ~TransportClientUdp();
+
+        virtual bool connect(std::string host = "127.0.0.1", uint32_t port = Kinova::Api::kApiPort) override;
+        virtual void disconnect() override;
+
+        virtual void send(const char* txBuffer, uint32_t txSize) override;
+        virtual void onMessage(std::function<void (const char*, uint32_t)> callback) override;
+
+        // virtual void onClose(ConnectionClose eventClose)> callback) = 0;
+        // virtual void onError(ConnectionError error)> callback) = 0;
+
+        // virtual bool isClosed() = 0;
+        // virtual bool isClosing() = 0;
+        // virtual bool isConnecting() = 0;
+        // virtual bool isOpen() = 0;
+        // virtual bool isUninitialized() = 0;
+
+        virtual char* getTxBuffer(uint32_t const& allocation_size) override { return m_txBuffer; }
+        virtual size_t getMaxTxBufferSize() override { return kMaxTxBufferSize; }
+
+        // double getTimeComm();
+    
+        int processReceive(long rcvTimeout_usec);
+        int processReceive(struct timeval rcvTimeout_tv);
+
+        virtual void getHostAddress(std::string &host, uint32_t &port) override {
+            host = mHostAddress;
+            port = mHostPort;
+        };
+
+    private:
+
+        std::string mHostAddress;
+        uint32_t mHostPort;
+
+        void receiveThread(std::atomic<bool> &program_is_running);
+        
+        // return value: <0 means error (-errorCode); =0 means timeout nothing received; >0 means nbr of handles ready to recvFrom
+        int callReceiveFrom();
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // __TRANSPORT_CLIENT_H__

kortex_api/include/client/version.h

@@ -0,0 +1,19 @@
+
+#ifndef VERSION_H
+#define VERSION_H
+
+#define NEO_PART_NUMBER_STR      ""
+
+#define VER_MAJOR                1
+#define VER_MINOR                1
+#define VER_FEATURE              6
+#define VER_BUILD_NUMBER         0
+
+#define VER_COMPANYNAME_STR      "Kinova Robotics"
+#define VER_INTERNALNAME_STR     "Kortex Cpp Client API"
+#define VER_LEGALCOPYRIGHT_STR   "Copyright 2018 Kinova"
+#define VER_LEGALTRADEMARKS1_STR "All Rights Reserved"
+
+#define VER_COMPANYDOMAIN_STR    "www.kinovarobotics.com/"
+
+#endif // VERSION_H

kortex_api/include/client_stubs/ActuatorConfigClientRpc.h

@@ -0,0 +1,223 @@
+#ifndef __ACTUATORCONFIGCLIENT_H__
+#define __ACTUATORCONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/ActuatorConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace ActuatorConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidGetAxisOffsets = 0xa0001,
+			eUidSetAxisOffsets = 0xa0002,
+			eUidReadTorqueCalibration = 0xa0003,
+			eUidWriteTorqueCalibration = 0xa0004,
+			eUidSetTorqueOffset = 0xa0005,
+			eUidGetControlMode = 0xa0006,
+			eUidSetControlMode = 0xa0007,
+			eUidGetActivatedControlLoop = 0xa0008,
+			eUidSetActivatedControlLoop = 0xa0009,
+			eUidGetVectorDriveParameters = 0xa000a,
+			eUidSetVectorDriveParameters = 0xa000b,
+			eUidGetEncoderDerivativeParameters = 0xa000c,
+			eUidSetEncoderDerivativeParameters = 0xa000d,
+			eUidGetControlLoopParameters = 0xa000e,
+			eUidSetControlLoopParameters = 0xa000f,
+			eUidStartFrequencyResponse = 0xa0010,
+			eUidStopFrequencyResponse = 0xa0011,
+			eUidStartStepResponse = 0xa0012,
+			eUidStopStepResponse = 0xa0013,
+			eUidStartRampResponse = 0xa0014,
+			eUidStopRampResponse = 0xa0015,
+			eUidSelectCustomData = 0xa0016,
+			eUidGetSelectedCustomData = 0xa0017,
+			eUidSetCommandMode = 0xa0018,
+			eUidClearFaults = 0xa0019,
+			eUidSetServoing = 0xa001a,
+			eUidMoveToPosition = 0xa001b,
+			eUidGetCommandMode = 0xa001c,
+			eUidGetServoing = 0xa001d,
+			eUidGetTorqueOffset = 0xa001e,
+			eUidSetCoggingFeedforwardMode = 0xa001f,
+			eUidGetCoggingFeedforwardMode = 0xa0020,
+		};
+		
+		class ActuatorConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdActuatorConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			ActuatorConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			AxisOffsets GetAxisOffsets(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAxisOffsets_callback(std::function< void (const Error&, const AxisOffsets&) > callback, uint32_t deviceId = 0);
+			std::future<AxisOffsets> GetAxisOffsets_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetAxisOffsets(const AxisPosition& axisposition, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetAxisOffsets_callback(const AxisPosition& axisposition, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetAxisOffsets_async(const AxisPosition& axisposition, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TorqueCalibration ReadTorqueCalibration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadTorqueCalibration_callback(std::function< void (const Error&, const TorqueCalibration&) > callback, uint32_t deviceId = 0);
+			std::future<TorqueCalibration> ReadTorqueCalibration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void WriteTorqueCalibration(const TorqueCalibration& torquecalibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void WriteTorqueCalibration_callback(const TorqueCalibration& torquecalibration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> WriteTorqueCalibration_async(const TorqueCalibration& torquecalibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetTorqueOffset(const TorqueOffset& torqueoffset, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetTorqueOffset_callback(const TorqueOffset& torqueoffset, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetTorqueOffset_async(const TorqueOffset& torqueoffset, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControlModeInformation GetControlMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControlMode_callback(std::function< void (const Error&, const ControlModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ControlModeInformation> GetControlMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetControlMode(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetControlMode_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetControlMode_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControlLoop GetActivatedControlLoop(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetActivatedControlLoop_callback(std::function< void (const Error&, const ControlLoop&) > callback, uint32_t deviceId = 0);
+			std::future<ControlLoop> GetActivatedControlLoop_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetActivatedControlLoop(const ControlLoop& controlloop, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetActivatedControlLoop_callback(const ControlLoop& controlloop, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetActivatedControlLoop_async(const ControlLoop& controlloop, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			VectorDriveParameters GetVectorDriveParameters(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetVectorDriveParameters_callback(std::function< void (const Error&, const VectorDriveParameters&) > callback, uint32_t deviceId = 0);
+			std::future<VectorDriveParameters> GetVectorDriveParameters_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetVectorDriveParameters(const VectorDriveParameters& vectordriveparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetVectorDriveParameters_callback(const VectorDriveParameters& vectordriveparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetVectorDriveParameters_async(const VectorDriveParameters& vectordriveparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			EncoderDerivativeParameters GetEncoderDerivativeParameters(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetEncoderDerivativeParameters_callback(std::function< void (const Error&, const EncoderDerivativeParameters&) > callback, uint32_t deviceId = 0);
+			std::future<EncoderDerivativeParameters> GetEncoderDerivativeParameters_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetEncoderDerivativeParameters(const EncoderDerivativeParameters& encoderderivativeparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetEncoderDerivativeParameters_callback(const EncoderDerivativeParameters& encoderderivativeparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetEncoderDerivativeParameters_async(const EncoderDerivativeParameters& encoderderivativeparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControlLoopParameters GetControlLoopParameters(const LoopSelection& loopselection, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControlLoopParameters_callback(const LoopSelection& loopselection, std::function< void (const Error&, const ControlLoopParameters&) > callback, uint32_t deviceId = 0);
+			std::future<ControlLoopParameters> GetControlLoopParameters_async(const LoopSelection& loopselection, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetControlLoopParameters(const ControlLoopParameters& controlloopparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetControlLoopParameters_callback(const ControlLoopParameters& controlloopparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetControlLoopParameters_async(const ControlLoopParameters& controlloopparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartFrequencyResponse(const FrequencyResponse& frequencyresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartFrequencyResponse_callback(const FrequencyResponse& frequencyresponse, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartFrequencyResponse_async(const FrequencyResponse& frequencyresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopFrequencyResponse(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopFrequencyResponse_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopFrequencyResponse_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartStepResponse(const StepResponse& stepresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartStepResponse_callback(const StepResponse& stepresponse, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartStepResponse_async(const StepResponse& stepresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopStepResponse(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopStepResponse_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopStepResponse_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartRampResponse(const RampResponse& rampresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartRampResponse_callback(const RampResponse& rampresponse, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartRampResponse_async(const RampResponse& rampresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopRampResponse(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopRampResponse_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopRampResponse_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SelectCustomData(const CustomDataSelection& customdataselection, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SelectCustomData_callback(const CustomDataSelection& customdataselection, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SelectCustomData_async(const CustomDataSelection& customdataselection, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomDataSelection GetSelectedCustomData(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSelectedCustomData_callback(std::function< void (const Error&, const CustomDataSelection&) > callback, uint32_t deviceId = 0);
+			std::future<CustomDataSelection> GetSelectedCustomData_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCommandMode(const CommandModeInformation& commandmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCommandMode_callback(const CommandModeInformation& commandmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCommandMode_async(const CommandModeInformation& commandmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ClearFaults(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ClearFaults_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ClearFaults_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetServoing(const Servoing& servoing, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetServoing_callback(const Servoing& servoing, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetServoing_async(const Servoing& servoing, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void MoveToPosition(const PositionCommand& positioncommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void MoveToPosition_callback(const PositionCommand& positioncommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> MoveToPosition_async(const PositionCommand& positioncommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CommandModeInformation GetCommandMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCommandMode_callback(std::function< void (const Error&, const CommandModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<CommandModeInformation> GetCommandMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Servoing GetServoing(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetServoing_callback(std::function< void (const Error&, const Servoing&) > callback, uint32_t deviceId = 0);
+			std::future<Servoing> GetServoing_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TorqueOffset GetTorqueOffset(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetTorqueOffset_callback(std::function< void (const Error&, const TorqueOffset&) > callback, uint32_t deviceId = 0);
+			std::future<TorqueOffset> GetTorqueOffset_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCoggingFeedforwardMode(const CoggingFeedforwardModeInformation& coggingfeedforwardmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCoggingFeedforwardMode_callback(const CoggingFeedforwardModeInformation& coggingfeedforwardmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCoggingFeedforwardMode_async(const CoggingFeedforwardModeInformation& coggingfeedforwardmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CoggingFeedforwardModeInformation GetCoggingFeedforwardMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCoggingFeedforwardMode_callback(std::function< void (const Error&, const CoggingFeedforwardModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<CoggingFeedforwardModeInformation> GetCoggingFeedforwardMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/ActuatorCyclicClientRpc.h

@@ -0,0 +1,83 @@
+#ifndef __ACTUATORCYCLICCLIENT_H__
+#define __ACTUATORCYCLICCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/ActuatorCyclic.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace ActuatorCyclic
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidRefresh = 0xb0001,
+			eUidRefreshCommand = 0xb0002,
+			eUidRefreshFeedback = 0xb0003,
+			eUidRefreshCustomData = 0xb0004,
+		};
+		
+		class ActuatorCyclicClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdActuatorCyclic;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			ActuatorCyclicClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Feedback Refresh(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Refresh_callback(const Command& command, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> Refresh_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RefreshCommand(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCommand_callback(const Command& command, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RefreshCommand_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Feedback RefreshFeedback(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshFeedback_callback(const MessageId& messageid, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> RefreshFeedback_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomData RefreshCustomData(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCustomData_callback(const MessageId& messageid, std::function< void (const Error&, const CustomData&) > callback, uint32_t deviceId = 0);
+			std::future<CustomData> RefreshCustomData_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/BaseClientRpc.h

@@ -0,0 +1,770 @@
+#ifndef __BASECLIENT_H__
+#define __BASECLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/Base.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace Base
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidCreateUserProfile = 0x20001,
+			eUidUpdateUserProfile = 0x20002,
+			eUidReadUserProfile = 0x20003,
+			eUidDeleteUserProfile = 0x20004,
+			eUidReadAllUserProfiles = 0x20005,
+			eUidReadAllUsers = 0x20006,
+			eUidChangePassword = 0x20007,
+			eUidCreateSequence = 0x20008,
+			eUidUpdateSequence = 0x20009,
+			eUidReadSequence = 0x2000a,
+			eUidDeleteSequence = 0x2000b,
+			eUidReadAllSequences = 0x2000c,
+			eUidPlaySequence = 0x2000f,
+			eUidPlayAdvancedSequence = 0x20010,
+			eUidStopSequence = 0x20011,
+			eUidPauseSequence = 0x20012,
+			eUidResumeSequence = 0x20013,
+			eUidCreateProtectionZone = 0x20014,
+			eUidUpdateProtectionZone = 0x20015,
+			eUidReadProtectionZone = 0x20016,
+			eUidDeleteProtectionZone = 0x20017,
+			eUidReadAllProtectionZones = 0x20018,
+			eUidCreateMapping = 0x2001a,
+			eUidReadMapping = 0x2001b,
+			eUidUpdateMapping = 0x2001c,
+			eUidDeleteMapping = 0x2001d,
+			eUidReadAllMappings = 0x2001e,
+			eUidCreateMap = 0x20024,
+			eUidReadMap = 0x20025,
+			eUidUpdateMap = 0x20026,
+			eUidDeleteMap = 0x20027,
+			eUidReadAllMaps = 0x20028,
+			eUidActivateMap = 0x20029,
+			eUidCreateAction = 0x2002a,
+			eUidReadAction = 0x2002b,
+			eUidReadAllActions = 0x2002c,
+			eUidDeleteAction = 0x2002d,
+			eUidUpdateAction = 0x2002e,
+			eUidExecuteActionFromReference = 0x2002f,
+			eUidExecuteAction = 0x20030,
+			eUidPauseAction = 0x20031,
+			eUidStopAction = 0x20032,
+			eUidResumeAction = 0x20033,
+			eUidGetIPv4Configuration = 0x2003b,
+			eUidSetIPv4Configuration = 0x2003c,
+			eUidSetCommunicationInterfaceEnable = 0x2003d,
+			eUidIsCommunicationInterfaceEnable = 0x2003e,
+			eUidGetAvailableWifi = 0x2003f,
+			eUidGetWifiInformation = 0x20040,
+			eUidAddWifiConfiguration = 0x20041,
+			eUidDeleteWifiConfiguration = 0x20042,
+			eUidGetAllConfiguredWifis = 0x20043,
+			eUidConnectWifi = 0x20044,
+			eUidDisconnectWifi = 0x20045,
+			eUidGetConnectedWifiInformation = 0x20046,
+			eUidUnsubscribe = 0x20061,
+			eUidConfigurationChangeTopic = 0x20062,
+			eUidMappingInfoTopic = 0x20063,
+			eUidOperatingModeTopic = 0x20065,
+			eUidSequenceInfoTopic = 0x20066,
+			eUidProtectionZoneTopic = 0x20067,
+			eUidUserTopic = 0x20068,
+			eUidControllerTopic = 0x20069,
+			eUidActionTopic = 0x2006a,
+			eUidRobotEventTopic = 0x2006b,
+			eUidPlayCartesianTrajectory = 0x2006d,
+			eUidPlayCartesianTrajectoryPosition = 0x2006e,
+			eUidPlayCartesianTrajectoryOrientation = 0x2006f,
+			eUidStop = 0x20070,
+			eUidGetMeasuredCartesianPose = 0x20073,
+			eUidSendWrenchCommand = 0x20076,
+			eUidSendWrenchJoystickCommand = 0x20077,
+			eUidSendTwistJoystickCommand = 0x20078,
+			eUidSendTwistCommand = 0x20079,
+			eUidPlayJointTrajectory = 0x2007c,
+			eUidPlaySelectedJointTrajectory = 0x2007d,
+			eUidGetMeasuredJointAngles = 0x2007e,
+			eUidSendJointSpeedsCommand = 0x20084,
+			eUidSendSelectedJointSpeedCommand = 0x20085,
+			eUidSendGripperCommand = 0x20088,
+			eUidGetMeasuredGripperMovement = 0x20089,
+			eUidSetAdmittance = 0x2008b,
+			eUidSetOperatingMode = 0x2008d,
+			eUidApplyEmergencyStop = 0x20091,
+			eUidClearFaults = 0x20092,
+			eUidGetOperatingMode = 0x20097,
+			eUidSetServoingMode = 0x20098,
+			eUidGetServoingMode = 0x20099,
+			eUidServoingModeTopic = 0x2009a,
+			eUidRestoreFactorySettings = 0x200a0,
+			eUidReboot = 0x200a2,
+			eUidFactoryTopic = 0x200a4,
+			eUidGetAllConnectedControllers = 0x200a6,
+			eUidGetControllerState = 0x200a7,
+			eUidGetActuatorCount = 0x200ab,
+			eUidStartWifiScan = 0x200ac,
+			eUidGetConfiguredWifi = 0x200ad,
+			eUidNetworkTopic = 0x200ae,
+			eUidGetArmState = 0x200af,
+			eUidArmStateTopic = 0x200b0,
+			eUidGetIPv4Information = 0x200b1,
+			eUidSetWifiCountryCode = 0x200b2,
+			eUidGetWifiCountryCode = 0x200b3,
+			eUidSetCapSenseConfig = 0x200b4,
+			eUidGetCapSenseConfig = 0x200b5,
+			eUidGetAllJointsTorqueHardLimitation = 0x200b8,
+			eUidGetWrenchHardLimitation = 0x200ba,
+			eUidSendJointSpeedsJoystickCommand = 0x200bb,
+			eUidSendSelectedJointSpeedJoystickCommand = 0x200bc,
+			eUidEnableBridge = 0x200c1,
+			eUidDisableBridge = 0x200c2,
+			eUidGetBridgeList = 0x200c3,
+			eUidGetBridgeConfig = 0x200c4,
+			eUidPlayPreComputedJointTrajectory = 0x200c5,
+			eUidGetProductConfiguration = 0x200c6,
+			eUidUpdateEndEffectorTypeConfiguration = 0x200c9,
+			eUidRestoreFactoryProductConfiguration = 0x200ce,
+			eUidGetTrajectoryErrorReport = 0x200cf,
+			eUidGetAllJointsTorqueSoftLimitation = 0x200d1,
+			eUidGetWrenchSoftLimitation = 0x200d3,
+			eUidSetControllerConfigurationMode = 0x200d4,
+			eUidGetControllerConfigurationMode = 0x200d5,
+			eUidStartTeaching = 0x200d6,
+			eUidStopTeaching = 0x200d7,
+			eUidAddSequenceTasks = 0x200d8,
+			eUidUpdateSequenceTask = 0x200d9,
+			eUidSwapSequenceTasks = 0x200da,
+			eUidReadSequenceTask = 0x200db,
+			eUidReadAllSequenceTasks = 0x200dc,
+			eUidDeleteSequenceTask = 0x2000d,
+			eUidDeleteAllSequenceTasks = 0x2000e,
+			eUidTakeSnapshot = 0x200df,
+			eUidGetFirmwareBundleVersions = 0x200e0,
+			eUidExecuteWaypointTrajectory = 0x200e2,
+			eUidMoveSequenceTask = 0x200e3,
+			eUidDuplicateMapping = 0x200e4,
+			eUidDuplicateMap = 0x200e5,
+			eUidSetControllerConfiguration = 0x200e6,
+			eUidGetControllerConfiguration = 0x200e7,
+			eUidGetAllControllerConfigurations = 0x200e8,
+			eUidComputeForwardKinematics = 0x200e9,
+			eUidComputeInverseKinematics = 0x200ea,
+			eUidValidateWaypointList = 0x200eb,
+			eUidSetWifiEnableState = 0x200ec,
+			eUidGetWifiEnableState = 0x200ed,
+			eUidSetBluetoothEnableState = 0x200ee,
+			eUidGetBluetoothEnableState = 0x200ef,
+		};
+		
+		class BaseClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdBase;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			BaseClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Kinova::Api::Common::UserProfileHandle CreateUserProfile(const FullUserProfile& fulluserprofile, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateUserProfile_callback(const FullUserProfile& fulluserprofile, std::function< void (const Error&, const Kinova::Api::Common::UserProfileHandle&) > callback, uint32_t deviceId = 0);
+			std::future<Kinova::Api::Common::UserProfileHandle> CreateUserProfile_async(const FullUserProfile& fulluserprofile, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateUserProfile(const UserProfile& userprofile, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateUserProfile_callback(const UserProfile& userprofile, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateUserProfile_async(const UserProfile& userprofile, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			UserProfile ReadUserProfile(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadUserProfile_callback(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, std::function< void (const Error&, const UserProfile&) > callback, uint32_t deviceId = 0);
+			std::future<UserProfile> ReadUserProfile_async(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteUserProfile(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteUserProfile_callback(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteUserProfile_async(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			UserProfileList ReadAllUserProfiles(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllUserProfiles_callback(std::function< void (const Error&, const UserProfileList&) > callback, uint32_t deviceId = 0);
+			std::future<UserProfileList> ReadAllUserProfiles_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			UserList ReadAllUsers(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllUsers_callback(std::function< void (const Error&, const UserList&) > callback, uint32_t deviceId = 0);
+			std::future<UserList> ReadAllUsers_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ChangePassword(const PasswordChange& passwordchange, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ChangePassword_callback(const PasswordChange& passwordchange, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ChangePassword_async(const PasswordChange& passwordchange, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceHandle CreateSequence(const Sequence& sequence, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateSequence_callback(const Sequence& sequence, std::function< void (const Error&, const SequenceHandle&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceHandle> CreateSequence_async(const Sequence& sequence, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateSequence(const Sequence& sequence, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateSequence_callback(const Sequence& sequence, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateSequence_async(const Sequence& sequence, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Sequence ReadSequence(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadSequence_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&, const Sequence&) > callback, uint32_t deviceId = 0);
+			std::future<Sequence> ReadSequence_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteSequence(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteSequence_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteSequence_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceList ReadAllSequences(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllSequences_callback(std::function< void (const Error&, const SequenceList&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceList> ReadAllSequences_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PlaySequence(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PlaySequence_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PlaySequence_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PlayAdvancedSequence(const AdvancedSequenceHandle& advancedsequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PlayAdvancedSequence_callback(const AdvancedSequenceHandle& advancedsequencehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PlayAdvancedSequence_async(const AdvancedSequenceHandle& advancedsequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopSequence(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopSequence_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopSequence_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PauseSequence(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PauseSequence_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PauseSequence_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ResumeSequence(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResumeSequence_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ResumeSequence_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ProtectionZoneHandle CreateProtectionZone(const ProtectionZone& protectionzone, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateProtectionZone_callback(const ProtectionZone& protectionzone, std::function< void (const Error&, const ProtectionZoneHandle&) > callback, uint32_t deviceId = 0);
+			std::future<ProtectionZoneHandle> CreateProtectionZone_async(const ProtectionZone& protectionzone, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateProtectionZone(const ProtectionZone& protectionzone, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateProtectionZone_callback(const ProtectionZone& protectionzone, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateProtectionZone_async(const ProtectionZone& protectionzone, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ProtectionZone ReadProtectionZone(const ProtectionZoneHandle& protectionzonehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadProtectionZone_callback(const ProtectionZoneHandle& protectionzonehandle, std::function< void (const Error&, const ProtectionZone&) > callback, uint32_t deviceId = 0);
+			std::future<ProtectionZone> ReadProtectionZone_async(const ProtectionZoneHandle& protectionzonehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteProtectionZone(const ProtectionZoneHandle& protectionzonehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteProtectionZone_callback(const ProtectionZoneHandle& protectionzonehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteProtectionZone_async(const ProtectionZoneHandle& protectionzonehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ProtectionZoneList ReadAllProtectionZones(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllProtectionZones_callback(std::function< void (const Error&, const ProtectionZoneList&) > callback, uint32_t deviceId = 0);
+			std::future<ProtectionZoneList> ReadAllProtectionZones_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MappingHandle CreateMapping(const Mapping& mapping, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateMapping_callback(const Mapping& mapping, std::function< void (const Error&, const MappingHandle&) > callback, uint32_t deviceId = 0);
+			std::future<MappingHandle> CreateMapping_async(const Mapping& mapping, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Mapping ReadMapping(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadMapping_callback(const MappingHandle& mappinghandle, std::function< void (const Error&, const Mapping&) > callback, uint32_t deviceId = 0);
+			std::future<Mapping> ReadMapping_async(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateMapping(const Mapping& mapping, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateMapping_callback(const Mapping& mapping, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateMapping_async(const Mapping& mapping, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteMapping(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteMapping_callback(const MappingHandle& mappinghandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteMapping_async(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MappingList ReadAllMappings(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllMappings_callback(std::function< void (const Error&, const MappingList&) > callback, uint32_t deviceId = 0);
+			std::future<MappingList> ReadAllMappings_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MapHandle CreateMap(const Map& map, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateMap_callback(const Map& map, std::function< void (const Error&, const MapHandle&) > callback, uint32_t deviceId = 0);
+			std::future<MapHandle> CreateMap_async(const Map& map, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Map ReadMap(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadMap_callback(const MapHandle& maphandle, std::function< void (const Error&, const Map&) > callback, uint32_t deviceId = 0);
+			std::future<Map> ReadMap_async(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateMap(const Map& map, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateMap_callback(const Map& map, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateMap_async(const Map& map, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteMap(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteMap_callback(const MapHandle& maphandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteMap_async(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MapList ReadAllMaps(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllMaps_callback(const MappingHandle& mappinghandle, std::function< void (const Error&, const MapList&) > callback, uint32_t deviceId = 0);
+			std::future<MapList> ReadAllMaps_async(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ActivateMap(const ActivateMapHandle& activatemaphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ActivateMap_callback(const ActivateMapHandle& activatemaphandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ActivateMap_async(const ActivateMapHandle& activatemaphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ActionHandle CreateAction(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateAction_callback(const Action& action, std::function< void (const Error&, const ActionHandle&) > callback, uint32_t deviceId = 0);
+			std::future<ActionHandle> CreateAction_async(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Action ReadAction(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAction_callback(const ActionHandle& actionhandle, std::function< void (const Error&, const Action&) > callback, uint32_t deviceId = 0);
+			std::future<Action> ReadAction_async(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ActionList ReadAllActions(const RequestedActionType& requestedactiontype, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllActions_callback(const RequestedActionType& requestedactiontype, std::function< void (const Error&, const ActionList&) > callback, uint32_t deviceId = 0);
+			std::future<ActionList> ReadAllActions_async(const RequestedActionType& requestedactiontype, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteAction(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteAction_callback(const ActionHandle& actionhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteAction_async(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateAction(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateAction_callback(const Action& action, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateAction_async(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ExecuteActionFromReference(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ExecuteActionFromReference_callback(const ActionHandle& actionhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ExecuteActionFromReference_async(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ExecuteAction(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ExecuteAction_callback(const Action& action, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ExecuteAction_async(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PauseAction(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PauseAction_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PauseAction_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopAction(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopAction_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopAction_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ResumeAction(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResumeAction_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ResumeAction_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IPv4Configuration GetIPv4Configuration(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIPv4Configuration_callback(const NetworkHandle& networkhandle, std::function< void (const Error&, const IPv4Configuration&) > callback, uint32_t deviceId = 0);
+			std::future<IPv4Configuration> GetIPv4Configuration_async(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetIPv4Configuration(const FullIPv4Configuration& fullipv4configuration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetIPv4Configuration_callback(const FullIPv4Configuration& fullipv4configuration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetIPv4Configuration_async(const FullIPv4Configuration& fullipv4configuration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCommunicationInterfaceEnable(const CommunicationInterfaceConfiguration& communicationinterfaceconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCommunicationInterfaceEnable_callback(const CommunicationInterfaceConfiguration& communicationinterfaceconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCommunicationInterfaceEnable_async(const CommunicationInterfaceConfiguration& communicationinterfaceconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CommunicationInterfaceConfiguration IsCommunicationInterfaceEnable(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void IsCommunicationInterfaceEnable_callback(const NetworkHandle& networkhandle, std::function< void (const Error&, const CommunicationInterfaceConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<CommunicationInterfaceConfiguration> IsCommunicationInterfaceEnable_async(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiInformationList GetAvailableWifi(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAvailableWifi_callback(std::function< void (const Error&, const WifiInformationList&) > callback, uint32_t deviceId = 0);
+			std::future<WifiInformationList> GetAvailableWifi_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiInformation GetWifiInformation(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetWifiInformation_callback(const Ssid& ssid, std::function< void (const Error&, const WifiInformation&) > callback, uint32_t deviceId = 0);
+			std::future<WifiInformation> GetWifiInformation_async(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void AddWifiConfiguration(const WifiConfiguration& wificonfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void AddWifiConfiguration_callback(const WifiConfiguration& wificonfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> AddWifiConfiguration_async(const WifiConfiguration& wificonfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteWifiConfiguration(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteWifiConfiguration_callback(const Ssid& ssid, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteWifiConfiguration_async(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiConfigurationList GetAllConfiguredWifis(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllConfiguredWifis_callback(std::function< void (const Error&, const WifiConfigurationList&) > callback, uint32_t deviceId = 0);
+			std::future<WifiConfigurationList> GetAllConfiguredWifis_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ConnectWifi(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ConnectWifi_callback(const Ssid& ssid, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ConnectWifi_async(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DisconnectWifi(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DisconnectWifi_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DisconnectWifi_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiInformation GetConnectedWifiInformation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetConnectedWifiInformation_callback(std::function< void (const Error&, const WifiInformation&) > callback, uint32_t deviceId = 0);
+			std::future<WifiInformation> GetConnectedWifiInformation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Unsubscribe(const Kinova::Api::Common::NotificationHandle& notificationhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationConfigurationChangeTopic(std::function< void (ConfigurationChangeNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationMappingInfoTopic(std::function< void (MappingInfoNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationOperatingModeTopic(std::function< void (OperatingModeNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationSequenceInfoTopic(std::function< void (SequenceInfoNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationProtectionZoneTopic(std::function< void (ProtectionZoneNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationUserTopic(std::function< void (UserNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationControllerTopic(std::function< void (ControllerNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationActionTopic(std::function< void (ActionNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationRobotEventTopic(std::function< void (RobotEventNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlayCartesianTrajectory(const ConstrainedPose& constrainedpose, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlayCartesianTrajectory_callback(const ConstrainedPose& constrainedpose, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlayCartesianTrajectory_async(const ConstrainedPose& constrainedpose, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlayCartesianTrajectoryPosition(const ConstrainedPosition& constrainedposition, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlayCartesianTrajectoryPosition_callback(const ConstrainedPosition& constrainedposition, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlayCartesianTrajectoryPosition_async(const ConstrainedPosition& constrainedposition, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlayCartesianTrajectoryOrientation(const ConstrainedOrientation& constrainedorientation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlayCartesianTrajectoryOrientation_callback(const ConstrainedOrientation& constrainedorientation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlayCartesianTrajectoryOrientation_async(const ConstrainedOrientation& constrainedorientation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Stop(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Stop_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Stop_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Pose GetMeasuredCartesianPose(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetMeasuredCartesianPose_callback(std::function< void (const Error&, const Pose&) > callback, uint32_t deviceId = 0);
+			std::future<Pose> GetMeasuredCartesianPose_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendWrenchCommand(const WrenchCommand& wrenchcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendWrenchCommand_callback(const WrenchCommand& wrenchcommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendWrenchCommand_async(const WrenchCommand& wrenchcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendWrenchJoystickCommand(const WrenchCommand& wrenchcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendWrenchJoystickCommand_callback(const WrenchCommand& wrenchcommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendWrenchJoystickCommand_async(const WrenchCommand& wrenchcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendTwistJoystickCommand(const TwistCommand& twistcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendTwistJoystickCommand_callback(const TwistCommand& twistcommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendTwistJoystickCommand_async(const TwistCommand& twistcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendTwistCommand(const TwistCommand& twistcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendTwistCommand_callback(const TwistCommand& twistcommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendTwistCommand_async(const TwistCommand& twistcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlayJointTrajectory(const ConstrainedJointAngles& constrainedjointangles, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlayJointTrajectory_callback(const ConstrainedJointAngles& constrainedjointangles, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlayJointTrajectory_async(const ConstrainedJointAngles& constrainedjointangles, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlaySelectedJointTrajectory(const ConstrainedJointAngle& constrainedjointangle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlaySelectedJointTrajectory_callback(const ConstrainedJointAngle& constrainedjointangle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlaySelectedJointTrajectory_async(const ConstrainedJointAngle& constrainedjointangle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			JointAngles GetMeasuredJointAngles(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetMeasuredJointAngles_callback(std::function< void (const Error&, const JointAngles&) > callback, uint32_t deviceId = 0);
+			std::future<JointAngles> GetMeasuredJointAngles_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendJointSpeedsCommand(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendJointSpeedsCommand_callback(const JointSpeeds& jointspeeds, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendJointSpeedsCommand_async(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendSelectedJointSpeedCommand(const JointSpeed& jointspeed, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendSelectedJointSpeedCommand_callback(const JointSpeed& jointspeed, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendSelectedJointSpeedCommand_async(const JointSpeed& jointspeed, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendGripperCommand(const GripperCommand& grippercommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendGripperCommand_callback(const GripperCommand& grippercommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendGripperCommand_async(const GripperCommand& grippercommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Gripper GetMeasuredGripperMovement(const GripperRequest& gripperrequest, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetMeasuredGripperMovement_callback(const GripperRequest& gripperrequest, std::function< void (const Error&, const Gripper&) > callback, uint32_t deviceId = 0);
+			std::future<Gripper> GetMeasuredGripperMovement_async(const GripperRequest& gripperrequest, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetAdmittance(const Admittance& admittance, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetAdmittance_callback(const Admittance& admittance, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetAdmittance_async(const Admittance& admittance, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetOperatingMode(const OperatingModeInformation& operatingmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetOperatingMode_callback(const OperatingModeInformation& operatingmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetOperatingMode_async(const OperatingModeInformation& operatingmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ApplyEmergencyStop(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ApplyEmergencyStop_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ApplyEmergencyStop_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ClearFaults(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ClearFaults_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ClearFaults_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			OperatingModeInformation GetOperatingMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetOperatingMode_callback(std::function< void (const Error&, const OperatingModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<OperatingModeInformation> GetOperatingMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetServoingMode(const ServoingModeInformation& servoingmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetServoingMode_callback(const ServoingModeInformation& servoingmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetServoingMode_async(const ServoingModeInformation& servoingmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ServoingModeInformation GetServoingMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetServoingMode_callback(std::function< void (const Error&, const ServoingModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ServoingModeInformation> GetServoingMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationServoingModeTopic(std::function< void (ServoingModeNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RestoreFactorySettings(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RestoreFactorySettings_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RestoreFactorySettings_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Reboot(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Reboot_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Reboot_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationFactoryTopic(std::function< void (FactoryNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerList GetAllConnectedControllers(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllConnectedControllers_callback(std::function< void (const Error&, const ControllerList&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerList> GetAllConnectedControllers_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerState GetControllerState(const ControllerHandle& controllerhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControllerState_callback(const ControllerHandle& controllerhandle, std::function< void (const Error&, const ControllerState&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerState> GetControllerState_async(const ControllerHandle& controllerhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ActuatorInformation GetActuatorCount(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetActuatorCount_callback(std::function< void (const Error&, const ActuatorInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ActuatorInformation> GetActuatorCount_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartWifiScan(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartWifiScan_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartWifiScan_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiConfiguration GetConfiguredWifi(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetConfiguredWifi_callback(const Ssid& ssid, std::function< void (const Error&, const WifiConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<WifiConfiguration> GetConfiguredWifi_async(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationNetworkTopic(std::function< void (NetworkNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ArmStateInformation GetArmState(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetArmState_callback(std::function< void (const Error&, const ArmStateInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ArmStateInformation> GetArmState_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationArmStateTopic(std::function< void (ArmStateNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IPv4Information GetIPv4Information(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIPv4Information_callback(const NetworkHandle& networkhandle, std::function< void (const Error&, const IPv4Information&) > callback, uint32_t deviceId = 0);
+			std::future<IPv4Information> GetIPv4Information_async(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetWifiCountryCode(const Kinova::Api::Common::CountryCode& countrycode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetWifiCountryCode_callback(const Kinova::Api::Common::CountryCode& countrycode, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetWifiCountryCode_async(const Kinova::Api::Common::CountryCode& countrycode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::CountryCode GetWifiCountryCode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetWifiCountryCode_callback(std::function< void (const Error&, const Kinova::Api::Common::CountryCode&) > callback, uint32_t deviceId = 0);
+			std::future<Kinova::Api::Common::CountryCode> GetWifiCountryCode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCapSenseConfig(const CapSenseConfig& capsenseconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCapSenseConfig_callback(const CapSenseConfig& capsenseconfig, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCapSenseConfig_async(const CapSenseConfig& capsenseconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CapSenseConfig GetCapSenseConfig(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCapSenseConfig_callback(std::function< void (const Error&, const CapSenseConfig&) > callback, uint32_t deviceId = 0);
+			std::future<CapSenseConfig> GetCapSenseConfig_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED JointsLimitationsList GetAllJointsTorqueHardLimitation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void GetAllJointsTorqueHardLimitation_callback(std::function< void (const Error&, const JointsLimitationsList&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<JointsLimitationsList> GetAllJointsTorqueHardLimitation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED WrenchLimitation GetWrenchHardLimitation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void GetWrenchHardLimitation_callback(std::function< void (const Error&, const WrenchLimitation&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<WrenchLimitation> GetWrenchHardLimitation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendJointSpeedsJoystickCommand(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendJointSpeedsJoystickCommand_callback(const JointSpeeds& jointspeeds, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendJointSpeedsJoystickCommand_async(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendSelectedJointSpeedJoystickCommand(const JointSpeed& jointspeed, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendSelectedJointSpeedJoystickCommand_callback(const JointSpeed& jointspeed, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendSelectedJointSpeedJoystickCommand_async(const JointSpeed& jointspeed, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BridgeResult EnableBridge(const BridgeConfig& bridgeconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void EnableBridge_callback(const BridgeConfig& bridgeconfig, std::function< void (const Error&, const BridgeResult&) > callback, uint32_t deviceId = 0);
+			std::future<BridgeResult> EnableBridge_async(const BridgeConfig& bridgeconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BridgeResult DisableBridge(const BridgeIdentifier& bridgeidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DisableBridge_callback(const BridgeIdentifier& bridgeidentifier, std::function< void (const Error&, const BridgeResult&) > callback, uint32_t deviceId = 0);
+			std::future<BridgeResult> DisableBridge_async(const BridgeIdentifier& bridgeidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BridgeList GetBridgeList(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetBridgeList_callback(std::function< void (const Error&, const BridgeList&) > callback, uint32_t deviceId = 0);
+			std::future<BridgeList> GetBridgeList_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BridgeConfig GetBridgeConfig(const BridgeIdentifier& bridgeidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetBridgeConfig_callback(const BridgeIdentifier& bridgeidentifier, std::function< void (const Error&, const BridgeConfig&) > callback, uint32_t deviceId = 0);
+			std::future<BridgeConfig> GetBridgeConfig_async(const BridgeIdentifier& bridgeidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PlayPreComputedJointTrajectory(const PreComputedJointTrajectory& precomputedjointtrajectory, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PlayPreComputedJointTrajectory_callback(const PreComputedJointTrajectory& precomputedjointtrajectory, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PlayPreComputedJointTrajectory_async(const PreComputedJointTrajectory& precomputedjointtrajectory, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::ProductConfiguration::CompleteProductConfiguration GetProductConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetProductConfiguration_callback(std::function< void (const Error&, const Kinova::Api::ProductConfiguration::CompleteProductConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<Kinova::Api::ProductConfiguration::CompleteProductConfiguration> GetProductConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateEndEffectorTypeConfiguration(const Kinova::Api::ProductConfiguration::ProductConfigurationEndEffectorType& productconfigurationendeffectortype, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateEndEffectorTypeConfiguration_callback(const Kinova::Api::ProductConfiguration::ProductConfigurationEndEffectorType& productconfigurationendeffectortype, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateEndEffectorTypeConfiguration_async(const Kinova::Api::ProductConfiguration::ProductConfigurationEndEffectorType& productconfigurationendeffectortype, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RestoreFactoryProductConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RestoreFactoryProductConfiguration_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RestoreFactoryProductConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TrajectoryErrorReport GetTrajectoryErrorReport(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetTrajectoryErrorReport_callback(std::function< void (const Error&, const TrajectoryErrorReport&) > callback, uint32_t deviceId = 0);
+			std::future<TrajectoryErrorReport> GetTrajectoryErrorReport_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED JointsLimitationsList GetAllJointsTorqueSoftLimitation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void GetAllJointsTorqueSoftLimitation_callback(std::function< void (const Error&, const JointsLimitationsList&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<JointsLimitationsList> GetAllJointsTorqueSoftLimitation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED WrenchLimitation GetWrenchSoftLimitation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void GetWrenchSoftLimitation_callback(std::function< void (const Error&, const WrenchLimitation&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<WrenchLimitation> GetWrenchSoftLimitation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetControllerConfigurationMode(const ControllerConfigurationMode& controllerconfigurationmode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetControllerConfigurationMode_callback(const ControllerConfigurationMode& controllerconfigurationmode, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetControllerConfigurationMode_async(const ControllerConfigurationMode& controllerconfigurationmode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerConfigurationMode GetControllerConfigurationMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControllerConfigurationMode_callback(std::function< void (const Error&, const ControllerConfigurationMode&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerConfigurationMode> GetControllerConfigurationMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartTeaching(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartTeaching_callback(const SequenceTaskHandle& sequencetaskhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartTeaching_async(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopTeaching(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopTeaching_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopTeaching_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceTasksRange AddSequenceTasks(const SequenceTasksConfiguration& sequencetasksconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void AddSequenceTasks_callback(const SequenceTasksConfiguration& sequencetasksconfiguration, std::function< void (const Error&, const SequenceTasksRange&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceTasksRange> AddSequenceTasks_async(const SequenceTasksConfiguration& sequencetasksconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateSequenceTask(const SequenceTaskConfiguration& sequencetaskconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateSequenceTask_callback(const SequenceTaskConfiguration& sequencetaskconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateSequenceTask_async(const SequenceTaskConfiguration& sequencetaskconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SwapSequenceTasks(const SequenceTasksPair& sequencetaskspair, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SwapSequenceTasks_callback(const SequenceTasksPair& sequencetaskspair, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SwapSequenceTasks_async(const SequenceTasksPair& sequencetaskspair, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceTask ReadSequenceTask(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadSequenceTask_callback(const SequenceTaskHandle& sequencetaskhandle, std::function< void (const Error&, const SequenceTask&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceTask> ReadSequenceTask_async(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceTasks ReadAllSequenceTasks(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllSequenceTasks_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&, const SequenceTasks&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceTasks> ReadAllSequenceTasks_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteSequenceTask(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteSequenceTask_callback(const SequenceTaskHandle& sequencetaskhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteSequenceTask_async(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteAllSequenceTasks(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteAllSequenceTasks_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteAllSequenceTasks_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TakeSnapshot(const Snapshot& snapshot, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TakeSnapshot_callback(const Snapshot& snapshot, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TakeSnapshot_async(const Snapshot& snapshot, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			FirmwareBundleVersions GetFirmwareBundleVersions(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetFirmwareBundleVersions_callback(std::function< void (const Error&, const FirmwareBundleVersions&) > callback, uint32_t deviceId = 0);
+			std::future<FirmwareBundleVersions> GetFirmwareBundleVersions_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ExecuteWaypointTrajectory(const WaypointList& waypointlist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ExecuteWaypointTrajectory_callback(const WaypointList& waypointlist, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ExecuteWaypointTrajectory_async(const WaypointList& waypointlist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void MoveSequenceTask(const SequenceTasksPair& sequencetaskspair, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void MoveSequenceTask_callback(const SequenceTasksPair& sequencetaskspair, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> MoveSequenceTask_async(const SequenceTasksPair& sequencetaskspair, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MappingHandle DuplicateMapping(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DuplicateMapping_callback(const MappingHandle& mappinghandle, std::function< void (const Error&, const MappingHandle&) > callback, uint32_t deviceId = 0);
+			std::future<MappingHandle> DuplicateMapping_async(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MapHandle DuplicateMap(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DuplicateMap_callback(const MapHandle& maphandle, std::function< void (const Error&, const MapHandle&) > callback, uint32_t deviceId = 0);
+			std::future<MapHandle> DuplicateMap_async(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetControllerConfiguration(const ControllerConfiguration& controllerconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetControllerConfiguration_callback(const ControllerConfiguration& controllerconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetControllerConfiguration_async(const ControllerConfiguration& controllerconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerConfiguration GetControllerConfiguration(const ControllerHandle& controllerhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControllerConfiguration_callback(const ControllerHandle& controllerhandle, std::function< void (const Error&, const ControllerConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerConfiguration> GetControllerConfiguration_async(const ControllerHandle& controllerhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerConfigurationList GetAllControllerConfigurations(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllControllerConfigurations_callback(std::function< void (const Error&, const ControllerConfigurationList&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerConfigurationList> GetAllControllerConfigurations_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Pose ComputeForwardKinematics(const JointAngles& jointangles, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ComputeForwardKinematics_callback(const JointAngles& jointangles, std::function< void (const Error&, const Pose&) > callback, uint32_t deviceId = 0);
+			std::future<Pose> ComputeForwardKinematics_async(const JointAngles& jointangles, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			JointAngles ComputeInverseKinematics(const IKData& ikdata, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ComputeInverseKinematics_callback(const IKData& ikdata, std::function< void (const Error&, const JointAngles&) > callback, uint32_t deviceId = 0);
+			std::future<JointAngles> ComputeInverseKinematics_async(const IKData& ikdata, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WaypointValidationReport ValidateWaypointList(const WaypointList& waypointlist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ValidateWaypointList_callback(const WaypointList& waypointlist, std::function< void (const Error&, const WaypointValidationReport&) > callback, uint32_t deviceId = 0);
+			std::future<WaypointValidationReport> ValidateWaypointList_async(const WaypointList& waypointlist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetWifiEnableState(const WifiEnableState& wifienablestate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetWifiEnableState_callback(const WifiEnableState& wifienablestate, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetWifiEnableState_async(const WifiEnableState& wifienablestate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiEnableState GetWifiEnableState(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetWifiEnableState_callback(std::function< void (const Error&, const WifiEnableState&) > callback, uint32_t deviceId = 0);
+			std::future<WifiEnableState> GetWifiEnableState_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetBluetoothEnableState(const BluetoothEnableState& bluetoothenablestate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetBluetoothEnableState_callback(const BluetoothEnableState& bluetoothenablestate, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetBluetoothEnableState_async(const BluetoothEnableState& bluetoothenablestate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BluetoothEnableState GetBluetoothEnableState(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetBluetoothEnableState_callback(std::function< void (const Error&, const BluetoothEnableState&) > callback, uint32_t deviceId = 0);
+			std::future<BluetoothEnableState> GetBluetoothEnableState_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/BaseCyclicClientRpc.h

@@ -0,0 +1,83 @@
+#ifndef __BASECYCLICCLIENT_H__
+#define __BASECYCLICCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/BaseCyclic.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace BaseCyclic
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidRefresh = 0x30001,
+			eUidRefreshCommand = 0x30002,
+			eUidRefreshFeedback = 0x30003,
+			eUidRefreshCustomData = 0x30004,
+		};
+		
+		class BaseCyclicClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdBaseCyclic;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			BaseCyclicClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Feedback Refresh(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Refresh_callback(const Command& command, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> Refresh_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RefreshCommand(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCommand_callback(const Command& command, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RefreshCommand_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Feedback RefreshFeedback(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshFeedback_callback(std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> RefreshFeedback_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomData RefreshCustomData(const CustomData& customdata, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCustomData_callback(const CustomData& customdata, std::function< void (const Error&, const CustomData&) > callback, uint32_t deviceId = 0);
+			std::future<CustomData> RefreshCustomData_async(const CustomData& customdata, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/ControlConfigClientRpc.h

@@ -0,0 +1,207 @@
+#ifndef __CONTROLCONFIGCLIENT_H__
+#define __CONTROLCONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/ControlConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace ControlConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidSetGravityVector = 0x100001,
+			eUidGetGravityVector = 0x100002,
+			eUidSetPayloadInformation = 0x100003,
+			eUidGetPayloadInformation = 0x100004,
+			eUidSetToolConfiguration = 0x100005,
+			eUidGetToolConfiguration = 0x100006,
+			eUidControlConfigurationTopic = 0x100007,
+			eUidUnsubscribe = 0x100008,
+			eUidSetCartesianReferenceFrame = 0x100009,
+			eUidGetCartesianReferenceFrame = 0x10000a,
+			eUidGetControlMode = 0x10000d,
+			eUidSetJointSpeedSoftLimits = 0x10000e,
+			eUidSetTwistLinearSoftLimit = 0x10000f,
+			eUidSetTwistAngularSoftLimit = 0x100010,
+			eUidSetJointAccelerationSoftLimits = 0x100011,
+			eUidGetKinematicHardLimits = 0x100012,
+			eUidGetKinematicSoftLimits = 0x100013,
+			eUidGetAllKinematicSoftLimits = 0x100014,
+			eUidSetDesiredLinearTwist = 0x100015,
+			eUidSetDesiredAngularTwist = 0x100016,
+			eUidSetDesiredJointSpeeds = 0x100017,
+			eUidGetDesiredSpeeds = 0x100018,
+			eUidResetGravityVector = 0x100019,
+			eUidResetPayloadInformation = 0x10001a,
+			eUidResetToolConfiguration = 0x10001b,
+			eUidResetJointSpeedSoftLimits = 0x10001c,
+			eUidResetTwistLinearSoftLimit = 0x10001d,
+			eUidResetTwistAngularSoftLimit = 0x10001e,
+			eUidResetJointAccelerationSoftLimits = 0x10001f,
+			eUidControlModeTopic = 0x100020,
+		};
+		
+		class ControlConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdControlConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			ControlConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			void SetGravityVector(const GravityVector& gravityvector, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetGravityVector_callback(const GravityVector& gravityvector, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetGravityVector_async(const GravityVector& gravityvector, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			GravityVector GetGravityVector(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetGravityVector_callback(std::function< void (const Error&, const GravityVector&) > callback, uint32_t deviceId = 0);
+			std::future<GravityVector> GetGravityVector_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetPayloadInformation(const PayloadInformation& payloadinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetPayloadInformation_callback(const PayloadInformation& payloadinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetPayloadInformation_async(const PayloadInformation& payloadinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			PayloadInformation GetPayloadInformation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetPayloadInformation_callback(std::function< void (const Error&, const PayloadInformation&) > callback, uint32_t deviceId = 0);
+			std::future<PayloadInformation> GetPayloadInformation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetToolConfiguration(const ToolConfiguration& toolconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetToolConfiguration_callback(const ToolConfiguration& toolconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetToolConfiguration_async(const ToolConfiguration& toolconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ToolConfiguration GetToolConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetToolConfiguration_callback(std::function< void (const Error&, const ToolConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<ToolConfiguration> GetToolConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationControlConfigurationTopic(std::function< void (ControlConfigurationNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Unsubscribe(const Kinova::Api::Common::NotificationHandle& notificationhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCartesianReferenceFrame(const CartesianReferenceFrameInfo& cartesianreferenceframeinfo, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCartesianReferenceFrame_callback(const CartesianReferenceFrameInfo& cartesianreferenceframeinfo, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCartesianReferenceFrame_async(const CartesianReferenceFrameInfo& cartesianreferenceframeinfo, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CartesianReferenceFrameInfo GetCartesianReferenceFrame(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCartesianReferenceFrame_callback(std::function< void (const Error&, const CartesianReferenceFrameInfo&) > callback, uint32_t deviceId = 0);
+			std::future<CartesianReferenceFrameInfo> GetCartesianReferenceFrame_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControlModeInformation GetControlMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControlMode_callback(std::function< void (const Error&, const ControlModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ControlModeInformation> GetControlMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetJointSpeedSoftLimits(const JointSpeedSoftLimits& jointspeedsoftlimits, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetJointSpeedSoftLimits_callback(const JointSpeedSoftLimits& jointspeedsoftlimits, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetJointSpeedSoftLimits_async(const JointSpeedSoftLimits& jointspeedsoftlimits, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetTwistLinearSoftLimit(const TwistLinearSoftLimit& twistlinearsoftlimit, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetTwistLinearSoftLimit_callback(const TwistLinearSoftLimit& twistlinearsoftlimit, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetTwistLinearSoftLimit_async(const TwistLinearSoftLimit& twistlinearsoftlimit, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetTwistAngularSoftLimit(const TwistAngularSoftLimit& twistangularsoftlimit, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetTwistAngularSoftLimit_callback(const TwistAngularSoftLimit& twistangularsoftlimit, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetTwistAngularSoftLimit_async(const TwistAngularSoftLimit& twistangularsoftlimit, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetJointAccelerationSoftLimits(const JointAccelerationSoftLimits& jointaccelerationsoftlimits, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetJointAccelerationSoftLimits_callback(const JointAccelerationSoftLimits& jointaccelerationsoftlimits, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetJointAccelerationSoftLimits_async(const JointAccelerationSoftLimits& jointaccelerationsoftlimits, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			KinematicLimits GetKinematicHardLimits(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetKinematicHardLimits_callback(std::function< void (const Error&, const KinematicLimits&) > callback, uint32_t deviceId = 0);
+			std::future<KinematicLimits> GetKinematicHardLimits_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			KinematicLimits GetKinematicSoftLimits(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetKinematicSoftLimits_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const KinematicLimits&) > callback, uint32_t deviceId = 0);
+			std::future<KinematicLimits> GetKinematicSoftLimits_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			KinematicLimitsList GetAllKinematicSoftLimits(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllKinematicSoftLimits_callback(std::function< void (const Error&, const KinematicLimitsList&) > callback, uint32_t deviceId = 0);
+			std::future<KinematicLimitsList> GetAllKinematicSoftLimits_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetDesiredLinearTwist(const LinearTwist& lineartwist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetDesiredLinearTwist_callback(const LinearTwist& lineartwist, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetDesiredLinearTwist_async(const LinearTwist& lineartwist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetDesiredAngularTwist(const AngularTwist& angulartwist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetDesiredAngularTwist_callback(const AngularTwist& angulartwist, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetDesiredAngularTwist_async(const AngularTwist& angulartwist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetDesiredJointSpeeds(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetDesiredJointSpeeds_callback(const JointSpeeds& jointspeeds, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetDesiredJointSpeeds_async(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DesiredSpeeds GetDesiredSpeeds(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetDesiredSpeeds_callback(std::function< void (const Error&, const DesiredSpeeds&) > callback, uint32_t deviceId = 0);
+			std::future<DesiredSpeeds> GetDesiredSpeeds_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			GravityVector ResetGravityVector(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetGravityVector_callback(std::function< void (const Error&, const GravityVector&) > callback, uint32_t deviceId = 0);
+			std::future<GravityVector> ResetGravityVector_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			PayloadInformation ResetPayloadInformation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetPayloadInformation_callback(std::function< void (const Error&, const PayloadInformation&) > callback, uint32_t deviceId = 0);
+			std::future<PayloadInformation> ResetPayloadInformation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ToolConfiguration ResetToolConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetToolConfiguration_callback(std::function< void (const Error&, const ToolConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<ToolConfiguration> ResetToolConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			JointSpeedSoftLimits ResetJointSpeedSoftLimits(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetJointSpeedSoftLimits_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const JointSpeedSoftLimits&) > callback, uint32_t deviceId = 0);
+			std::future<JointSpeedSoftLimits> ResetJointSpeedSoftLimits_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TwistLinearSoftLimit ResetTwistLinearSoftLimit(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetTwistLinearSoftLimit_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const TwistLinearSoftLimit&) > callback, uint32_t deviceId = 0);
+			std::future<TwistLinearSoftLimit> ResetTwistLinearSoftLimit_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TwistAngularSoftLimit ResetTwistAngularSoftLimit(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetTwistAngularSoftLimit_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const TwistAngularSoftLimit&) > callback, uint32_t deviceId = 0);
+			std::future<TwistAngularSoftLimit> ResetTwistAngularSoftLimit_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			JointAccelerationSoftLimits ResetJointAccelerationSoftLimits(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetJointAccelerationSoftLimits_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const JointAccelerationSoftLimits&) > callback, uint32_t deviceId = 0);
+			std::future<JointAccelerationSoftLimits> ResetJointAccelerationSoftLimits_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationControlModeTopic(std::function< void (ControlModeNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/DeviceConfigClientRpc.h

@@ -0,0 +1,230 @@
+#ifndef __DEVICECONFIGCLIENT_H__
+#define __DEVICECONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+#include "messages/Frame.pb.h"
+#include "messages/DeviceConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace DeviceConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidGetRunMode = 0x90001,
+			eUidSetRunMode = 0x90002,
+			eUidGetDeviceType = 0x90003,
+			eUidGetFirmwareVersion = 0x90004,
+			eUidGetBootloaderVersion = 0x90005,
+			eUidGetModelNumber = 0x90006,
+			eUidGetPartNumber = 0x90007,
+			eUidGetSerialNumber = 0x90008,
+			eUidGetMACAddress = 0x90009,
+			eUidGetIPv4Settings = 0x9000a,
+			eUidSetIPv4Settings = 0x9000b,
+			eUidGetPartNumberRevision = 0x9000c,
+			eUidRebootRequest = 0x9000e,
+			eUidSetSafetyEnable = 0x9000f,
+			eUidSetSafetyErrorThreshold = 0x90010,
+			eUidSetSafetyWarningThreshold = 0x90011,
+			eUidSetSafetyConfiguration = 0x90012,
+			eUidGetSafetyConfiguration = 0x90013,
+			eUidGetSafetyInformation = 0x90014,
+			eUidGetSafetyEnable = 0x90015,
+			eUidGetSafetyStatus = 0x90016,
+			eUidClearAllSafetyStatus = 0x90017,
+			eUidClearSafetyStatus = 0x90018,
+			eUidGetAllSafetyConfiguration = 0x90019,
+			eUidGetAllSafetyInformation = 0x9001a,
+			eUidResetSafetyDefaults = 0x9001b,
+			eUidSafetyTopic = 0x9001c,
+			eUidExecuteCalibration = 0x90022,
+			eUidGetCalibrationResult = 0x90023,
+			eUidStopCalibration = 0x90024,
+			eUidSetCapSenseConfig = 0x90025,
+			eUidGetCapSenseConfig = 0x90026,
+			eUidReadCapSenseRegister = 0x90027,
+			eUidWriteCapSenseRegister = 0x90028,
+		};
+		
+		class DeviceConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdDeviceConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			DeviceConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			RunMode GetRunMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetRunMode_callback(std::function< void (const Error&, const RunMode&) > callback, uint32_t deviceId = 0);
+			std::future<RunMode> GetRunMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetRunMode(const RunMode& runmode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetRunMode_callback(const RunMode& runmode, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetRunMode_async(const RunMode& runmode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DeviceType GetDeviceType(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetDeviceType_callback(std::function< void (const Error&, const DeviceType&) > callback, uint32_t deviceId = 0);
+			std::future<DeviceType> GetDeviceType_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			FirmwareVersion GetFirmwareVersion(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetFirmwareVersion_callback(std::function< void (const Error&, const FirmwareVersion&) > callback, uint32_t deviceId = 0);
+			std::future<FirmwareVersion> GetFirmwareVersion_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BootloaderVersion GetBootloaderVersion(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetBootloaderVersion_callback(std::function< void (const Error&, const BootloaderVersion&) > callback, uint32_t deviceId = 0);
+			std::future<BootloaderVersion> GetBootloaderVersion_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ModelNumber GetModelNumber(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetModelNumber_callback(std::function< void (const Error&, const ModelNumber&) > callback, uint32_t deviceId = 0);
+			std::future<ModelNumber> GetModelNumber_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			PartNumber GetPartNumber(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetPartNumber_callback(std::function< void (const Error&, const PartNumber&) > callback, uint32_t deviceId = 0);
+			std::future<PartNumber> GetPartNumber_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SerialNumber GetSerialNumber(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSerialNumber_callback(std::function< void (const Error&, const SerialNumber&) > callback, uint32_t deviceId = 0);
+			std::future<SerialNumber> GetSerialNumber_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MACAddress GetMACAddress(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetMACAddress_callback(std::function< void (const Error&, const MACAddress&) > callback, uint32_t deviceId = 0);
+			std::future<MACAddress> GetMACAddress_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IPv4Settings GetIPv4Settings(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIPv4Settings_callback(std::function< void (const Error&, const IPv4Settings&) > callback, uint32_t deviceId = 0);
+			std::future<IPv4Settings> GetIPv4Settings_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetIPv4Settings(const IPv4Settings& ipv4settings, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetIPv4Settings_callback(const IPv4Settings& ipv4settings, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetIPv4Settings_async(const IPv4Settings& ipv4settings, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			PartNumberRevision GetPartNumberRevision(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetPartNumberRevision_callback(std::function< void (const Error&, const PartNumberRevision&) > callback, uint32_t deviceId = 0);
+			std::future<PartNumberRevision> GetPartNumberRevision_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RebootRequest(const RebootRqst& rebootrqst, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RebootRequest_callback(const RebootRqst& rebootrqst, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RebootRequest_async(const RebootRqst& rebootrqst, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetSafetyEnable(const SafetyEnable& safetyenable, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSafetyEnable_callback(const SafetyEnable& safetyenable, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSafetyEnable_async(const SafetyEnable& safetyenable, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetSafetyErrorThreshold(const SafetyThreshold& safetythreshold, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSafetyErrorThreshold_callback(const SafetyThreshold& safetythreshold, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSafetyErrorThreshold_async(const SafetyThreshold& safetythreshold, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetSafetyWarningThreshold(const SafetyThreshold& safetythreshold, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSafetyWarningThreshold_callback(const SafetyThreshold& safetythreshold, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSafetyWarningThreshold_async(const SafetyThreshold& safetythreshold, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetSafetyConfiguration(const SafetyConfiguration& safetyconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSafetyConfiguration_callback(const SafetyConfiguration& safetyconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSafetyConfiguration_async(const SafetyConfiguration& safetyconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyConfiguration GetSafetyConfiguration(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSafetyConfiguration_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&, const SafetyConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyConfiguration> GetSafetyConfiguration_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyInformation GetSafetyInformation(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSafetyInformation_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&, const SafetyInformation&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyInformation> GetSafetyInformation_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyEnable GetSafetyEnable(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSafetyEnable_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&, const SafetyEnable&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyEnable> GetSafetyEnable_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyStatus GetSafetyStatus(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSafetyStatus_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&, const SafetyStatus&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyStatus> GetSafetyStatus_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ClearAllSafetyStatus(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ClearAllSafetyStatus_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ClearAllSafetyStatus_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ClearSafetyStatus(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ClearSafetyStatus_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ClearSafetyStatus_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyConfigurationList GetAllSafetyConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllSafetyConfiguration_callback(std::function< void (const Error&, const SafetyConfigurationList&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyConfigurationList> GetAllSafetyConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyInformationList GetAllSafetyInformation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllSafetyInformation_callback(std::function< void (const Error&, const SafetyInformationList&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyInformationList> GetAllSafetyInformation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ResetSafetyDefaults(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetSafetyDefaults_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ResetSafetyDefaults_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationSafetyTopic(std::function< void (Kinova::Api::Common::SafetyNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ExecuteCalibration(const Calibration& calibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ExecuteCalibration_callback(const Calibration& calibration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ExecuteCalibration_async(const Calibration& calibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CalibrationResult GetCalibrationResult(const CalibrationElement& calibrationelement, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCalibrationResult_callback(const CalibrationElement& calibrationelement, std::function< void (const Error&, const CalibrationResult&) > callback, uint32_t deviceId = 0);
+			std::future<CalibrationResult> GetCalibrationResult_async(const CalibrationElement& calibrationelement, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CalibrationResult StopCalibration(const Calibration& calibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopCalibration_callback(const Calibration& calibration, std::function< void (const Error&, const CalibrationResult&) > callback, uint32_t deviceId = 0);
+			std::future<CalibrationResult> StopCalibration_async(const Calibration& calibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCapSenseConfig(const CapSenseConfig& capsenseconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCapSenseConfig_callback(const CapSenseConfig& capsenseconfig, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCapSenseConfig_async(const CapSenseConfig& capsenseconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CapSenseConfig GetCapSenseConfig(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCapSenseConfig_callback(std::function< void (const Error&, const CapSenseConfig&) > callback, uint32_t deviceId = 0);
+			std::future<CapSenseConfig> GetCapSenseConfig_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CapSenseRegister ReadCapSenseRegister(const CapSenseRegister& capsenseregister, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadCapSenseRegister_callback(const CapSenseRegister& capsenseregister, std::function< void (const Error&, const CapSenseRegister&) > callback, uint32_t deviceId = 0);
+			std::future<CapSenseRegister> ReadCapSenseRegister_async(const CapSenseRegister& capsenseregister, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void WriteCapSenseRegister(const CapSenseRegister& capsenseregister, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void WriteCapSenseRegister_callback(const CapSenseRegister& capsenseregister, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> WriteCapSenseRegister_async(const CapSenseRegister& capsenseregister, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/DeviceManagerClientRpc.h

@@ -0,0 +1,68 @@
+#ifndef __DEVICEMANAGERCLIENT_H__
+#define __DEVICEMANAGERCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/DeviceManager.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace DeviceManager
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidReadAllDevices = 0x170001,
+		};
+		
+		class DeviceManagerClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdDeviceManager;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			DeviceManagerClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			DeviceHandles ReadAllDevices(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllDevices_callback(std::function< void (const Error&, const DeviceHandles&) > callback, uint32_t deviceId = 0);
+			std::future<DeviceHandles> ReadAllDevices_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/GripperCyclicClientRpc.h

@@ -0,0 +1,83 @@
+#ifndef __GRIPPERCYCLICCLIENT_H__
+#define __GRIPPERCYCLICCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/GripperCyclic.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace GripperCyclic
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidRefresh = 0x110001,
+			eUidRefreshCommand = 0x110002,
+			eUidRefreshFeedback = 0x110003,
+			eUidRefreshCustomData = 0x110004,
+		};
+		
+		class GripperCyclicClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdGripperCyclic;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			GripperCyclicClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Feedback Refresh(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Refresh_callback(const Command& command, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> Refresh_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RefreshCommand(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCommand_callback(const Command& command, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RefreshCommand_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Feedback RefreshFeedback(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshFeedback_callback(const MessageId& messageid, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> RefreshFeedback_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomData RefreshCustomData(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCustomData_callback(const MessageId& messageid, std::function< void (const Error&, const CustomData&) > callback, uint32_t deviceId = 0);
+			std::future<CustomData> RefreshCustomData_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/InterconnectConfigClientRpc.h

@@ -0,0 +1,133 @@
+#ifndef __INTERCONNECTCONFIGCLIENT_H__
+#define __INTERCONNECTCONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/InterconnectConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace InterconnectConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidGetUARTConfiguration = 0xe0001,
+			eUidSetUARTConfiguration = 0xe0002,
+			eUidGetEthernetConfiguration = 0xe0003,
+			eUidSetEthernetConfiguration = 0xe0004,
+			eUidGetGPIOConfiguration = 0xe0005,
+			eUidSetGPIOConfiguration = 0xe0006,
+			eUidGetGPIOState = 0xe0007,
+			eUidSetGPIOState = 0xe0008,
+			eUidGetI2CConfiguration = 0xe0009,
+			eUidSetI2CConfiguration = 0xe000a,
+			eUidI2CRead = 0xe000b,
+			eUidI2CReadRegister = 0xe000c,
+			eUidI2CWrite = 0xe000d,
+			eUidI2CWriteRegister = 0xe000e,
+		};
+		
+		class InterconnectConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdInterconnectConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			InterconnectConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Kinova::Api::Common::UARTConfiguration GetUARTConfiguration(const Kinova::Api::Common::UARTDeviceIdentification& uartdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetUARTConfiguration_callback(const Kinova::Api::Common::UARTDeviceIdentification& uartdeviceidentification, std::function< void (const Error&, const Kinova::Api::Common::UARTConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<Kinova::Api::Common::UARTConfiguration> GetUARTConfiguration_async(const Kinova::Api::Common::UARTDeviceIdentification& uartdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetUARTConfiguration(const Kinova::Api::Common::UARTConfiguration& uartconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetUARTConfiguration_callback(const Kinova::Api::Common::UARTConfiguration& uartconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetUARTConfiguration_async(const Kinova::Api::Common::UARTConfiguration& uartconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			EthernetConfiguration GetEthernetConfiguration(const EthernetDeviceIdentification& ethernetdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetEthernetConfiguration_callback(const EthernetDeviceIdentification& ethernetdeviceidentification, std::function< void (const Error&, const EthernetConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<EthernetConfiguration> GetEthernetConfiguration_async(const EthernetDeviceIdentification& ethernetdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetEthernetConfiguration(const EthernetConfiguration& ethernetconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetEthernetConfiguration_callback(const EthernetConfiguration& ethernetconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetEthernetConfiguration_async(const EthernetConfiguration& ethernetconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			GPIOConfiguration GetGPIOConfiguration(const GPIOIdentification& gpioidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetGPIOConfiguration_callback(const GPIOIdentification& gpioidentification, std::function< void (const Error&, const GPIOConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<GPIOConfiguration> GetGPIOConfiguration_async(const GPIOIdentification& gpioidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetGPIOConfiguration(const GPIOConfiguration& gpioconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetGPIOConfiguration_callback(const GPIOConfiguration& gpioconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetGPIOConfiguration_async(const GPIOConfiguration& gpioconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			GPIOState GetGPIOState(const GPIOIdentification& gpioidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetGPIOState_callback(const GPIOIdentification& gpioidentification, std::function< void (const Error&, const GPIOState&) > callback, uint32_t deviceId = 0);
+			std::future<GPIOState> GetGPIOState_async(const GPIOIdentification& gpioidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetGPIOState(const GPIOState& gpiostate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetGPIOState_callback(const GPIOState& gpiostate, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetGPIOState_async(const GPIOState& gpiostate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			I2CConfiguration GetI2CConfiguration(const I2CDeviceIdentification& i2cdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetI2CConfiguration_callback(const I2CDeviceIdentification& i2cdeviceidentification, std::function< void (const Error&, const I2CConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<I2CConfiguration> GetI2CConfiguration_async(const I2CDeviceIdentification& i2cdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetI2CConfiguration(const I2CConfiguration& i2cconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetI2CConfiguration_callback(const I2CConfiguration& i2cconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetI2CConfiguration_async(const I2CConfiguration& i2cconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			I2CData I2CRead(const I2CReadParameter& i2creadparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void I2CRead_callback(const I2CReadParameter& i2creadparameter, std::function< void (const Error&, const I2CData&) > callback, uint32_t deviceId = 0);
+			std::future<I2CData> I2CRead_async(const I2CReadParameter& i2creadparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			I2CData I2CReadRegister(const I2CReadRegisterParameter& i2creadregisterparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void I2CReadRegister_callback(const I2CReadRegisterParameter& i2creadregisterparameter, std::function< void (const Error&, const I2CData&) > callback, uint32_t deviceId = 0);
+			std::future<I2CData> I2CReadRegister_async(const I2CReadRegisterParameter& i2creadregisterparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void I2CWrite(const I2CWriteParameter& i2cwriteparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void I2CWrite_callback(const I2CWriteParameter& i2cwriteparameter, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> I2CWrite_async(const I2CWriteParameter& i2cwriteparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void I2CWriteRegister(const I2CWriteRegisterParameter& i2cwriteregisterparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void I2CWriteRegister_callback(const I2CWriteRegisterParameter& i2cwriteregisterparameter, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> I2CWriteRegister_async(const I2CWriteRegisterParameter& i2cwriteregisterparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/InterconnectCyclicClientRpc.h

@@ -0,0 +1,83 @@
+#ifndef __INTERCONNECTCYCLICCLIENT_H__
+#define __INTERCONNECTCYCLICCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/InterconnectCyclic.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace InterconnectCyclic
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidRefresh = 0xf0001,
+			eUidRefreshCommand = 0xf0002,
+			eUidRefreshFeedback = 0xf0003,
+			eUidRefreshCustomData = 0xf0004,
+		};
+		
+		class InterconnectCyclicClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdInterconnectCyclic;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			InterconnectCyclicClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Feedback Refresh(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Refresh_callback(const Command& command, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> Refresh_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RefreshCommand(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCommand_callback(const Command& command, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RefreshCommand_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Feedback RefreshFeedback(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshFeedback_callback(const MessageId& messageid, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> RefreshFeedback_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomData RefreshCustomData(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCustomData_callback(const MessageId& messageid, std::function< void (const Error&, const CustomData&) > callback, uint32_t deviceId = 0);
+			std::future<CustomData> RefreshCustomData_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/SessionClientRpc.h

@@ -0,0 +1,83 @@
+#ifndef __SESSIONCLIENT_H__
+#define __SESSIONCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/Session.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace Session
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidCreateSession = 0x10001,
+			eUidCloseSession = 0x10002,
+			eUidKeepAlive = 0x10003,
+			eUidGetConnections = 0x10004,
+		};
+		
+		class SessionClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdSession;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			SessionClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			void CreateSession(const CreateSessionInfo& createsessioninfo, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateSession_callback(const CreateSessionInfo& createsessioninfo, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> CreateSession_async(const CreateSessionInfo& createsessioninfo, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void CloseSession(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CloseSession_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> CloseSession_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void KeepAlive(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void KeepAlive_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> KeepAlive_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ConnectionList GetConnections(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetConnections_callback(std::function< void (const Error&, const ConnectionList&) > callback, uint32_t deviceId = 0);
+			std::future<ConnectionList> GetConnections_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/TestClientRpc.h

@@ -0,0 +1,165 @@
+#ifndef __TESTCLIENT_H__
+#define __TESTCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/Test.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace Test
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidSetMockValidationStruct = 0xff00001,
+			eUidTestParamAndReturn = 0xff00002,
+			eUidTestParamOnly = 0xff00003,
+			eUidTestReturnOnly = 0xff00004,
+			eUidTestTimeout = 0xff00005,
+			eUidTestNotif = 0xff00006,
+			eUidTestNotifUnsubscribe = 0xff00007,
+			eUidTestAsync = 0xff00008,
+			eUidTestConcurrence = 0xff00009,
+			eUidTestTriggerNotif = 0xff0000a,
+			eUidTestNotImplemented = 0xff0000b,
+			eUidServerError = 0xff0000c,
+			eUidUnsubscribe = 0xff0001e,
+			eUidSomethingChangeTopic = 0xff0001f,
+			eUidTriggerSomethingChangeTopic = 0xff00020,
+			eUidWait = 0xff00021,
+			eUidThrow = 0xff00022,
+			eUidDisconnect = 0xff00023,
+			eUidForget = 0xff00024,
+			eUidNotImplemented = 0xff00025,
+			eUidDeprecated = 0xff00027,
+			eUidDeprecatedWithMessage = 0xff00028,
+		};
+		
+		class TestClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdTest;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			TestClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			void SetMockValidationStruct(const validateStruct& validatestruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetMockValidationStruct_callback(const validateStruct& validatestruct, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetMockValidationStruct_async(const validateStruct& validatestruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			RcvStruct TestParamAndReturn(const SendStruct& sendstruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestParamAndReturn_callback(const SendStruct& sendstruct, std::function< void (const Error&, const RcvStruct&) > callback, uint32_t deviceId = 0);
+			std::future<RcvStruct> TestParamAndReturn_async(const SendStruct& sendstruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestParamOnly(const SendStruct& sendstruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestParamOnly_callback(const SendStruct& sendstruct, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestParamOnly_async(const SendStruct& sendstruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			RcvStruct TestReturnOnly(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestReturnOnly_callback(std::function< void (const Error&, const RcvStruct&) > callback, uint32_t deviceId = 0);
+			std::future<RcvStruct> TestReturnOnly_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestTimeout(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestTimeout_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestTimeout_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationTestNotif(std::function< void (TestNotification) > callback, const NotifOption& notifoption, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestNotifUnsubscribe(const Kinova::Api::Common::NotificationHandle& notificationhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestAsync(const timeToResponse& timetoresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestAsync_callback(const timeToResponse& timetoresponse, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestAsync_async(const timeToResponse& timetoresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestConcurrence(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestConcurrence_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestConcurrence_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestTriggerNotif(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestTriggerNotif_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestTriggerNotif_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestNotImplemented(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestNotImplemented_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestNotImplemented_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TestError ServerError(const TestError& testerror, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ServerError_callback(const TestError& testerror, std::function< void (const Error&, const TestError&) > callback, uint32_t deviceId = 0);
+			std::future<TestError> ServerError_async(const TestError& testerror, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Unsubscribe(const Kinova::Api::Common::NotificationHandle& notificationhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationSomethingChangeTopic(std::function< void (SomethingChanged) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TriggerSomethingChangeTopic(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TriggerSomethingChangeTopic_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TriggerSomethingChangeTopic_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Wait(const Delay& delay, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Wait_callback(const Delay& delay, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Wait_async(const Delay& delay, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Throw(const Kinova::Api::Error& error, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Throw_callback(const Kinova::Api::Error& error, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Throw_async(const Kinova::Api::Error& error, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Disconnect(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Disconnect_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Disconnect_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Forget(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Forget_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Forget_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void NotImplemented(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void NotImplemented_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> NotImplemented_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void Deprecated(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void Deprecated_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> Deprecated_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED_MSG("Purposely deprecated for test") void DeprecatedWithMessage(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED_MSG("Purposely deprecated for test") void DeprecatedWithMessage_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED_MSG("Purposely deprecated for test") std::future<void> DeprecatedWithMessage_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/client_stubs/VisionConfigClientRpc.h

@@ -0,0 +1,121 @@
+#ifndef __VISIONCONFIGCLIENT_H__
+#define __VISIONCONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/VisionConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace VisionConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidSetSensorSettings = 0x50001,
+			eUidGetSensorSettings = 0x50002,
+			eUidGetOptionValue = 0x50003,
+			eUidSetOptionValue = 0x50004,
+			eUidGetOptionInformation = 0x50005,
+			eUidVisionTopic = 0x50006,
+			eUidDoSensorFocusAction = 0x50007,
+			eUidGetIntrinsicParameters = 0x50008,
+			eUidGetIntrinsicParametersProfile = 0x50009,
+			eUidSetIntrinsicParameters = 0x5000a,
+			eUidGetExtrinsicParameters = 0x5000b,
+			eUidSetExtrinsicParameters = 0x5000c,
+		};
+		
+		class VisionConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdVisionConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			VisionConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			void SetSensorSettings(const SensorSettings& sensorsettings, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSensorSettings_callback(const SensorSettings& sensorsettings, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSensorSettings_async(const SensorSettings& sensorsettings, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SensorSettings GetSensorSettings(const SensorIdentifier& sensoridentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSensorSettings_callback(const SensorIdentifier& sensoridentifier, std::function< void (const Error&, const SensorSettings&) > callback, uint32_t deviceId = 0);
+			std::future<SensorSettings> GetSensorSettings_async(const SensorIdentifier& sensoridentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			OptionValue GetOptionValue(const OptionIdentifier& optionidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetOptionValue_callback(const OptionIdentifier& optionidentifier, std::function< void (const Error&, const OptionValue&) > callback, uint32_t deviceId = 0);
+			std::future<OptionValue> GetOptionValue_async(const OptionIdentifier& optionidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetOptionValue(const OptionValue& optionvalue, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetOptionValue_callback(const OptionValue& optionvalue, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetOptionValue_async(const OptionValue& optionvalue, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			OptionInformation GetOptionInformation(const OptionIdentifier& optionidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetOptionInformation_callback(const OptionIdentifier& optionidentifier, std::function< void (const Error&, const OptionInformation&) > callback, uint32_t deviceId = 0);
+			std::future<OptionInformation> GetOptionInformation_async(const OptionIdentifier& optionidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationVisionTopic(std::function< void (VisionNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DoSensorFocusAction(const SensorFocusAction& sensorfocusaction, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DoSensorFocusAction_callback(const SensorFocusAction& sensorfocusaction, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DoSensorFocusAction_async(const SensorFocusAction& sensorfocusaction, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IntrinsicParameters GetIntrinsicParameters(const SensorIdentifier& sensoridentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIntrinsicParameters_callback(const SensorIdentifier& sensoridentifier, std::function< void (const Error&, const IntrinsicParameters&) > callback, uint32_t deviceId = 0);
+			std::future<IntrinsicParameters> GetIntrinsicParameters_async(const SensorIdentifier& sensoridentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IntrinsicParameters GetIntrinsicParametersProfile(const IntrinsicProfileIdentifier& intrinsicprofileidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIntrinsicParametersProfile_callback(const IntrinsicProfileIdentifier& intrinsicprofileidentifier, std::function< void (const Error&, const IntrinsicParameters&) > callback, uint32_t deviceId = 0);
+			std::future<IntrinsicParameters> GetIntrinsicParametersProfile_async(const IntrinsicProfileIdentifier& intrinsicprofileidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetIntrinsicParameters(const IntrinsicParameters& intrinsicparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetIntrinsicParameters_callback(const IntrinsicParameters& intrinsicparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetIntrinsicParameters_async(const IntrinsicParameters& intrinsicparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ExtrinsicParameters GetExtrinsicParameters(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetExtrinsicParameters_callback(std::function< void (const Error&, const ExtrinsicParameters&) > callback, uint32_t deviceId = 0);
+			std::future<ExtrinsicParameters> GetExtrinsicParameters_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetExtrinsicParameters(const ExtrinsicParameters& extrinsicparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetExtrinsicParameters_callback(const ExtrinsicParameters& extrinsicparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetExtrinsicParameters_async(const ExtrinsicParameters& extrinsicparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif

kortex_api/include/common/Frame.h

@@ -0,0 +1,71 @@
+#ifndef __FRAME_H__
+#define __FRAME_H__
+
+#include "messages/Frame.pb.h"
+
+#define ACTUATORCONFIG_CLIENT_PROTO_AVAILABLE
+#define ACTUATORCYCLIC_CLIENT_PROTO_AVAILABLE
+#define BASE_CLIENT_PROTO_AVAILABLE
+#define BASECYCLIC_CLIENT_PROTO_AVAILABLE
+#define COMMON_CLIENT_PROTO_AVAILABLE
+#define CONTROLCONFIG_CLIENT_PROTO_AVAILABLE
+#define DEVICECONFIG_CLIENT_PROTO_AVAILABLE
+#define DEVICEMANAGER_CLIENT_PROTO_AVAILABLE
+#define ERRORS_CLIENT_PROTO_AVAILABLE
+#define FRAME_CLIENT_PROTO_AVAILABLE
+#define GRIPPERCONFIG_CLIENT_PROTO_AVAILABLE
+#define GRIPPERCYCLIC_CLIENT_PROTO_AVAILABLE
+#define GRIPPERCYCLICMESSAGE_CLIENT_PROTO_AVAILABLE
+#define INTERCONNECTCONFIG_CLIENT_PROTO_AVAILABLE
+#define INTERCONNECTCYCLIC_CLIENT_PROTO_AVAILABLE
+#define INTERCONNECTCYCLICMESSAGE_CLIENT_PROTO_AVAILABLE
+#define PRODUCTCONFIGURATION_CLIENT_PROTO_AVAILABLE
+#define SESSION_CLIENT_PROTO_AVAILABLE
+#define TEST_CLIENT_PROTO_AVAILABLE
+#define VISIONCONFIG_CLIENT_PROTO_AVAILABLE
+
+#define ACTUATORCONFIG_SERVER_PROTO_AVAILABLE
+#define ACTUATORCYCLIC_SERVER_PROTO_AVAILABLE
+#define BASE_SERVER_PROTO_AVAILABLE
+#define BASECYCLIC_SERVER_PROTO_AVAILABLE
+#define COMMON_SERVER_PROTO_AVAILABLE
+#define CONTROLCONFIG_SERVER_PROTO_AVAILABLE
+#define DEVICECONFIG_SERVER_PROTO_AVAILABLE
+#define DEVICEMANAGER_SERVER_PROTO_AVAILABLE
+#define ERRORS_SERVER_PROTO_AVAILABLE
+#define FRAME_SERVER_PROTO_AVAILABLE
+#define GRIPPERCONFIG_SERVER_PROTO_AVAILABLE
+#define GRIPPERCYCLIC_SERVER_PROTO_AVAILABLE
+#define GRIPPERCYCLICMESSAGE_SERVER_PROTO_AVAILABLE
+#define INTERCONNECTCONFIG_SERVER_PROTO_AVAILABLE
+#define INTERCONNECTCYCLIC_SERVER_PROTO_AVAILABLE
+#define INTERCONNECTCYCLICMESSAGE_SERVER_PROTO_AVAILABLE
+#define PRODUCTCONFIGURATION_SERVER_PROTO_AVAILABLE
+#define SESSION_SERVER_PROTO_AVAILABLE
+#define TEST_SERVER_PROTO_AVAILABLE
+#define VISIONCONFIG_SERVER_PROTO_AVAILABLE
+
+namespace Kinova
+{
+namespace Api
+{
+	enum ServiceIds
+	{
+		eIdActuatorConfig = 10,
+		eIdActuatorCyclic = 11,
+		eIdBase = 2,
+		eIdBaseCyclic = 3,
+		eIdControlConfig = 16,
+		eIdDeviceConfig = 9,
+		eIdDeviceManager = 23,
+		eIdGripperCyclic = 17,
+		eIdInterconnectConfig = 14,
+		eIdInterconnectCyclic = 15,
+		eIdSession = 1,
+		eIdTest = 4080,
+		eIdVisionConfig = 5,
+	};
+}
+}
+
+#endif

kortex_api/include/common/HeaderInfo.h

@@ -0,0 +1,81 @@
+#ifndef KINOVAUTILAPI_H
+#define KINOVAUTILAPI_H
+
+#include "messages/Frame.pb.h"
+
+namespace Kinova
+{
+namespace Api
+{
+
+    typedef union
+    {
+        uint32_t frame_info;
+        struct
+        {
+            uint32_t errorSubCode: 12;
+            uint32_t errorCode: 4;
+            uint32_t deviceId: 8;
+
+            uint32_t frameType: 4;
+            uint32_t headerVersion : 4;
+        };
+    } FrameInfo;
+
+    typedef union
+    {
+        uint32_t message_info;
+        struct
+        {
+            uint32_t messageId: 16;
+            uint32_t sessionId: 16;
+        };
+    } MessageInfo;
+    
+    typedef union
+    {
+        uint32_t service_info;
+        struct
+        {
+            uint32_t functionId: 16;
+            uint32_t serviceId: 12;
+            uint32_t serviceVersion: 4;
+        };
+        
+        struct
+        {
+            uint32_t functionUid: 28;
+        };
+    } ServiceInfo;
+    
+    typedef union
+    {
+        uint32_t payload_info;
+        struct
+        {
+            uint32_t payloadLength: 24;
+            uint32_t reserved: 8;
+        };
+    } PayloadInfo;
+    
+    class HeaderInfo
+    {
+    public:
+        HeaderInfo();
+        HeaderInfo(const Header& headerProto);
+
+        Header createHeader();
+
+        void fillHeader(Header* pHeader);
+
+        FrameInfo        m_frameInfo;
+        MessageInfo      m_messageInfo;
+        ServiceInfo      m_serviceInfo;
+        PayloadInfo      m_payloadInfo;
+    };
+
+
+} // namespace Api
+} // namespace Kinova
+
+#endif

kortex_api/include/common/KBasicException.h

@@ -0,0 +1,29 @@
+#ifndef KINOVAEXCEPTION_H
+#define KINOVAEXCEPTION_H
+
+#include <string>
+#include <sstream>
+#include <exception>
+
+namespace Kinova
+{
+namespace Api
+{
+
+    class KBasicException : public std::runtime_error
+    {
+    public:
+        KBasicException(const std::string& msgStr);
+        KBasicException(const KBasicException &other);
+
+        virtual const char* what() const throw() override;
+        virtual std::string toString();
+    };
+
+    // todogr add a new kinova exception: KProgException
+    typedef KBasicException KProgException;
+
+} // namespace Api
+} // namespace Kinova
+
+#endif

kortex_api/include/common/KDetailedException.h

@@ -0,0 +1,39 @@
+#ifndef KINOVASERVEREXCEPTION_H
+#define KINOVASERVEREXCEPTION_H
+
+#include <string>
+#include <sstream>
+
+#include "KBasicException.h"
+
+#include <messages/Frame.pb.h>
+#include "KError.h"
+
+#include "HeaderInfo.h"
+
+namespace Kinova
+{
+namespace Api
+{
+    class KDetailedException : public KBasicException
+    {
+    public:
+        KDetailedException(const KError& error);
+        KDetailedException(const KDetailedException &other);
+
+        virtual const char* what() const throw() override;
+        virtual std::string toString() override;
+
+        KError&      getErrorInfo() { return m_error; }
+
+    private:
+        void init(const HeaderInfo& header, const Error& error);
+    
+        KError       m_error;
+        std::string  m_errorStr;
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif

kortex_api/include/common/KError.h

@@ -0,0 +1,42 @@
+#ifndef KINOVAERROR_H
+#define KINOVAERROR_H
+
+#include <string>
+#include <sstream>
+
+#include "messages/Frame.pb.h"
+
+#include "HeaderInfo.h"
+
+namespace Kinova
+{
+namespace Api
+{
+    class KError
+    {
+    public:
+        KError(Kinova::Api::ErrorCodes errorCode, Kinova::Api::SubErrorCodes errorSubCode, std::string errorDescription);
+        KError(const HeaderInfo& header, Kinova::Api::ErrorCodes errorCode, Kinova::Api::SubErrorCodes errorSubCode, std::string errorDescription);
+        KError(const Error& error);
+        KError(const HeaderInfo& header, const Error& error);
+
+        static Error fillError(Kinova::Api::ErrorCodes errorCode, Kinova::Api::SubErrorCodes errorSubCode, std::string errorDescription);
+
+        std::string toString() const;
+
+        bool            isThereHeaderInfo();
+        HeaderInfo      getHeader();
+        Error           getError();
+
+        KError& operator =(const KError& other) = default;
+
+    private:
+        bool            m_isThereHeaderInfo;
+        HeaderInfo      m_header;
+        Error           m_error;
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif

kortex_api/include/common/KinovaTcpUtilities.h

@@ -0,0 +1,23 @@
+#ifndef CPPAPI_KINOVATCPUTILITIES_H
+#define CPPAPI_KINOVATCPUTILITIES_H
+
+#include <string>
+
+class KinovaTcpUtilities {
+
+public:
+    KinovaTcpUtilities();
+    ~KinovaTcpUtilities();
+
+    uint32_t ParseBufferHeader(uint8_t* buff);
+    void PrependHeader(uint8_t *in_buf, uint32_t payload_length);
+    void PrintBuffer(uint8_t* in_buf, uint32_t len);
+    char* ResizeBuffer(char *buf, size_t data_size_to_copy, size_t new_size, uint32_t& buffer_size);
+    uint8_t* ResizeBuffer(uint8_t *buf, size_t data_size_to_copy, size_t new_size, uint32_t& buffer_size);
+
+    const std::string KINOVA_MAGIC_STRING = { "\07xEtRoK\07" };
+    const size_t KINOVA_HEADER_SIZE { (KINOVA_MAGIC_STRING.length() + sizeof(uint32_t) )};
+};
+
+
+#endif //CPPAPI_KINOVATCPUTILITIES_H

kortex_api/include/common/TransportBridgeDummy.h

@@ -0,0 +1,127 @@
+/* ***************************************************************************
+ * 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

kortex_api/include/common/WindowsNetworking.h

@@ -0,0 +1,21 @@
+#ifndef WINDOWS_NETWORKING_H
+#define WINDOWS_NETWORKING_H
+
+#ifdef _WIN32
+#define _OS_WINDOWS
+
+// Include Windows networking headers before standard C++ headers
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+
+// Define missing types that are used in TransportClientTcp.h
+typedef int socklen_t;
+
+// Ensure proper Windows networking initialization
+#pragma comment(lib, "ws2_32.lib")
+#pragma comment(lib, "iphlpapi.lib")
+
+#endif // _WIN32
+
+#endif // WINDOWS_NETWORKING_H

kortex_api/include/common/version.h

@@ -0,0 +1,10 @@
+#ifndef VERSION_H
+#define VERSION_H
+
+#define PROJECT_NAME "KortexApiCpp"
+#define PROJECT_VER  "2.7.0"
+#define PROJECT_VER_MAJOR "2"
+#define PROJECT_VER_MINOR "7"
+#define PTOJECT_VER_PATCH "0"
+
+#endif //VERSION_H

kortex_api/include/google/protobuf/any.h

@@ -0,0 +1,107 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_ANY_H__
+#define GOOGLE_PROTOBUF_ANY_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/arenastring.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Helper class used to implement google::protobuf::Any.
+class LIBPROTOBUF_EXPORT AnyMetadata {
+  typedef ArenaStringPtr UrlType;
+  typedef ArenaStringPtr ValueType;
+ public:
+  // AnyMetadata does not take ownership of "type_url" and "value".
+  AnyMetadata(UrlType* type_url, ValueType* value);
+
+  // Packs a message using the default type URL prefix: "type.googleapis.com".
+  // The resulted type URL will be "type.googleapis.com/<message_full_name>".
+  void PackFrom(const Message& message);
+  // Packs a message using the given type URL prefix. The type URL will be
+  // constructed by concatenating the message type's full name to the prefix
+  // with an optional "/" separator if the prefix doesn't already end up "/".
+  // For example, both PackFrom(message, "type.googleapis.com") and
+  // PackFrom(message, "type.googleapis.com/") yield the same result type
+  // URL: "type.googleapis.com/<message_full_name>".
+  void PackFrom(const Message& message, const string& type_url_prefix);
+
+  // Unpacks the payload into the given message. Returns false if the message's
+  // type doesn't match the type specified in the type URL (i.e., the full
+  // name after the last "/" of the type URL doesn't match the message's actual
+  // full name) or parsing the payload has failed.
+  bool UnpackTo(Message* message) const;
+
+  // Checks whether the type specified in the type URL matches the given type.
+  // A type is consdiered matching if its full name matches the full name after
+  // the last "/" in the type URL.
+  template<typename T>
+  bool Is() const {
+    return InternalIs(T::default_instance().GetDescriptor());
+  }
+
+ private:
+  bool InternalIs(const Descriptor* message) const;
+
+  UrlType* type_url_;
+  ValueType* value_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AnyMetadata);
+};
+
+extern const char kAnyFullTypeName[];          // "google.protobuf.Any".
+extern const char kTypeGoogleApisComPrefix[];  // "type.googleapis.com/".
+extern const char kTypeGoogleProdComPrefix[];  // "type.googleprod.com/".
+
+// Get the proto type name from Any::type_url value. For example, passing
+// "type.googleapis.com/rpc.QueryOrigin" will return "rpc.QueryOrigin" in
+// *full_type_name. Returns false if the type_url does not have a "/"
+// in the type url separating the full type name.
+bool ParseAnyTypeUrl(const string& type_url, string* full_type_name);
+
+// See if message is of type google.protobuf.Any, if so, return the descriptors
+// for "type_url" and "value" fields.
+bool GetAnyFieldDescriptors(const Message& message,
+                            const FieldDescriptor** type_url_field,
+                            const FieldDescriptor** value_field);
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_ANY_H__

kortex_api/include/google/protobuf/any.pb.h

@@ -0,0 +1,323 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/any.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fany_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fany_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/any.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fany_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsAnyImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsAny();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsAny();
+}
+}  // namespace protobuf_google_2fprotobuf_2fany_2eproto
+namespace google {
+namespace protobuf {
+class Any;
+class AnyDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern AnyDefaultTypeInternal _Any_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT Any : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Any) */ {
+ public:
+  Any();
+  virtual ~Any();
+
+  Any(const Any& from);
+
+  inline Any& operator=(const Any& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Any(Any&& from) noexcept
+    : Any() {
+    *this = ::std::move(from);
+  }
+
+  inline Any& operator=(Any&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Any& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Any* internal_default_instance() {
+    return reinterpret_cast<const Any*>(
+               &_Any_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  // implements Any -----------------------------------------------
+
+  void PackFrom(const ::google::protobuf::Message& message);
+  void PackFrom(const ::google::protobuf::Message& message,
+                const ::std::string& type_url_prefix);
+  bool UnpackTo(::google::protobuf::Message* message) const;
+  template<typename T> bool Is() const {
+    return _any_metadata_.Is<T>();
+  }
+
+  void Swap(Any* other);
+  friend void swap(Any& a, Any& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Any* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Any* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Any& from);
+  void MergeFrom(const Any& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Any* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string type_url = 1;
+  void clear_type_url();
+  static const int kTypeUrlFieldNumber = 1;
+  const ::std::string& type_url() const;
+  void set_type_url(const ::std::string& value);
+  #if LANG_CXX11
+  void set_type_url(::std::string&& value);
+  #endif
+  void set_type_url(const char* value);
+  void set_type_url(const char* value, size_t size);
+  ::std::string* mutable_type_url();
+  ::std::string* release_type_url();
+  void set_allocated_type_url(::std::string* type_url);
+
+  // bytes value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  const ::std::string& value() const;
+  void set_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_value(::std::string&& value);
+  #endif
+  void set_value(const char* value);
+  void set_value(const void* value, size_t size);
+  ::std::string* mutable_value();
+  ::std::string* release_value();
+  void set_allocated_value(::std::string* value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Any)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr type_url_;
+  ::google::protobuf::internal::ArenaStringPtr value_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::AnyMetadata _any_metadata_;
+  friend struct ::protobuf_google_2fprotobuf_2fany_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fany_2eproto::InitDefaultsAnyImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Any
+
+// string type_url = 1;
+inline void Any::clear_type_url() {
+  type_url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Any::type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Any.type_url)
+  return type_url_.GetNoArena();
+}
+inline void Any::set_type_url(const ::std::string& value) {
+  
+  type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Any.type_url)
+}
+#if LANG_CXX11
+inline void Any::set_type_url(::std::string&& value) {
+  
+  type_url_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Any.type_url)
+}
+#endif
+inline void Any::set_type_url(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Any.type_url)
+}
+inline void Any::set_type_url(const char* value, size_t size) {
+  
+  type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Any.type_url)
+}
+inline ::std::string* Any::mutable_type_url() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Any.type_url)
+  return type_url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Any::release_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Any.type_url)
+  
+  return type_url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Any::set_allocated_type_url(::std::string* type_url) {
+  if (type_url != NULL) {
+    
+  } else {
+    
+  }
+  type_url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type_url);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.type_url)
+}
+
+// bytes value = 2;
+inline void Any::clear_value() {
+  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Any::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Any.value)
+  return value_.GetNoArena();
+}
+inline void Any::set_value(const ::std::string& value) {
+  
+  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Any.value)
+}
+#if LANG_CXX11
+inline void Any::set_value(::std::string&& value) {
+  
+  value_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Any.value)
+}
+#endif
+inline void Any::set_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Any.value)
+}
+inline void Any::set_value(const void* value, size_t size) {
+  
+  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Any.value)
+}
+inline ::std::string* Any::mutable_value() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Any.value)
+  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Any::release_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Any.value)
+  
+  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Any::set_allocated_value(::std::string* value) {
+  if (value != NULL) {
+    
+  } else {
+    
+  }
+  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.value)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fany_2eproto__INCLUDED

kortex_api/include/google/protobuf/api.pb.h

@@ -0,0 +1,1165 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/api.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fapi_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fapi_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/source_context.pb.h>
+#include <google/protobuf/type.pb.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fapi_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[3];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsApiImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsApi();
+void LIBPROTOBUF_EXPORT InitDefaultsMethodImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsMethod();
+void LIBPROTOBUF_EXPORT InitDefaultsMixinImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsMixin();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsApi();
+  InitDefaultsMethod();
+  InitDefaultsMixin();
+}
+}  // namespace protobuf_google_2fprotobuf_2fapi_2eproto
+namespace google {
+namespace protobuf {
+class Api;
+class ApiDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern ApiDefaultTypeInternal _Api_default_instance_;
+class Method;
+class MethodDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern MethodDefaultTypeInternal _Method_default_instance_;
+class Mixin;
+class MixinDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern MixinDefaultTypeInternal _Mixin_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT Api : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Api) */ {
+ public:
+  Api();
+  virtual ~Api();
+
+  Api(const Api& from);
+
+  inline Api& operator=(const Api& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Api(Api&& from) noexcept
+    : Api() {
+    *this = ::std::move(from);
+  }
+
+  inline Api& operator=(Api&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Api& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Api* internal_default_instance() {
+    return reinterpret_cast<const Api*>(
+               &_Api_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(Api* other);
+  friend void swap(Api& a, Api& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Api* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Api* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Api& from);
+  void MergeFrom(const Api& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Api* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.Method methods = 2;
+  int methods_size() const;
+  void clear_methods();
+  static const int kMethodsFieldNumber = 2;
+  const ::google::protobuf::Method& methods(int index) const;
+  ::google::protobuf::Method* mutable_methods(int index);
+  ::google::protobuf::Method* add_methods();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method >*
+      mutable_methods();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method >&
+      methods() const;
+
+  // repeated .google.protobuf.Option options = 3;
+  int options_size() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  const ::google::protobuf::Option& options(int index) const;
+  ::google::protobuf::Option* mutable_options(int index);
+  ::google::protobuf::Option* add_options();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+      mutable_options();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+      options() const;
+
+  // repeated .google.protobuf.Mixin mixins = 6;
+  int mixins_size() const;
+  void clear_mixins();
+  static const int kMixinsFieldNumber = 6;
+  const ::google::protobuf::Mixin& mixins(int index) const;
+  ::google::protobuf::Mixin* mutable_mixins(int index);
+  ::google::protobuf::Mixin* add_mixins();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >*
+      mutable_mixins();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >&
+      mixins() const;
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string version = 4;
+  void clear_version();
+  static const int kVersionFieldNumber = 4;
+  const ::std::string& version() const;
+  void set_version(const ::std::string& value);
+  #if LANG_CXX11
+  void set_version(::std::string&& value);
+  #endif
+  void set_version(const char* value);
+  void set_version(const char* value, size_t size);
+  ::std::string* mutable_version();
+  ::std::string* release_version();
+  void set_allocated_version(::std::string* version);
+
+  // .google.protobuf.SourceContext source_context = 5;
+  bool has_source_context() const;
+  void clear_source_context();
+  static const int kSourceContextFieldNumber = 5;
+  const ::google::protobuf::SourceContext& source_context() const;
+  ::google::protobuf::SourceContext* release_source_context();
+  ::google::protobuf::SourceContext* mutable_source_context();
+  void set_allocated_source_context(::google::protobuf::SourceContext* source_context);
+
+  // .google.protobuf.Syntax syntax = 7;
+  void clear_syntax();
+  static const int kSyntaxFieldNumber = 7;
+  ::google::protobuf::Syntax syntax() const;
+  void set_syntax(::google::protobuf::Syntax value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Api)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method > methods_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option > options_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin > mixins_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr version_;
+  ::google::protobuf::SourceContext* source_context_;
+  int syntax_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fapi_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaultsApiImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Method : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Method) */ {
+ public:
+  Method();
+  virtual ~Method();
+
+  Method(const Method& from);
+
+  inline Method& operator=(const Method& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Method(Method&& from) noexcept
+    : Method() {
+    *this = ::std::move(from);
+  }
+
+  inline Method& operator=(Method&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Method& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Method* internal_default_instance() {
+    return reinterpret_cast<const Method*>(
+               &_Method_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(Method* other);
+  friend void swap(Method& a, Method& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Method* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Method* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Method& from);
+  void MergeFrom(const Method& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Method* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.Option options = 6;
+  int options_size() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 6;
+  const ::google::protobuf::Option& options(int index) const;
+  ::google::protobuf::Option* mutable_options(int index);
+  ::google::protobuf::Option* add_options();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+      mutable_options();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+      options() const;
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string request_type_url = 2;
+  void clear_request_type_url();
+  static const int kRequestTypeUrlFieldNumber = 2;
+  const ::std::string& request_type_url() const;
+  void set_request_type_url(const ::std::string& value);
+  #if LANG_CXX11
+  void set_request_type_url(::std::string&& value);
+  #endif
+  void set_request_type_url(const char* value);
+  void set_request_type_url(const char* value, size_t size);
+  ::std::string* mutable_request_type_url();
+  ::std::string* release_request_type_url();
+  void set_allocated_request_type_url(::std::string* request_type_url);
+
+  // string response_type_url = 4;
+  void clear_response_type_url();
+  static const int kResponseTypeUrlFieldNumber = 4;
+  const ::std::string& response_type_url() const;
+  void set_response_type_url(const ::std::string& value);
+  #if LANG_CXX11
+  void set_response_type_url(::std::string&& value);
+  #endif
+  void set_response_type_url(const char* value);
+  void set_response_type_url(const char* value, size_t size);
+  ::std::string* mutable_response_type_url();
+  ::std::string* release_response_type_url();
+  void set_allocated_response_type_url(::std::string* response_type_url);
+
+  // bool request_streaming = 3;
+  void clear_request_streaming();
+  static const int kRequestStreamingFieldNumber = 3;
+  bool request_streaming() const;
+  void set_request_streaming(bool value);
+
+  // bool response_streaming = 5;
+  void clear_response_streaming();
+  static const int kResponseStreamingFieldNumber = 5;
+  bool response_streaming() const;
+  void set_response_streaming(bool value);
+
+  // .google.protobuf.Syntax syntax = 7;
+  void clear_syntax();
+  static const int kSyntaxFieldNumber = 7;
+  ::google::protobuf::Syntax syntax() const;
+  void set_syntax(::google::protobuf::Syntax value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Method)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option > options_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr request_type_url_;
+  ::google::protobuf::internal::ArenaStringPtr response_type_url_;
+  bool request_streaming_;
+  bool response_streaming_;
+  int syntax_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fapi_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaultsMethodImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Mixin : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Mixin) */ {
+ public:
+  Mixin();
+  virtual ~Mixin();
+
+  Mixin(const Mixin& from);
+
+  inline Mixin& operator=(const Mixin& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Mixin(Mixin&& from) noexcept
+    : Mixin() {
+    *this = ::std::move(from);
+  }
+
+  inline Mixin& operator=(Mixin&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Mixin& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Mixin* internal_default_instance() {
+    return reinterpret_cast<const Mixin*>(
+               &_Mixin_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(Mixin* other);
+  friend void swap(Mixin& a, Mixin& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Mixin* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Mixin* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Mixin& from);
+  void MergeFrom(const Mixin& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Mixin* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string root = 2;
+  void clear_root();
+  static const int kRootFieldNumber = 2;
+  const ::std::string& root() const;
+  void set_root(const ::std::string& value);
+  #if LANG_CXX11
+  void set_root(::std::string&& value);
+  #endif
+  void set_root(const char* value);
+  void set_root(const char* value, size_t size);
+  ::std::string* mutable_root();
+  ::std::string* release_root();
+  void set_allocated_root(::std::string* root);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Mixin)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr root_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fapi_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaultsMixinImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Api
+
+// string name = 1;
+inline void Api::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Api::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.name)
+  return name_.GetNoArena();
+}
+inline void Api::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Api.name)
+}
+#if LANG_CXX11
+inline void Api::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Api.name)
+}
+#endif
+inline void Api::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Api.name)
+}
+inline void Api::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Api.name)
+}
+inline ::std::string* Api::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Api::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Api.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Api::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.name)
+}
+
+// repeated .google.protobuf.Method methods = 2;
+inline int Api::methods_size() const {
+  return methods_.size();
+}
+inline void Api::clear_methods() {
+  methods_.Clear();
+}
+inline const ::google::protobuf::Method& Api::methods(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.methods)
+  return methods_.Get(index);
+}
+inline ::google::protobuf::Method* Api::mutable_methods(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.methods)
+  return methods_.Mutable(index);
+}
+inline ::google::protobuf::Method* Api::add_methods() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Api.methods)
+  return methods_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method >*
+Api::mutable_methods() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.methods)
+  return &methods_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method >&
+Api::methods() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Api.methods)
+  return methods_;
+}
+
+// repeated .google.protobuf.Option options = 3;
+inline int Api::options_size() const {
+  return options_.size();
+}
+inline const ::google::protobuf::Option& Api::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.options)
+  return options_.Get(index);
+}
+inline ::google::protobuf::Option* Api::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.options)
+  return options_.Mutable(index);
+}
+inline ::google::protobuf::Option* Api::add_options() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Api.options)
+  return options_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+Api::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.options)
+  return &options_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+Api::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Api.options)
+  return options_;
+}
+
+// string version = 4;
+inline void Api::clear_version() {
+  version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Api::version() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.version)
+  return version_.GetNoArena();
+}
+inline void Api::set_version(const ::std::string& value) {
+  
+  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Api.version)
+}
+#if LANG_CXX11
+inline void Api::set_version(::std::string&& value) {
+  
+  version_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Api.version)
+}
+#endif
+inline void Api::set_version(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Api.version)
+}
+inline void Api::set_version(const char* value, size_t size) {
+  
+  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Api.version)
+}
+inline ::std::string* Api::mutable_version() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.version)
+  return version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Api::release_version() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Api.version)
+  
+  return version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Api::set_allocated_version(::std::string* version) {
+  if (version != NULL) {
+    
+  } else {
+    
+  }
+  version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), version);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.version)
+}
+
+// .google.protobuf.SourceContext source_context = 5;
+inline bool Api::has_source_context() const {
+  return this != internal_default_instance() && source_context_ != NULL;
+}
+inline const ::google::protobuf::SourceContext& Api::source_context() const {
+  const ::google::protobuf::SourceContext* p = source_context_;
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.source_context)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::SourceContext*>(
+      &::google::protobuf::_SourceContext_default_instance_);
+}
+inline ::google::protobuf::SourceContext* Api::release_source_context() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Api.source_context)
+  
+  ::google::protobuf::SourceContext* temp = source_context_;
+  source_context_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::SourceContext* Api::mutable_source_context() {
+  
+  if (source_context_ == NULL) {
+    source_context_ = new ::google::protobuf::SourceContext;
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.source_context)
+  return source_context_;
+}
+inline void Api::set_allocated_source_context(::google::protobuf::SourceContext* source_context) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(source_context_);
+  }
+  if (source_context) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      source_context = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, source_context, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  source_context_ = source_context;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.source_context)
+}
+
+// repeated .google.protobuf.Mixin mixins = 6;
+inline int Api::mixins_size() const {
+  return mixins_.size();
+}
+inline void Api::clear_mixins() {
+  mixins_.Clear();
+}
+inline const ::google::protobuf::Mixin& Api::mixins(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.mixins)
+  return mixins_.Get(index);
+}
+inline ::google::protobuf::Mixin* Api::mutable_mixins(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.mixins)
+  return mixins_.Mutable(index);
+}
+inline ::google::protobuf::Mixin* Api::add_mixins() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Api.mixins)
+  return mixins_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >*
+Api::mutable_mixins() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.mixins)
+  return &mixins_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >&
+Api::mixins() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Api.mixins)
+  return mixins_;
+}
+
+// .google.protobuf.Syntax syntax = 7;
+inline void Api::clear_syntax() {
+  syntax_ = 0;
+}
+inline ::google::protobuf::Syntax Api::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.syntax)
+  return static_cast< ::google::protobuf::Syntax >(syntax_);
+}
+inline void Api::set_syntax(::google::protobuf::Syntax value) {
+  
+  syntax_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Api.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// Method
+
+// string name = 1;
+inline void Method::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Method::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.name)
+  return name_.GetNoArena();
+}
+inline void Method::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.name)
+}
+#if LANG_CXX11
+inline void Method::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Method.name)
+}
+#endif
+inline void Method::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Method.name)
+}
+inline void Method::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Method.name)
+}
+inline ::std::string* Method::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Method::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Method.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Method::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.name)
+}
+
+// string request_type_url = 2;
+inline void Method::clear_request_type_url() {
+  request_type_url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Method::request_type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.request_type_url)
+  return request_type_url_.GetNoArena();
+}
+inline void Method::set_request_type_url(const ::std::string& value) {
+  
+  request_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.request_type_url)
+}
+#if LANG_CXX11
+inline void Method::set_request_type_url(::std::string&& value) {
+  
+  request_type_url_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Method.request_type_url)
+}
+#endif
+inline void Method::set_request_type_url(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  request_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Method.request_type_url)
+}
+inline void Method::set_request_type_url(const char* value, size_t size) {
+  
+  request_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Method.request_type_url)
+}
+inline ::std::string* Method::mutable_request_type_url() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.request_type_url)
+  return request_type_url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Method::release_request_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Method.request_type_url)
+  
+  return request_type_url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Method::set_allocated_request_type_url(::std::string* request_type_url) {
+  if (request_type_url != NULL) {
+    
+  } else {
+    
+  }
+  request_type_url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), request_type_url);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.request_type_url)
+}
+
+// bool request_streaming = 3;
+inline void Method::clear_request_streaming() {
+  request_streaming_ = false;
+}
+inline bool Method::request_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.request_streaming)
+  return request_streaming_;
+}
+inline void Method::set_request_streaming(bool value) {
+  
+  request_streaming_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.request_streaming)
+}
+
+// string response_type_url = 4;
+inline void Method::clear_response_type_url() {
+  response_type_url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Method::response_type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.response_type_url)
+  return response_type_url_.GetNoArena();
+}
+inline void Method::set_response_type_url(const ::std::string& value) {
+  
+  response_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.response_type_url)
+}
+#if LANG_CXX11
+inline void Method::set_response_type_url(::std::string&& value) {
+  
+  response_type_url_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Method.response_type_url)
+}
+#endif
+inline void Method::set_response_type_url(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  response_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Method.response_type_url)
+}
+inline void Method::set_response_type_url(const char* value, size_t size) {
+  
+  response_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Method.response_type_url)
+}
+inline ::std::string* Method::mutable_response_type_url() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.response_type_url)
+  return response_type_url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Method::release_response_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Method.response_type_url)
+  
+  return response_type_url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Method::set_allocated_response_type_url(::std::string* response_type_url) {
+  if (response_type_url != NULL) {
+    
+  } else {
+    
+  }
+  response_type_url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), response_type_url);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.response_type_url)
+}
+
+// bool response_streaming = 5;
+inline void Method::clear_response_streaming() {
+  response_streaming_ = false;
+}
+inline bool Method::response_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.response_streaming)
+  return response_streaming_;
+}
+inline void Method::set_response_streaming(bool value) {
+  
+  response_streaming_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.response_streaming)
+}
+
+// repeated .google.protobuf.Option options = 6;
+inline int Method::options_size() const {
+  return options_.size();
+}
+inline const ::google::protobuf::Option& Method::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.options)
+  return options_.Get(index);
+}
+inline ::google::protobuf::Option* Method::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.options)
+  return options_.Mutable(index);
+}
+inline ::google::protobuf::Option* Method::add_options() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Method.options)
+  return options_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+Method::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Method.options)
+  return &options_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+Method::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Method.options)
+  return options_;
+}
+
+// .google.protobuf.Syntax syntax = 7;
+inline void Method::clear_syntax() {
+  syntax_ = 0;
+}
+inline ::google::protobuf::Syntax Method::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.syntax)
+  return static_cast< ::google::protobuf::Syntax >(syntax_);
+}
+inline void Method::set_syntax(::google::protobuf::Syntax value) {
+  
+  syntax_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// Mixin
+
+// string name = 1;
+inline void Mixin::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Mixin::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Mixin.name)
+  return name_.GetNoArena();
+}
+inline void Mixin::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Mixin.name)
+}
+#if LANG_CXX11
+inline void Mixin::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Mixin.name)
+}
+#endif
+inline void Mixin::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Mixin.name)
+}
+inline void Mixin::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Mixin.name)
+}
+inline ::std::string* Mixin::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Mixin::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Mixin.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Mixin::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.name)
+}
+
+// string root = 2;
+inline void Mixin::clear_root() {
+  root_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Mixin::root() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Mixin.root)
+  return root_.GetNoArena();
+}
+inline void Mixin::set_root(const ::std::string& value) {
+  
+  root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Mixin.root)
+}
+#if LANG_CXX11
+inline void Mixin::set_root(::std::string&& value) {
+  
+  root_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Mixin.root)
+}
+#endif
+inline void Mixin::set_root(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Mixin.root)
+}
+inline void Mixin::set_root(const char* value, size_t size) {
+  
+  root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Mixin.root)
+}
+inline ::std::string* Mixin::mutable_root() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.root)
+  return root_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Mixin::release_root() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Mixin.root)
+  
+  return root_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Mixin::set_allocated_root(::std::string* root) {
+  if (root != NULL) {
+    
+  } else {
+    
+  }
+  root_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), root);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.root)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fapi_2eproto__INCLUDED

kortex_api/include/google/protobuf/arena.h

@@ -0,0 +1,934 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines an Arena allocator for better allocation performance.
+
+#ifndef GOOGLE_PROTOBUF_ARENA_H__
+#define GOOGLE_PROTOBUF_ARENA_H__
+
+#include <limits>
+#ifdef max
+#undef max  // Visual Studio defines this macro
+#endif
+#if LANG_CXX11
+#include <google/protobuf/stubs/type_traits.h>
+#endif
+#if defined(_MSC_VER) && !_HAS_EXCEPTIONS
+// Work around bugs in MSVC <typeinfo> header when _HAS_EXCEPTIONS=0.
+#include <exception>
+#include <typeinfo>
+namespace std {
+using type_info = ::type_info;
+}
+#else
+#include <typeinfo>
+#endif
+
+#include <google/protobuf/arena_impl.h>
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+namespace protobuf {
+
+class Arena;       // defined below
+class Message;     // message.h
+
+namespace internal {
+struct ArenaStringPtr;  // arenastring.h
+class LazyField;   // lazy_field.h
+
+template<typename Type>
+class GenericTypeHandler; // repeated_field.h
+
+// Templated cleanup methods.
+template<typename T> void arena_destruct_object(void* object) {
+  reinterpret_cast<T*>(object)->~T();
+}
+template<typename T> void arena_delete_object(void* object) {
+  delete reinterpret_cast<T*>(object);
+}
+inline void arena_free(void* object, size_t size) {
+#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
+  ::operator delete(object, size);
+#else
+  (void)size;
+  ::operator delete(object);
+#endif
+}
+
+}  // namespace internal
+
+// ArenaOptions provides optional additional parameters to arena construction
+// that control its block-allocation behavior.
+struct ArenaOptions {
+  // This defines the size of the first block requested from the system malloc.
+  // Subsequent block sizes will increase in a geometric series up to a maximum.
+  size_t start_block_size;
+
+  // This defines the maximum block size requested from system malloc (unless an
+  // individual arena allocation request occurs with a size larger than this
+  // maximum). Requested block sizes increase up to this value, then remain
+  // here.
+  size_t max_block_size;
+
+  // An initial block of memory for the arena to use, or NULL for none. If
+  // provided, the block must live at least as long as the arena itself. The
+  // creator of the Arena retains ownership of the block after the Arena is
+  // destroyed.
+  char* initial_block;
+
+  // The size of the initial block, if provided.
+  size_t initial_block_size;
+
+  // A function pointer to an alloc method that returns memory blocks of size
+  // requested. By default, it contains a ptr to the malloc function.
+  //
+  // NOTE: block_alloc and dealloc functions are expected to behave like
+  // malloc and free, including Asan poisoning.
+  void* (*block_alloc)(size_t);
+  // A function pointer to a dealloc method that takes ownership of the blocks
+  // from the arena. By default, it contains a ptr to a wrapper function that
+  // calls free.
+  void (*block_dealloc)(void*, size_t);
+  // Hooks for adding external functionality such as user-specific metrics
+  // collection, specific debugging abilities, etc.
+  // Init hook may return a pointer to a cookie to be stored in the arena.
+  // reset and destruction hooks will then be called with the same cookie
+  // pointer. This allows us to save an external object per arena instance and
+  // use it on the other hooks (Note: It is just as legal for init to return
+  // NULL and not use the cookie feature).
+  // on_arena_reset and on_arena_destruction also receive the space used in
+  // the arena just before the reset.
+  void* (*on_arena_init)(Arena* arena);
+  void (*on_arena_reset)(Arena* arena, void* cookie, uint64 space_used);
+  void (*on_arena_destruction)(Arena* arena, void* cookie, uint64 space_used);
+
+  // type_info is promised to be static - its lifetime extends to
+  // match program's lifetime (It is given by typeid operator).
+  // Note: typeid(void) will be passed as allocated_type every time we
+  // intentionally want to avoid monitoring an allocation. (i.e. internal
+  // allocations for managing the arena)
+  void (*on_arena_allocation)(const std::type_info* allocated_type,
+      uint64 alloc_size, void* cookie);
+
+  ArenaOptions()
+      : start_block_size(kDefaultStartBlockSize),
+        max_block_size(kDefaultMaxBlockSize),
+        initial_block(NULL),
+        initial_block_size(0),
+        block_alloc(&::operator new),
+        block_dealloc(&internal::arena_free),
+        on_arena_init(NULL),
+        on_arena_reset(NULL),
+        on_arena_destruction(NULL),
+        on_arena_allocation(NULL) {}
+
+ private:
+  // Constants define default starting block size and max block size for
+  // arena allocator behavior -- see descriptions above.
+  static const size_t kDefaultStartBlockSize = 256;
+  static const size_t kDefaultMaxBlockSize   = 8192;
+};
+
+// Support for non-RTTI environments. (The metrics hooks API uses type
+// information.)
+#ifndef GOOGLE_PROTOBUF_NO_RTTI
+#define RTTI_TYPE_ID(type) (&typeid(type))
+#else
+#define RTTI_TYPE_ID(type) (NULL)
+#endif
+
+// Arena allocator. Arena allocation replaces ordinary (heap-based) allocation
+// with new/delete, and improves performance by aggregating allocations into
+// larger blocks and freeing allocations all at once. Protocol messages are
+// allocated on an arena by using Arena::CreateMessage<T>(Arena*), below, and
+// are automatically freed when the arena is destroyed.
+//
+// This is a thread-safe implementation: multiple threads may allocate from the
+// arena concurrently. Destruction is not thread-safe and the destructing
+// thread must synchronize with users of the arena first.
+//
+// An arena provides two allocation interfaces: CreateMessage<T>, which works
+// for arena-enabled proto2 message types as well as other types that satisfy
+// the appropriate protocol (described below), and Create<T>, which works for
+// any arbitrary type T. CreateMessage<T> is better when the type T supports it,
+// because this interface (i) passes the arena pointer to the created object so
+// that its sub-objects and internal allocations can use the arena too, and (ii)
+// elides the object's destructor call when possible. Create<T> does not place
+// any special requirements on the type T, and will invoke the object's
+// destructor when the arena is destroyed.
+//
+// The arena message allocation protocol, required by CreateMessage<T>, is as
+// follows:
+//
+// - The type T must have (at least) two constructors: a constructor with no
+//   arguments, called when a T is allocated on the heap; and a constructor with
+//   a google::protobuf::Arena* argument, called when a T is allocated on an arena. If the
+//   second constructor is called with a NULL arena pointer, it must be
+//   equivalent to invoking the first (no-argument) constructor.
+//
+// - The type T must have a particular type trait: a nested type
+//   |InternalArenaConstructable_|. This is usually a typedef to |void|. If no
+//   such type trait exists, then the instantiation CreateMessage<T> will fail
+//   to compile.
+//
+// - The type T *may* have the type trait |DestructorSkippable_|. If this type
+//   trait is present in the type, then its destructor will not be called if and
+//   only if it was passed a non-NULL arena pointer. If this type trait is not
+//   present on the type, then its destructor is always called when the
+//   containing arena is destroyed.
+//
+// - One- and two-user-argument forms of CreateMessage<T>() also exist that
+//   forward these constructor arguments to T's constructor: for example,
+//   CreateMessage<T>(Arena*, arg1, arg2) forwards to a constructor T(Arena*,
+//   arg1, arg2).
+//
+// This protocol is implemented by all arena-enabled proto2 message classes as
+// well as RepeatedPtrField.
+//
+// Do NOT subclass Arena. This class will be marked as final when C++11 is
+// enabled.
+class LIBPROTOBUF_EXPORT Arena {
+ public:
+  // Arena constructor taking custom options. See ArenaOptions below for
+  // descriptions of the options available.
+  explicit Arena(const ArenaOptions& options) : impl_(options) {
+    Init(options);
+  }
+
+  // Block overhead.  Use this as a guide for how much to over-allocate the
+  // initial block if you want an allocation of size N to fit inside it.
+  //
+  // WARNING: if you allocate multiple objects, it is difficult to guarantee
+  // that a series of allocations will fit in the initial block, especially if
+  // Arena changes its alignment guarantees in the future!
+  static const size_t kBlockOverhead = internal::ArenaImpl::kHeaderSize;
+
+  // Default constructor with sensible default options, tuned for average
+  // use-cases.
+  Arena() : impl_(ArenaOptions()) { Init(ArenaOptions()); }
+
+  ~Arena() {
+    if (on_arena_reset_ != NULL || on_arena_destruction_ != NULL) {
+      CallDestructorHooks();
+    }
+  }
+
+  void Init(const ArenaOptions& options) {
+    on_arena_allocation_ = options.on_arena_allocation;
+    on_arena_reset_ = options.on_arena_reset;
+    on_arena_destruction_ = options.on_arena_destruction;
+    // Call the initialization hook
+    if (options.on_arena_init != NULL) {
+      hooks_cookie_ = options.on_arena_init(this);
+    } else {
+      hooks_cookie_ = NULL;
+    }
+  }
+
+  // API to create proto2 message objects on the arena. If the arena passed in
+  // is NULL, then a heap allocated object is returned. Type T must be a message
+  // defined in a .proto file with cc_enable_arenas set to true, otherwise a
+  // compilation error will occur.
+  //
+  // RepeatedField and RepeatedPtrField may also be instantiated directly on an
+  // arena with this method.
+  //
+  // This function also accepts any type T that satisfies the arena message
+  // allocation protocol, documented above.
+#if LANG_CXX11
+  template <typename T, typename... Args>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE static T* CreateMessage(
+      ::google::protobuf::Arena* arena, Args&&... args) {
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+    if (arena == NULL) {
+      return new T(NULL, std::forward<Args>(args)...);
+    } else {
+      return arena->CreateMessageInternal<T>(std::forward<Args>(args)...);
+    }
+  }
+#endif
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMessage(::google::protobuf::Arena* arena) {
+#if LANG_CXX11
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+#endif
+    if (arena == NULL) {
+      return new T;
+    } else {
+      return arena->CreateMessageInternal<T>();
+    }
+  }
+
+  // One-argument form of CreateMessage. This is useful for constructing objects
+  // that implement the arena message construction protocol described above but
+  // take additional constructor arguments.
+  template <typename T, typename Arg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMessage(::google::protobuf::Arena* arena, const Arg& arg) {
+#if LANG_CXX11
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+#endif
+    if (arena == NULL) {
+      return new T(NULL, arg);
+    } else {
+      return arena->CreateMessageInternal<T>(arg);
+    }
+  }
+
+  // Two-argument form of CreateMessage. This is useful for constructing objects
+  // that implement the arena message construction protocol described above but
+  // take additional constructor arguments.
+  template <typename T, typename Arg1, typename Arg2>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMessage(::google::protobuf::Arena* arena,
+                          const Arg1& arg1,
+                          const Arg2& arg2) {
+#if LANG_CXX11
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+#endif
+    if (arena == NULL) {
+      return new T(NULL, arg1, arg2);
+    } else {
+      return arena->CreateMessageInternal<T>(arg1, arg2);
+    }
+  }
+
+  // API to create any objects on the arena. Note that only the object will
+  // be created on the arena; the underlying ptrs (in case of a proto2 message)
+  // will be still heap allocated. Proto messages should usually be allocated
+  // with CreateMessage<T>() instead.
+  //
+  // Note that even if T satisfies the arena message construction protocol
+  // (InternalArenaConstructable_ trait and optional DestructorSkippable_
+  // trait), as described above, this function does not follow the protocol;
+  // instead, it treats T as a black-box type, just as if it did not have these
+  // traits. Specifically, T's constructor arguments will always be only those
+  // passed to Create<T>() -- no additional arena pointer is implicitly added.
+  // Furthermore, the destructor will always be called at arena destruction time
+  // (unless the destructor is trivial). Hence, from T's point of view, it is as
+  // if the object were allocated on the heap (except that the underlying memory
+  // is obtained from the arena).
+#if LANG_CXX11
+  template <typename T, typename... Args>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena, Args&&... args) {
+    if (arena == NULL) {
+      return new T(std::forward<Args>(args)...);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      std::forward<Args>(args)...);
+    }
+  }
+#endif
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena) {
+    if (arena == NULL) {
+      return new T();
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value);
+    }
+  }
+
+  // Version of the above with one constructor argument for the created object.
+  template <typename T, typename Arg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena, const Arg& arg) {
+    if (arena == NULL) {
+      return new T(arg);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg);
+    }
+  }
+
+  // Version of the above with two constructor arguments for the created object.
+  template <typename T, typename Arg1, typename Arg2>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena, const Arg1& arg1, const Arg2& arg2) {
+    if (arena == NULL) {
+      return new T(arg1, arg2);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2);
+    }
+  }
+
+  // Version of the above with three constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1,
+                   const Arg2& arg2,
+                   const Arg3& arg3) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3);
+    }
+  }
+
+  // Version of the above with four constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3, arg4);
+    }
+  }
+
+  // Version of the above with five constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4,
+                   const Arg5& arg5) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4, arg5);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3, arg4, arg5);
+    }
+  }
+
+  // Version of the above with six constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4,
+                   const Arg5& arg5, const Arg6& arg6) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4, arg5, arg6);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3, arg4, arg5, arg6);
+    }
+  }
+
+  // Version of the above with seven constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6, typename Arg7>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4,
+                   const Arg5& arg5, const Arg6& arg6,
+                   const Arg7& arg7) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+    }
+  }
+
+  // Version of the above with eight constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6, typename Arg7,
+            typename Arg8>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4,
+                   const Arg5& arg5, const Arg6& arg6,
+                   const Arg7& arg7, const Arg8& arg8) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+    } else {
+      return arena->CreateInternal<T>(
+          google::protobuf::internal::has_trivial_destructor<T>::value,
+          arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+    }
+  }
+
+  // Create an array of object type T on the arena *without* invoking the
+  // constructor of T. If `arena` is null, then the return value should be freed
+  // with `delete[] x;` (or `::operator delete[](x);`).
+  // To ensure safe uses, this function checks at compile time
+  // (when compiled as C++11) that T is trivially default-constructible and
+  // trivially destructible.
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateArray(::google::protobuf::Arena* arena, size_t num_elements) {
+    GOOGLE_CHECK_LE(num_elements,
+             std::numeric_limits<size_t>::max() / sizeof(T))
+        << "Requested size is too large to fit into size_t.";
+    if (arena == NULL) {
+      return static_cast<T*>(::operator new[](num_elements * sizeof(T)));
+    } else {
+      return arena->CreateInternalRawArray<T>(num_elements);
+    }
+  }
+
+  // Returns the total space allocated by the arena, which is the sum of the
+  // sizes of the underlying blocks. This method is relatively fast; a counter
+  // is kept as blocks are allocated.
+  uint64 SpaceAllocated() const { return impl_.SpaceAllocated(); }
+  // Returns the total space used by the arena. Similar to SpaceAllocated but
+  // does not include free space and block overhead. The total space returned
+  // may not include space used by other threads executing concurrently with
+  // the call to this method.
+  uint64 SpaceUsed() const { return impl_.SpaceUsed(); }
+  // DEPRECATED. Please use SpaceAllocated() and SpaceUsed().
+  //
+  // Combines SpaceAllocated and SpaceUsed. Returns a pair of
+  // <space_allocated, space_used>.
+  std::pair<uint64, uint64> SpaceAllocatedAndUsed() const {
+    return std::make_pair(SpaceAllocated(), SpaceUsed());
+  }
+
+  // Frees all storage allocated by this arena after calling destructors
+  // registered with OwnDestructor() and freeing objects registered with Own().
+  // Any objects allocated on this arena are unusable after this call. It also
+  // returns the total space used by the arena which is the sums of the sizes
+  // of the allocated blocks. This method is not thread-safe.
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE uint64 Reset() {
+    // Call the reset hook
+    if (on_arena_reset_ != NULL) {
+      on_arena_reset_(this, hooks_cookie_, impl_.SpaceAllocated());
+    }
+    return impl_.Reset();
+  }
+
+  // Adds |object| to a list of heap-allocated objects to be freed with |delete|
+  // when the arena is destroyed or reset.
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void Own(T* object) {
+    OwnInternal(object, google::protobuf::internal::is_convertible<T*, ::google::protobuf::Message*>());
+  }
+
+  // Adds |object| to a list of objects whose destructors will be manually
+  // called when the arena is destroyed or reset. This differs from Own() in
+  // that it does not free the underlying memory with |delete|; hence, it is
+  // normally only used for objects that are placement-newed into
+  // arena-allocated memory.
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void OwnDestructor(T* object) {
+    if (object != NULL) {
+      impl_.AddCleanup(object, &internal::arena_destruct_object<T>);
+    }
+  }
+
+  // Adds a custom member function on an object to the list of destructors that
+  // will be manually called when the arena is destroyed or reset. This differs
+  // from OwnDestructor() in that any member function may be specified, not only
+  // the class destructor.
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE void OwnCustomDestructor(
+      void* object, void (*destruct)(void*)) {
+    impl_.AddCleanup(object, destruct);
+  }
+
+  // Retrieves the arena associated with |value| if |value| is an arena-capable
+  // message, or NULL otherwise. This differs from value->GetArena() in that the
+  // latter is a virtual call, while this method is a templated call that
+  // resolves at compile-time.
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static ::google::protobuf::Arena* GetArena(const T* value) {
+    return GetArenaInternal(value, is_arena_constructable<T>());
+  }
+
+  template <typename T>
+  class InternalHelper {
+    template <typename U>
+    static char DestructorSkippable(const typename U::DestructorSkippable_*);
+    template <typename U>
+    static double DestructorSkippable(...);
+
+    typedef google::protobuf::internal::integral_constant<
+        bool, sizeof(DestructorSkippable<T>(static_cast<const T*>(0))) ==
+                      sizeof(char) ||
+                  google::protobuf::internal::has_trivial_destructor<T>::value>
+        is_destructor_skippable;
+
+    template<typename U>
+    static char ArenaConstructable(
+        const typename U::InternalArenaConstructable_*);
+    template<typename U>
+    static double ArenaConstructable(...);
+
+    typedef google::protobuf::internal::integral_constant<bool, sizeof(ArenaConstructable<T>(
+                                              static_cast<const T*>(0))) ==
+                                              sizeof(char)>
+        is_arena_constructable;
+
+#if LANG_CXX11
+    template <typename... Args>
+    static T* Construct(void* ptr, Args&&... args) {
+      return new (ptr) T(std::forward<Args>(args)...);
+    }
+#else
+    template <typename Arg1>
+    static T* Construct(void* ptr, const Arg1& arg1) {
+      return new (ptr) T(arg1);
+    }
+    template <typename Arg1, typename Arg2>
+    static T* Construct(void* ptr, const Arg1& arg1, const Arg2& arg2) {
+      return new (ptr) T(arg1, arg2);
+    }
+    template <typename Arg1, typename Arg2, typename Arg3>
+    static T* Construct(void* ptr, const Arg1& arg1,
+                        const Arg2& arg2, const Arg3& arg3) {
+      return new (ptr) T(arg1, arg2, arg3);
+    }
+#endif  // LANG_CXX11
+
+    static Arena* GetArena(const T* p) { return p->GetArenaNoVirtual(); }
+
+    friend class Arena;
+  };
+
+  // Helper typetrait that indicates support for arenas in a type T at compile
+  // time. This is public only to allow construction of higher-level templated
+  // utilities. is_arena_constructable<T>::value is true if the message type T
+  // has arena support enabled, and false otherwise.
+  //
+  // This is inside Arena because only Arena has the friend relationships
+  // necessary to see the underlying generated code traits.
+  template <typename T>
+  struct is_arena_constructable : InternalHelper<T>::is_arena_constructable {};
+
+ private:
+  void CallDestructorHooks();
+  void OnArenaAllocation(const std::type_info* allocated_type, size_t n) const;
+  inline void AllocHook(const std::type_info* allocated_type, size_t n) const {
+    if (GOOGLE_PREDICT_FALSE(hooks_cookie_ != NULL)) {
+      OnArenaAllocation(allocated_type, n);
+    }
+  }
+
+  // Allocate and also optionally call on_arena_allocation callback with the
+  // allocated type info when the hooks are in place in ArenaOptions and
+  // the cookie is not null.
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  void* AllocateInternal(bool skip_explicit_ownership) {
+    const size_t n = internal::AlignUpTo8(sizeof(T));
+    AllocHook(RTTI_TYPE_ID(T), n);
+    // Monitor allocation if needed.
+    if (skip_explicit_ownership) {
+      return impl_.AllocateAligned(n);
+    } else {
+      return impl_.AllocateAlignedAndAddCleanup(
+          n, &internal::arena_destruct_object<T>);
+    }
+  }
+
+  // CreateMessage<T> requires that T supports arenas, but this private method
+  // works whether or not T supports arenas. These are not exposed to user code
+  // as it can cause confusing API usages, and end up having double free in
+  // user code. These are used only internally from LazyField and Repeated
+  // fields, since they are designed to work in all mode combinations.
+  template <typename Msg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static Msg* CreateMaybeMessage(Arena* arena, google::protobuf::internal::true_type) {
+    return CreateMessage<Msg>(arena);
+  }
+
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMaybeMessage(Arena* arena, google::protobuf::internal::false_type) {
+    return Create<T>(arena);
+  }
+
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMaybeMessage(Arena* arena) {
+    return CreateMaybeMessage<T>(arena, is_arena_constructable<T>());
+  }
+
+  // Just allocate the required size for the given type assuming the
+  // type has a trivial constructor.
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternalRawArray(size_t num_elements) {
+    GOOGLE_CHECK_LE(num_elements,
+             std::numeric_limits<size_t>::max() / sizeof(T))
+        << "Requested size is too large to fit into size_t.";
+    const size_t n = internal::AlignUpTo8(sizeof(T) * num_elements);
+    // Monitor allocation if needed.
+    AllocHook(RTTI_TYPE_ID(T), n);
+    return static_cast<T*>(impl_.AllocateAligned(n));
+  }
+
+#if LANG_CXX11
+  template <typename T, typename... Args>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership, Args&&... args) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(std::forward<Args>(args)...);
+  }
+#else
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership) {
+    return new (AllocateInternal<T>(skip_explicit_ownership)) T();
+  }
+
+  template <typename T, typename Arg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership, const Arg& arg) {
+    return new (AllocateInternal<T>(skip_explicit_ownership)) T(arg);
+  }
+
+  template <typename T, typename Arg1, typename Arg2>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2) {
+    return new (AllocateInternal<T>(skip_explicit_ownership)) T(arg1, arg2);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4,
+                    const Arg5& arg5) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4, arg5);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4,
+                    const Arg5& arg5,
+                    const Arg6& arg6) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4, arg5, arg6);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6, typename Arg7>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4,
+                    const Arg5& arg5,
+                    const Arg6& arg6,
+                    const Arg7& arg7) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6, typename Arg7,
+            typename Arg8>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4,
+                    const Arg5& arg5,
+                    const Arg6& arg6,
+                    const Arg7& arg7,
+                    const Arg8& arg8) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  }
+#endif
+#if LANG_CXX11
+  template <typename T, typename... Args>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE T* CreateMessageInternal(
+      Args&&... args) {
+    return InternalHelper<T>::Construct(
+        AllocateInternal<T>(InternalHelper<T>::is_destructor_skippable::value),
+        this, std::forward<Args>(args)...);
+  }
+#endif
+  template <typename T>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE T* CreateMessageInternal() {
+    return InternalHelper<T>::Construct(
+        AllocateInternal<T>(InternalHelper<T>::is_destructor_skippable::value),
+        this);
+  }
+
+  template <typename T, typename Arg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateMessageInternal(const Arg& arg) {
+    return InternalHelper<T>::Construct(
+        AllocateInternal<T>(InternalHelper<T>::is_destructor_skippable::value),
+        this, arg);
+  }
+
+  template <typename T, typename Arg1, typename Arg2>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateMessageInternal(const Arg1& arg1, const Arg2& arg2) {
+    return InternalHelper<T>::Construct(
+        AllocateInternal<T>(InternalHelper<T>::is_destructor_skippable::value),
+        this, arg1, arg2);
+  }
+
+  // CreateInArenaStorage is used to implement map field. Without it,
+  // google::protobuf::Map need to call generated message's protected arena constructor,
+  // which needs to declare google::protobuf::Map as friend of generated message.
+  template <typename T>
+  static void CreateInArenaStorage(T* ptr, Arena* arena) {
+    CreateInArenaStorageInternal(ptr, arena,
+                                 typename is_arena_constructable<T>::type());
+    RegisterDestructorInternal(
+        ptr, arena,
+        typename InternalHelper<T>::is_destructor_skippable::type());
+  }
+
+  template <typename T>
+  static void CreateInArenaStorageInternal(
+      T* ptr, Arena* arena, google::protobuf::internal::true_type) {
+    InternalHelper<T>::Construct(ptr, arena);
+  }
+  template <typename T>
+  static void CreateInArenaStorageInternal(
+      T* ptr, Arena* /* arena */, google::protobuf::internal::false_type) {
+    new (ptr) T();
+  }
+
+  template <typename T>
+  static void RegisterDestructorInternal(
+      T* /* ptr */, Arena* /* arena */, google::protobuf::internal::true_type) {}
+  template <typename T>
+  static void RegisterDestructorInternal(
+      T* ptr, Arena* arena, google::protobuf::internal::false_type) {
+    arena->OwnDestructor(ptr);
+  }
+
+  // These implement Own(), which registers an object for deletion (destructor
+  // call and operator delete()). The second parameter has type 'true_type' if T
+  // is a subtype of ::google::protobuf::Message and 'false_type' otherwise. Collapsing
+  // all template instantiations to one for generic Message reduces code size,
+  // using the virtual destructor instead.
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  void OwnInternal(T* object, google::protobuf::internal::true_type) {
+    if (object != NULL) {
+      impl_.AddCleanup(object,
+                       &internal::arena_delete_object< ::google::protobuf::Message>);
+    }
+  }
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  void OwnInternal(T* object, google::protobuf::internal::false_type) {
+    if (object != NULL) {
+      impl_.AddCleanup(object, &internal::arena_delete_object<T>);
+    }
+  }
+
+  // Implementation for GetArena(). Only message objects with
+  // InternalArenaConstructable_ tags can be associated with an arena, and such
+  // objects must implement a GetArenaNoVirtual() method.
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static ::google::protobuf::Arena* GetArenaInternal(
+      const T* value, google::protobuf::internal::true_type) {
+    return InternalHelper<T>::GetArena(value);
+  }
+
+  template <typename T>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static ::google::protobuf::Arena* GetArenaInternal(
+      const T* /* value */, google::protobuf::internal::false_type) {
+    return NULL;
+  }
+
+  // For friends of arena.
+  void* AllocateAligned(size_t n) {
+    AllocHook(NULL, n);
+    return impl_.AllocateAligned(internal::AlignUpTo8(n));
+  }
+
+  internal::ArenaImpl impl_;
+
+  void* (*on_arena_init_)(Arena* arena);
+  void (*on_arena_allocation_)(const std::type_info* allocated_type,
+                               uint64 alloc_size, void* cookie);
+  void (*on_arena_reset_)(Arena* arena, void* cookie, uint64 space_used);
+  void (*on_arena_destruction_)(Arena* arena, void* cookie, uint64 space_used);
+
+  // The arena may save a cookie it receives from the external on_init hook
+  // and then use it when calling the on_reset and on_destruction hooks.
+  void* hooks_cookie_;
+
+  template <typename Type>
+  friend class ::google::protobuf::internal::GenericTypeHandler;
+  friend struct internal::ArenaStringPtr;  // For AllocateAligned.
+  friend class internal::LazyField;    // For CreateMaybeMessage.
+  template <typename Key, typename T>
+  friend class Map;
+};
+
+// Defined above for supporting environments without RTTI.
+#undef RTTI_TYPE_ID
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_ARENA_H__

kortex_api/include/google/protobuf/arena_impl.h

@@ -0,0 +1,242 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines an Arena allocator for better allocation performance.
+
+#ifndef GOOGLE_PROTOBUF_ARENA_IMPL_H__
+#define GOOGLE_PROTOBUF_ARENA_IMPL_H__
+
+#include <limits>
+
+#include <google/protobuf/stubs/atomic_sequence_num.h>
+#include <google/protobuf/stubs/atomicops.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/stubs/type_traits.h>
+
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+
+namespace protobuf {
+namespace internal {
+
+inline size_t AlignUpTo8(size_t n) {
+  // Align n to next multiple of 8 (from Hacker's Delight, Chapter 3.)
+  return (n + 7) & -8;
+}
+
+// This class provides the core Arena memory allocation library. Different
+// implementations only need to implement the public interface below.
+// Arena is not a template type as that would only be useful if all protos
+// in turn would be templates, which will/cannot happen. However separating
+// the memory allocation part from the cruft of the API users expect we can
+// use #ifdef the select the best implementation based on hardware / OS.
+class LIBPROTOBUF_EXPORT ArenaImpl {
+ public:
+  struct Options {
+    size_t start_block_size;
+    size_t max_block_size;
+    char* initial_block;
+    size_t initial_block_size;
+    void* (*block_alloc)(size_t);
+    void (*block_dealloc)(void*, size_t);
+
+    template <typename O>
+    explicit Options(const O& options)
+      : start_block_size(options.start_block_size),
+        max_block_size(options.max_block_size),
+        initial_block(options.initial_block),
+        initial_block_size(options.initial_block_size),
+        block_alloc(options.block_alloc),
+        block_dealloc(options.block_dealloc) {}
+  };
+
+  template <typename O>
+  explicit ArenaImpl(const O& options) : options_(options) {
+    if (options_.initial_block != NULL && options_.initial_block_size > 0) {
+      GOOGLE_CHECK_GE(options_.initial_block_size, sizeof(Block))
+          << ": Initial block size too small for header.";
+      initial_block_ = reinterpret_cast<Block*>(options_.initial_block);
+    } else {
+      initial_block_ = NULL;
+    }
+
+    Init();
+  }
+
+  // Destructor deletes all owned heap allocated objects, and destructs objects
+  // that have non-trivial destructors, except for proto2 message objects whose
+  // destructors can be skipped. Also, frees all blocks except the initial block
+  // if it was passed in.
+  ~ArenaImpl();
+
+  uint64 Reset();
+
+  uint64 SpaceAllocated() const;
+  uint64 SpaceUsed() const;
+
+  void* AllocateAligned(size_t n);
+
+  void* AllocateAlignedAndAddCleanup(size_t n, void (*cleanup)(void*));
+
+  // Add object pointer and cleanup function pointer to the list.
+  void AddCleanup(void* elem, void (*cleanup)(void*));
+
+ private:
+  // Node contains the ptr of the object to be cleaned up and the associated
+  // cleanup function ptr.
+  struct CleanupNode {
+    void* elem;              // Pointer to the object to be cleaned up.
+    void (*cleanup)(void*);  // Function pointer to the destructor or deleter.
+  };
+
+  // Cleanup uses a chunked linked list, to reduce pointer chasing.
+  struct CleanupChunk {
+    static size_t SizeOf(size_t i) {
+      return sizeof(CleanupChunk) + (sizeof(CleanupNode) * (i - 1));
+    }
+    size_t len;            // Number of elements currently present.
+    size_t size;           // Total elements in the list.
+    CleanupChunk* next;    // Next node in the list.
+    CleanupNode nodes[1];  // True length is |size|.
+  };
+
+  struct Block;
+
+  // Tracks per-thread info.  ThreadInfos are kept in a linked list.
+  struct ThreadInfo {
+    void *owner;             // &ThreadCache of this thread;
+    Block* head;             // Head of linked list of blocks.
+    CleanupChunk* cleanup;   // Head of cleanup list.
+    ThreadInfo* next;        // Next ThreadInfo in this linked list.
+  };
+
+  // Blocks are variable length malloc-ed objects.  The following structure
+  // describes the common header for all blocks.
+  struct Block {
+    void* owner;              // &ThreadCache of thread that owns this block.
+    ThreadInfo* thread_info;  // ThreadInfo of thread that owns this block.
+    Block* next;              // Next block in arena (may have different owner)
+    // ((char*) &block) + pos is next available byte. It is always
+    // aligned at a multiple of 8 bytes.
+    size_t pos;
+    size_t size;  // total size of the block.
+    GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+    size_t avail() const { return size - pos; }
+    // data follows
+  };
+
+  struct ThreadCache {
+#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
+    // If we are using the ThreadLocalStorage class to store the ThreadCache,
+    // then the ThreadCache's default constructor has to be responsible for
+    // initializing it.
+    ThreadCache() : last_lifecycle_id_seen(-1), last_block_used_(NULL) {}
+#endif
+
+    // The ThreadCache is considered valid as long as this matches the
+    // lifecycle_id of the arena being used.
+    int64 last_lifecycle_id_seen;
+    Block* last_block_used_;
+  };
+  static google::protobuf::internal::SequenceNumber lifecycle_id_generator_;
+#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
+  // Android ndk does not support GOOGLE_THREAD_LOCAL keyword so we use a custom thread
+  // local storage class we implemented.
+  // iOS also does not support the GOOGLE_THREAD_LOCAL keyword.
+  static ThreadCache& thread_cache();
+#elif defined(PROTOBUF_USE_DLLS)
+  // Thread local variables cannot be exposed through DLL interface but we can
+  // wrap them in static functions.
+  static ThreadCache& thread_cache();
+#else
+  static GOOGLE_THREAD_LOCAL ThreadCache thread_cache_;
+  static ThreadCache& thread_cache() { return thread_cache_; }
+#endif
+
+  void Init();
+
+  // Free all blocks and return the total space used which is the sums of sizes
+  // of the all the allocated blocks.
+  uint64 FreeBlocks();
+
+  void AddCleanupInBlock(Block* b, void* elem, void (*func)(void*));
+  CleanupChunk* ExpandCleanupList(CleanupChunk* cleanup, Block* b);
+  // Delete or Destruct all objects owned by the arena.
+  void CleanupList();
+
+  inline void CacheBlock(Block* block) {
+    thread_cache().last_block_used_ = block;
+    thread_cache().last_lifecycle_id_seen = lifecycle_id_;
+    // TODO(haberman): evaluate whether we would gain efficiency by getting rid
+    // of hint_.  It's the only write we do to ArenaImpl in the allocation path,
+    // which will dirty the cache line.
+    google::protobuf::internal::Release_Store(&hint_, reinterpret_cast<google::protobuf::internal::AtomicWord>(block));
+  }
+
+  google::protobuf::internal::AtomicWord threads_;          // Pointer to a linked list of ThreadInfo.
+  google::protobuf::internal::AtomicWord hint_;             // Fast thread-local block access
+  google::protobuf::internal::AtomicWord space_allocated_;  // Sum of sizes of all allocated blocks.
+
+  Block *initial_block_;     // If non-NULL, points to the block that came from
+                             // user data.
+
+  // Returns a block owned by this thread.
+  Block* GetBlock(size_t n);
+  Block* GetBlockSlow(void* me, Block* my_full_block, size_t n);
+  Block* NewBlock(void* me, Block* my_last_block, size_t min_bytes);
+  void InitBlock(Block* b, void *me, size_t size);
+  static void* AllocFromBlock(Block* b, size_t n);
+  ThreadInfo* NewThreadInfo(Block* b);
+  ThreadInfo* FindThreadInfo(void* me);
+  ThreadInfo* GetThreadInfo(void* me, size_t n);
+
+  int64 lifecycle_id_;  // Unique for each arena. Changes on Reset().
+
+  Options options_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArenaImpl);
+
+ public:
+  // kHeaderSize is sizeof(Block), aligned up to the nearest multiple of 8 to
+  // protect the invariant that pos is always at a multiple of 8.
+  static const size_t kHeaderSize = (sizeof(Block) + 7) & -8;
+#if LANG_CXX11
+  static_assert(kHeaderSize % 8 == 0, "kHeaderSize must be a multiple of 8.");
+#endif
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_ARENA_IMPL_H__

kortex_api/include/google/protobuf/arenastring.h

@@ -0,0 +1,338 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_ARENASTRING_H__
+#define GOOGLE_PROTOBUF_ARENASTRING_H__
+
+#include <string>
+
+#include <google/protobuf/arena.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/fastmem.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/port.h>
+
+// This is the implementation of arena string fields written for the open-source
+// release. The ArenaStringPtr struct below is an internal implementation class
+// and *should not be used* by user code. It is used to collect string
+// operations together into one place and abstract away the underlying
+// string-field pointer representation, so that (for example) an alternate
+// implementation that knew more about ::std::string's internals could integrate more
+// closely with the arena allocator.
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+struct LIBPROTOBUF_EXPORT ArenaStringPtr {
+  inline void Set(const ::std::string* default_value,
+                  const ::std::string& value, ::google::protobuf::Arena* arena) {
+    if (ptr_ == default_value) {
+      CreateInstance(arena, &value);
+    } else {
+      *ptr_ = value;
+    }
+  }
+
+  inline void SetLite(const ::std::string* default_value,
+                      const ::std::string& value,
+                      ::google::protobuf::Arena* arena) {
+    Set(default_value, value, arena);
+  }
+
+  // Basic accessors.
+  inline const ::std::string& Get() const { return *ptr_; }
+
+  inline ::std::string* Mutable(const ::std::string* default_value,
+                           ::google::protobuf::Arena* arena) {
+    if (ptr_ == default_value) {
+      CreateInstance(arena, default_value);
+    }
+    return ptr_;
+  }
+
+  // Release returns a ::std::string* instance that is heap-allocated and is not
+  // Own()'d by any arena. If the field was not set, it returns NULL. The caller
+  // retains ownership. Clears this field back to NULL state. Used to implement
+  // release_<field>() methods on generated classes.
+  inline ::std::string* Release(const ::std::string* default_value,
+                           ::google::protobuf::Arena* arena) {
+    if (ptr_ == default_value) {
+      return NULL;
+    }
+    ::std::string* released = NULL;
+    if (arena != NULL) {
+      // ptr_ is owned by the arena.
+      released = new ::std::string;
+      released->swap(*ptr_);
+    } else {
+      released = ptr_;
+    }
+    ptr_ = const_cast< ::std::string* >(default_value);
+    return released;
+  }
+
+  // UnsafeArenaRelease returns a ::std::string*, but it may be arena-owned (i.e.
+  // have its destructor already registered) if arena != NULL. If the field was
+  // not set, this returns NULL. This method clears this field back to NULL
+  // state. Used to implement unsafe_arena_release_<field>() methods on
+  // generated classes.
+  inline ::std::string* UnsafeArenaRelease(const ::std::string* default_value,
+                                      ::google::protobuf::Arena* /* arena */) {
+    if (ptr_ == default_value) {
+      return NULL;
+    }
+    ::std::string* released = ptr_;
+    ptr_ = const_cast< ::std::string* >(default_value);
+    return released;
+  }
+
+  // Takes a string that is heap-allocated, and takes ownership. The string's
+  // destructor is registered with the arena. Used to implement
+  // set_allocated_<field> in generated classes.
+  inline void SetAllocated(const ::std::string* default_value,
+                           ::std::string* value, ::google::protobuf::Arena* arena) {
+    if (arena == NULL && ptr_ != default_value) {
+      Destroy(default_value, arena);
+    }
+    if (value != NULL) {
+      ptr_ = value;
+      if (arena != NULL) {
+        arena->Own(value);
+      }
+    } else {
+      ptr_ = const_cast< ::std::string* >(default_value);
+    }
+  }
+
+  // Takes a string that has lifetime equal to the arena's lifetime. The arena
+  // must be non-null. It is safe only to pass this method a value returned by
+  // UnsafeArenaRelease() on another field of a message in the same arena. Used
+  // to implement unsafe_arena_set_allocated_<field> in generated classes.
+  inline void UnsafeArenaSetAllocated(const ::std::string* default_value,
+                                      ::std::string* value,
+                                      ::google::protobuf::Arena* /* arena */) {
+    if (value != NULL) {
+      ptr_ = value;
+    } else {
+      ptr_ = const_cast< ::std::string* >(default_value);
+    }
+  }
+
+  // Swaps internal pointers. Arena-safety semantics: this is guarded by the
+  // logic in Swap()/UnsafeArenaSwap() at the message level, so this method is
+  // 'unsafe' if called directly.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void Swap(ArenaStringPtr* other) {
+    std::swap(ptr_, other->ptr_);
+  }
+
+  // Frees storage (if not on an arena).
+  inline void Destroy(const ::std::string* default_value,
+                      ::google::protobuf::Arena* arena) {
+    if (arena == NULL && ptr_ != default_value) {
+      delete ptr_;
+    }
+  }
+
+  // Clears content, but keeps allocated string if arena != NULL, to avoid the
+  // overhead of heap operations. After this returns, the content (as seen by
+  // the user) will always be the empty string. Assumes that |default_value|
+  // is an empty string.
+  inline void ClearToEmpty(const ::std::string* default_value,
+                           ::google::protobuf::Arena* /* arena */) {
+    if (ptr_ == default_value) {
+      // Already set to default (which is empty) -- do nothing.
+    } else {
+      ptr_->clear();
+    }
+  }
+
+  // Clears content, but keeps allocated string if arena != NULL, to avoid the
+  // overhead of heap operations. After this returns, the content (as seen by
+  // the user) will always be equal to |default_value|.
+  inline void ClearToDefault(const ::std::string* default_value,
+                             ::google::protobuf::Arena* /* arena */) {
+    if (ptr_ == default_value) {
+      // Already set to default -- do nothing.
+    } else {
+      // Have another allocated string -- rather than throwing this away and
+      // resetting ptr_ to the canonical default string instance, we just reuse
+      // this instance.
+      *ptr_ = *default_value;
+    }
+  }
+
+  // Called from generated code / reflection runtime only. Resets value to point
+  // to a default string pointer, with the semantics that this ArenaStringPtr
+  // does not own the pointed-to memory. Disregards initial value of ptr_ (so
+  // this is the *ONLY* safe method to call after construction or when
+  // reinitializing after becoming the active field in a oneof union).
+  inline void UnsafeSetDefault(const ::std::string* default_value) {
+    // Casting away 'const' is safe here: accessors ensure that ptr_ is only
+    // returned as a const if it is equal to default_value.
+    ptr_ = const_cast< ::std::string* >(default_value);
+  }
+
+  // The 'NoArena' variants of methods below assume arena == NULL and are
+  // optimized to provide very little overhead relative to a raw string pointer
+  // (while still being in-memory compatible with other code that assumes
+  // ArenaStringPtr). Note the invariant that a class instance that has only
+  // ever been mutated by NoArena methods must *only* be in the String state
+  // (i.e., tag bits are not used), *NEVER* ArenaString. This allows all
+  // tagged-pointer manipulations to be avoided.
+  inline void SetNoArena(const ::std::string* default_value,
+                         const ::std::string& value) {
+    if (ptr_ == default_value) {
+      CreateInstanceNoArena(&value);
+    } else {
+      *ptr_ = value;
+    }
+  }
+
+#if LANG_CXX11
+  void SetNoArena(const ::std::string* default_value, ::std::string&& value) {
+    if (IsDefault(default_value)) {
+      ptr_ = new ::std::string(std::move(value));
+    } else {
+      *ptr_ = std::move(value);
+    }
+  }
+#endif
+
+  void AssignWithDefault(const ::std::string* default_value, ArenaStringPtr value);
+
+  inline const ::std::string& GetNoArena() const { return *ptr_; }
+
+  inline ::std::string* MutableNoArena(const ::std::string* default_value) {
+    if (ptr_ == default_value) {
+      CreateInstanceNoArena(default_value);
+    }
+    return ptr_;
+  }
+
+  inline ::std::string* ReleaseNoArena(const ::std::string* default_value) {
+    if (ptr_ == default_value) {
+      return NULL;
+    } else {
+      ::std::string* released = ptr_;
+      ptr_ = const_cast< ::std::string* >(default_value);
+      return released;
+    }
+  }
+
+  inline void SetAllocatedNoArena(const ::std::string* default_value,
+                                  ::std::string* value) {
+    if (ptr_ != default_value) {
+      delete ptr_;
+    }
+    if (value != NULL) {
+      ptr_ = value;
+    } else {
+      ptr_ = const_cast< ::std::string* >(default_value);
+    }
+  }
+
+  inline void DestroyNoArena(const ::std::string* default_value) {
+    if (ptr_ != default_value) {
+      delete ptr_;
+    }
+  }
+
+  inline void ClearToEmptyNoArena(const ::std::string* default_value) {
+    if (ptr_ == default_value) {
+      // Nothing: already equal to default (which is the empty string).
+    } else {
+      ptr_->clear();
+    }
+  }
+
+  inline void ClearToDefaultNoArena(const ::std::string* default_value) {
+    if (ptr_ == default_value) {
+      // Nothing: already set to default.
+    } else {
+      // Reuse existing allocated instance.
+      *ptr_ = *default_value;
+    }
+  }
+
+  // Internal accessor used only at parse time to provide direct access to the
+  // raw pointer from the shared parse routine (in the non-arenas case). The
+  // parse routine does the string allocation in order to save code size in the
+  // generated parsing code.
+  inline ::std::string** UnsafeRawStringPointer() {
+    return &ptr_;
+  }
+
+  inline bool IsDefault(const ::std::string* default_value) const {
+    return ptr_ == default_value;
+  }
+
+ private:
+  ::std::string* ptr_;
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void CreateInstance(::google::protobuf::Arena* arena,
+                      const ::std::string* initial_value) {
+    GOOGLE_DCHECK(initial_value != NULL);
+    ptr_ = new ::std::string(*initial_value);
+    if (arena != NULL) {
+      arena->Own(ptr_);
+    }
+  }
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void CreateInstanceNoArena(const ::std::string* initial_value) {
+    GOOGLE_DCHECK(initial_value != NULL);
+    ptr_ = new ::std::string(*initial_value);
+  }
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+
+
+namespace protobuf {
+namespace internal {
+
+inline void ArenaStringPtr::AssignWithDefault(const ::std::string* default_value,
+                                       ArenaStringPtr value) {
+  const ::std::string* me = *UnsafeRawStringPointer();
+  const ::std::string* other = *value.UnsafeRawStringPointer();
+  // If the pointers are the same then do nothing.
+  if (me != other) {
+    SetNoArena(default_value, value.GetNoArena());
+  }
+}
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_ARENASTRING_H__

kortex_api/include/google/protobuf/compiler/code_generator.h

@@ -0,0 +1,176 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines the abstract interface implemented by each of the language-specific
+// code generators.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace google {
+namespace protobuf {
+
+namespace io { class ZeroCopyOutputStream; }
+class FileDescriptor;
+
+namespace compiler {
+class AccessInfoMap;
+
+class Version;
+
+// Defined in this file.
+class CodeGenerator;
+class GeneratorContext;
+
+// The abstract interface to a class which generates code implementing a
+// particular proto file in a particular language.  A number of these may
+// be registered with CommandLineInterface to support various languages.
+class LIBPROTOC_EXPORT CodeGenerator {
+ public:
+  inline CodeGenerator() {}
+  virtual ~CodeGenerator();
+
+  // Generates code for the given proto file, generating one or more files in
+  // the given output directory.
+  //
+  // A parameter to be passed to the generator can be specified on the command
+  // line. This is intended to be used to pass generator specific parameters.
+  // It is empty if no parameter was given. ParseGeneratorParameter (below),
+  // can be used to accept multiple parameters within the single parameter
+  // command line flag.
+  //
+  // Returns true if successful.  Otherwise, sets *error to a description of
+  // the problem (e.g. "invalid parameter") and returns false.
+  virtual bool Generate(const FileDescriptor* file,
+                        const string& parameter,
+                        GeneratorContext* generator_context,
+                        string* error) const = 0;
+
+  // Generates code for all given proto files.
+  //
+  // WARNING: The canonical code generator design produces one or two output
+  // files per input .proto file, and we do not wish to encourage alternate
+  // designs.
+  //
+  // A parameter is given as passed on the command line, as in |Generate()|
+  // above.
+  //
+  // Returns true if successful.  Otherwise, sets *error to a description of
+  // the problem (e.g. "invalid parameter") and returns false.
+  virtual bool GenerateAll(const std::vector<const FileDescriptor*>& files,
+                           const string& parameter,
+                           GeneratorContext* generator_context,
+                           string* error) const;
+
+  // This is no longer used, but this class is part of the opensource protobuf
+  // library, so it has to remain to keep vtables the same for the current
+  // version of the library. When protobufs does a api breaking change, the
+  // method can be removed.
+  virtual bool HasGenerateAll() const { return true; }
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodeGenerator);
+};
+
+// CodeGenerators generate one or more files in a given directory.  This
+// abstract interface represents the directory to which the CodeGenerator is
+// to write and other information about the context in which the Generator
+// runs.
+class LIBPROTOC_EXPORT GeneratorContext {
+ public:
+  inline GeneratorContext() {
+  }
+  virtual ~GeneratorContext();
+
+  // Opens the given file, truncating it if it exists, and returns a
+  // ZeroCopyOutputStream that writes to the file.  The caller takes ownership
+  // of the returned object.  This method never fails (a dummy stream will be
+  // returned instead).
+  //
+  // The filename given should be relative to the root of the source tree.
+  // E.g. the C++ generator, when generating code for "foo/bar.proto", will
+  // generate the files "foo/bar.pb.h" and "foo/bar.pb.cc"; note that
+  // "foo/" is included in these filenames.  The filename is not allowed to
+  // contain "." or ".." components.
+  virtual io::ZeroCopyOutputStream* Open(const string& filename) = 0;
+
+  // Similar to Open() but the output will be appended to the file if exists
+  virtual io::ZeroCopyOutputStream* OpenForAppend(const string& filename);
+
+  // Creates a ZeroCopyOutputStream which will insert code into the given file
+  // at the given insertion point.  See plugin.proto (plugin.pb.h) for more
+  // information on insertion points.  The default implementation
+  // assert-fails -- it exists only for backwards-compatibility.
+  //
+  // WARNING:  This feature is currently EXPERIMENTAL and is subject to change.
+  virtual io::ZeroCopyOutputStream* OpenForInsert(
+      const string& filename, const string& insertion_point);
+
+  // Returns a vector of FileDescriptors for all the files being compiled
+  // in this run.  Useful for languages, such as Go, that treat files
+  // differently when compiled as a set rather than individually.
+  virtual void ListParsedFiles(std::vector<const FileDescriptor*>* output);
+
+  // Retrieves the version number of the protocol compiler associated with
+  // this GeneratorContext.
+  virtual void GetCompilerVersion(Version* version) const;
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratorContext);
+};
+
+// The type GeneratorContext was once called OutputDirectory. This typedef
+// provides backward compatibility.
+typedef GeneratorContext OutputDirectory;
+
+// Several code generators treat the parameter argument as holding a
+// list of options separated by commas.  This helper function parses
+// a set of comma-delimited name/value pairs: e.g.,
+//   "foo=bar,baz,qux=corge"
+// parses to the pairs:
+//   ("foo", "bar"), ("baz", ""), ("qux", "corge")
+void ParseGeneratorParameter(
+    const string&, std::vector<std::pair<string, string> >*);
+
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__

kortex_api/include/google/protobuf/compiler/command_line_interface.h

@@ -0,0 +1,440 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Implements the Protocol Compiler front-end such that it may be reused by
+// custom compilers written to support other languages.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
+#define GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/hash.h>
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+#include <utility>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;            // descriptor.h
+class DescriptorPool;        // descriptor.h
+class FileDescriptor;        // descriptor.h
+class FileDescriptorSet;     // descriptor.h
+class FileDescriptorProto;   // descriptor.pb.h
+template<typename T> class RepeatedPtrField;  // repeated_field.h
+class SimpleDescriptorDatabase;               // descriptor_database.h
+
+namespace compiler {
+
+class CodeGenerator;     // code_generator.h
+class GeneratorContext;  // code_generator.h
+class DiskSourceTree;    // importer.h
+
+// This class implements the command-line interface to the protocol compiler.
+// It is designed to make it very easy to create a custom protocol compiler
+// supporting the languages of your choice.  For example, if you wanted to
+// create a custom protocol compiler binary which includes both the regular
+// C++ support plus support for your own custom output "Foo", you would
+// write a class "FooGenerator" which implements the CodeGenerator interface,
+// then write a main() procedure like this:
+//
+//   int main(int argc, char* argv[]) {
+//     google::protobuf::compiler::CommandLineInterface cli;
+//
+//     // Support generation of C++ source and headers.
+//     google::protobuf::compiler::cpp::CppGenerator cpp_generator;
+//     cli.RegisterGenerator("--cpp_out", &cpp_generator,
+//       "Generate C++ source and header.");
+//
+//     // Support generation of Foo code.
+//     FooGenerator foo_generator;
+//     cli.RegisterGenerator("--foo_out", &foo_generator,
+//       "Generate Foo file.");
+//
+//     return cli.Run(argc, argv);
+//   }
+//
+// The compiler is invoked with syntax like:
+//   protoc --cpp_out=outdir --foo_out=outdir --proto_path=src src/foo.proto
+//
+// The .proto file to compile can be specified on the command line using either
+// its physical file path, or a virtual path relative to a diretory specified
+// in --proto_path. For example, for src/foo.proto, the following two protoc
+// invocations work the same way:
+//   1. protoc --proto_path=src src/foo.proto (physical file path)
+//   2. protoc --proto_path=src foo.proto (virtual path relative to src)
+//
+// If a file path can be interpreted both as a physical file path and as a
+// relative virtual path, the physical file path takes precendence.
+//
+// For a full description of the command-line syntax, invoke it with --help.
+class LIBPROTOC_EXPORT CommandLineInterface {
+ public:
+  static const char* const kPathSeparator;
+
+  CommandLineInterface();
+  ~CommandLineInterface();
+
+  // Register a code generator for a language.
+  //
+  // Parameters:
+  // * flag_name: The command-line flag used to specify an output file of
+  //   this type.  The name must start with a '-'.  If the name is longer
+  //   than one letter, it must start with two '-'s.
+  // * generator: The CodeGenerator which will be called to generate files
+  //   of this type.
+  // * help_text: Text describing this flag in the --help output.
+  //
+  // Some generators accept extra parameters.  You can specify this parameter
+  // on the command-line by placing it before the output directory, separated
+  // by a colon:
+  //   protoc --foo_out=enable_bar:outdir
+  // The text before the colon is passed to CodeGenerator::Generate() as the
+  // "parameter".
+  void RegisterGenerator(const string& flag_name,
+                         CodeGenerator* generator,
+                         const string& help_text);
+
+  // Register a code generator for a language.
+  // Besides flag_name you can specify another option_flag_name that could be
+  // used to pass extra parameters to the registered code generator.
+  // Suppose you have registered a generator by calling:
+  //   command_line_interface.RegisterGenerator("--foo_out", "--foo_opt", ...)
+  // Then you could invoke the compiler with a command like:
+  //   protoc --foo_out=enable_bar:outdir --foo_opt=enable_baz
+  // This will pass "enable_bar,enable_baz" as the parameter to the generator.
+  void RegisterGenerator(const string& flag_name,
+                         const string& option_flag_name,
+                         CodeGenerator* generator,
+                         const string& help_text);
+
+  // Enables "plugins".  In this mode, if a command-line flag ends with "_out"
+  // but does not match any registered generator, the compiler will attempt to
+  // find a "plugin" to implement the generator.  Plugins are just executables.
+  // They should live somewhere in the PATH.
+  //
+  // The compiler determines the executable name to search for by concatenating
+  // exe_name_prefix with the unrecognized flag name, removing "_out".  So, for
+  // example, if exe_name_prefix is "protoc-" and you pass the flag --foo_out,
+  // the compiler will try to run the program "protoc-foo".
+  //
+  // The plugin program should implement the following usage:
+  //   plugin [--out=OUTDIR] [--parameter=PARAMETER] PROTO_FILES < DESCRIPTORS
+  // --out indicates the output directory (as passed to the --foo_out
+  // parameter); if omitted, the current directory should be used.  --parameter
+  // gives the generator parameter, if any was provided (see below).  The
+  // PROTO_FILES list the .proto files which were given on the compiler
+  // command-line; these are the files for which the plugin is expected to
+  // generate output code.  Finally, DESCRIPTORS is an encoded FileDescriptorSet
+  // (as defined in descriptor.proto).  This is piped to the plugin's stdin.
+  // The set will include descriptors for all the files listed in PROTO_FILES as
+  // well as all files that they import.  The plugin MUST NOT attempt to read
+  // the PROTO_FILES directly -- it must use the FileDescriptorSet.
+  //
+  // The plugin should generate whatever files are necessary, as code generators
+  // normally do.  It should write the names of all files it generates to
+  // stdout.  The names should be relative to the output directory, NOT absolute
+  // names or relative to the current directory.  If any errors occur, error
+  // messages should be written to stderr.  If an error is fatal, the plugin
+  // should exit with a non-zero exit code.
+  //
+  // Plugins can have generator parameters similar to normal built-in
+  // generators. Extra generator parameters can be passed in via a matching
+  // "_opt" parameter. For example:
+  //   protoc --plug_out=enable_bar:outdir --plug_opt=enable_baz
+  // This will pass "enable_bar,enable_baz" as the parameter to the plugin.
+  //
+  void AllowPlugins(const string& exe_name_prefix);
+
+  // Run the Protocol Compiler with the given command-line parameters.
+  // Returns the error code which should be returned by main().
+  //
+  // It may not be safe to call Run() in a multi-threaded environment because
+  // it calls strerror().  I'm not sure why you'd want to do this anyway.
+  int Run(int argc, const char* const argv[]);
+
+  // DEPRECATED. Calling this method has no effect. Protocol compiler now
+  // always try to find the .proto file relative to the current directory
+  // first and if the file is not found, it will then treat the input path
+  // as a virutal path.
+  void SetInputsAreProtoPathRelative(bool /* enable */) {}
+
+  // Provides some text which will be printed when the --version flag is
+  // used.  The version of libprotoc will also be printed on the next line
+  // after this text.
+  void SetVersionInfo(const string& text) {
+    version_info_ = text;
+  }
+
+
+ private:
+  // -----------------------------------------------------------------
+
+  class ErrorPrinter;
+  class GeneratorContextImpl;
+  class MemoryOutputStream;
+  typedef hash_map<string, GeneratorContextImpl*> GeneratorContextMap;
+
+  // Clear state from previous Run().
+  void Clear();
+
+  // Remaps each file in input_files_ so that it is relative to one of the
+  // directories in proto_path_.  Returns false if an error occurred.  This
+  // is only used if inputs_are_proto_path_relative_ is false.
+  bool MakeInputsBeProtoPathRelative(
+    DiskSourceTree* source_tree);
+
+  // Return status for ParseArguments() and InterpretArgument().
+  enum ParseArgumentStatus {
+    PARSE_ARGUMENT_DONE_AND_CONTINUE,
+    PARSE_ARGUMENT_DONE_AND_EXIT,
+    PARSE_ARGUMENT_FAIL
+  };
+
+  // Parse all command-line arguments.
+  ParseArgumentStatus ParseArguments(int argc, const char* const argv[]);
+
+  // Read an argument file and append the file's content to the list of
+  // arguments. Return false if the file cannot be read.
+  bool ExpandArgumentFile(const string& file, std::vector<string>* arguments);
+
+  // Parses a command-line argument into a name/value pair.  Returns
+  // true if the next argument in the argv should be used as the value,
+  // false otherwise.
+  //
+  // Examples:
+  //   "-Isrc/protos" ->
+  //     name = "-I", value = "src/protos"
+  //   "--cpp_out=src/foo.pb2.cc" ->
+  //     name = "--cpp_out", value = "src/foo.pb2.cc"
+  //   "foo.proto" ->
+  //     name = "", value = "foo.proto"
+  bool ParseArgument(const char* arg, string* name, string* value);
+
+  // Interprets arguments parsed with ParseArgument.
+  ParseArgumentStatus InterpretArgument(const string& name,
+                                        const string& value);
+
+  // Print the --help text to stderr.
+  void PrintHelpText();
+
+  // Loads proto_path_ into the provided source_tree.
+  bool InitializeDiskSourceTree(DiskSourceTree* source_tree);
+
+  // Loads descriptor_set_in into the provided database
+  bool PopulateSimpleDescriptorDatabase(SimpleDescriptorDatabase* database);
+
+  // Parses input_files_ into parsed_files
+  bool ParseInputFiles(DescriptorPool* descriptor_pool,
+                       std::vector<const FileDescriptor*>* parsed_files);
+
+  // Generate the given output file from the given input.
+  struct OutputDirective;  // see below
+  bool GenerateOutput(const std::vector<const FileDescriptor*>& parsed_files,
+                      const OutputDirective& output_directive,
+                      GeneratorContext* generator_context);
+  bool GeneratePluginOutput(
+      const std::vector<const FileDescriptor*>& parsed_files,
+      const string& plugin_name, const string& parameter,
+      GeneratorContext* generator_context, string* error);
+
+  // Implements --encode and --decode.
+  bool EncodeOrDecode(const DescriptorPool* pool);
+
+  // Implements the --descriptor_set_out option.
+  bool WriteDescriptorSet(
+      const std::vector<const FileDescriptor*>& parsed_files);
+
+  // Implements the --dependency_out option
+  bool GenerateDependencyManifestFile(
+      const std::vector<const FileDescriptor*>& parsed_files,
+      const GeneratorContextMap& output_directories,
+      DiskSourceTree* source_tree);
+
+  // Get all transitive dependencies of the given file (including the file
+  // itself), adding them to the given list of FileDescriptorProtos.  The
+  // protos will be ordered such that every file is listed before any file that
+  // depends on it, so that you can call DescriptorPool::BuildFile() on them
+  // in order.  Any files in *already_seen will not be added, and each file
+  // added will be inserted into *already_seen.  If include_source_code_info is
+  // true then include the source code information in the FileDescriptorProtos.
+  // If include_json_name is true, populate the json_name field of
+  // FieldDescriptorProto for all fields.
+  static void GetTransitiveDependencies(
+      const FileDescriptor* file,
+      bool include_json_name,
+      bool include_source_code_info,
+      std::set<const FileDescriptor*>* already_seen,
+      RepeatedPtrField<FileDescriptorProto>* output);
+
+  // Implements the --print_free_field_numbers. This function prints free field
+  // numbers into stdout for the message and it's nested message types in
+  // post-order, i.e. nested types first. Printed range are left-right
+  // inclusive, i.e. [a, b].
+  //
+  // Groups:
+  // For historical reasons, groups are considered to share the same
+  // field number space with the parent message, thus it will not print free
+  // field numbers for groups. The field numbers used in the groups are
+  // excluded in the free field numbers of the parent message.
+  //
+  // Extension Ranges:
+  // Extension ranges are considered ocuppied field numbers and they will not be
+  // listed as free numbers in the output.
+  void PrintFreeFieldNumbers(const Descriptor* descriptor);
+
+  // -----------------------------------------------------------------
+
+  // The name of the executable as invoked (i.e. argv[0]).
+  string executable_name_;
+
+  // Version info set with SetVersionInfo().
+  string version_info_;
+
+  // Registered generators.
+  struct GeneratorInfo {
+    string flag_name;
+    string option_flag_name;
+    CodeGenerator* generator;
+    string help_text;
+  };
+  typedef std::map<string, GeneratorInfo> GeneratorMap;
+  GeneratorMap generators_by_flag_name_;
+  GeneratorMap generators_by_option_name_;
+  // A map from generator names to the parameters specified using the option
+  // flag. For example, if the user invokes the compiler with:
+  //   protoc --foo_out=outputdir --foo_opt=enable_bar ...
+  // Then there will be an entry ("--foo_out", "enable_bar") in this map.
+  std::map<string, string> generator_parameters_;
+  // Similar to generator_parameters_, but stores the parameters for plugins.
+  std::map<string, string> plugin_parameters_;
+
+  // See AllowPlugins().  If this is empty, plugins aren't allowed.
+  string plugin_prefix_;
+
+  // Maps specific plugin names to files.  When executing a plugin, this map
+  // is searched first to find the plugin executable.  If not found here, the
+  // PATH (or other OS-specific search strategy) is searched.
+  std::map<string, string> plugins_;
+
+  // Stuff parsed from command line.
+  enum Mode {
+    MODE_COMPILE,  // Normal mode:  parse .proto files and compile them.
+    MODE_ENCODE,   // --encode:  read text from stdin, write binary to stdout.
+    MODE_DECODE,   // --decode:  read binary from stdin, write text to stdout.
+    MODE_PRINT,    // Print mode: print info of the given .proto files and exit.
+  };
+
+  Mode mode_;
+
+  enum PrintMode {
+    PRINT_NONE,               // Not in MODE_PRINT
+    PRINT_FREE_FIELDS,        // --print_free_fields
+  };
+
+  PrintMode print_mode_;
+
+  enum ErrorFormat {
+    ERROR_FORMAT_GCC,   // GCC error output format (default).
+    ERROR_FORMAT_MSVS   // Visual Studio output (--error_format=msvs).
+  };
+
+  ErrorFormat error_format_;
+
+  std::vector<std::pair<string, string> >
+      proto_path_;                   // Search path for proto files.
+  std::vector<string> input_files_;  // Names of the input proto files.
+
+  // Names of proto files which are allowed to be imported. Used by build
+  // systems to enforce depend-on-what-you-import.
+  std::set<string> direct_dependencies_;
+  bool direct_dependencies_explicitly_set_;
+
+  // If there's a violation of depend-on-what-you-import, this string will be
+  // presented to the user. "%s" will be replaced with the violating import.
+  string direct_dependencies_violation_msg_;
+
+  // output_directives_ lists all the files we are supposed to output and what
+  // generator to use for each.
+  struct OutputDirective {
+    string name;                // E.g. "--foo_out"
+    CodeGenerator* generator;   // NULL for plugins
+    string parameter;
+    string output_location;
+  };
+  std::vector<OutputDirective> output_directives_;
+
+  // When using --encode or --decode, this names the type we are encoding or
+  // decoding.  (Empty string indicates --decode_raw.)
+  string codec_type_;
+
+  // If --descriptor_set_in was given, these are filenames containing
+  // parsed FileDescriptorSets to be used for loading protos.  Otherwise, empty.
+  std::vector<string> descriptor_set_in_names_;
+
+  // If --descriptor_set_out was given, this is the filename to which the
+  // FileDescriptorSet should be written.  Otherwise, empty.
+  string descriptor_set_out_name_;
+
+  // If --dependency_out was given, this is the path to the file where the
+  // dependency file will be written. Otherwise, empty.
+  string dependency_out_name_;
+
+  // Path to a file that contains serialized AccessInfo which provides
+  // relative hotness of fields per message. This helps protoc to generate
+  // better code.
+  string profile_path_;
+
+  // True if --include_imports was given, meaning that we should
+  // write all transitive dependencies to the DescriptorSet.  Otherwise, only
+  // the .proto files listed on the command-line are added.
+  bool imports_in_descriptor_set_;
+
+  // True if --include_source_info was given, meaning that we should not strip
+  // SourceCodeInfo from the DescriptorSet.
+  bool source_info_in_descriptor_set_;
+
+  // Was the --disallow_services flag used?
+  bool disallow_services_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CommandLineInterface);
+};
+
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__

kortex_api/include/google/protobuf/compiler/cpp/cpp_generator.h

@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Generates C++ code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace cpp {
+
+// CodeGenerator implementation which generates a C++ source file and
+// header.  If you create your own protocol compiler binary and you want
+// it to support C++ output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT CppGenerator : public CodeGenerator {
+ public:
+  CppGenerator();
+  ~CppGenerator();
+
+  // implements CodeGenerator ----------------------------------------
+  bool Generate(const FileDescriptor* file,
+                const string& parameter,
+                GeneratorContext* generator_context,
+                string* error) const;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CppGenerator);
+};
+
+}  // namespace cpp
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__

kortex_api/include/google/protobuf/compiler/csharp/csharp_generator.h

@@ -0,0 +1,64 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates C# code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CSHARP_GENERATOR_H__
+
+#include <string>
+
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace csharp {
+
+// CodeGenerator implementation which generates a C# source file and
+// header.  If you create your own protocol compiler binary and you want
+// it to support C# output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT Generator
+    : public google::protobuf::compiler::CodeGenerator {
+public:
+  virtual bool Generate(
+      const FileDescriptor* file,
+      const string& parameter,
+      GeneratorContext* generator_context,
+      string* error) const;
+};
+
+}  // namespace csharp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_GENERATOR_H__

kortex_api/include/google/protobuf/compiler/csharp/csharp_names.h

@@ -0,0 +1,104 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Provides a mechanism for mapping a descriptor to the
+// fully-qualified name of the corresponding C# class.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__
+#define GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__
+
+#include <string>
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class FileDescriptor;
+class ServiceDescriptor;
+
+namespace compiler {
+namespace csharp {
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The namespace to use for given file descriptor.
+string LIBPROTOC_EXPORT GetFileNamespace(const FileDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified C# class name.
+string LIBPROTOC_EXPORT GetClassName(const Descriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified name of the C# class that provides
+//   access to the file descriptor. Proto compiler generates
+//   such class for each .proto file processed.
+string LIBPROTOC_EXPORT GetReflectionClassName(const FileDescriptor* descriptor);
+
+// Generates output file name for given file descriptor. If generate_directories
+// is true, the output file will be put under directory corresponding to file's
+// namespace. base_namespace can be used to strip some of the top level
+// directories. E.g. for file with namespace "Bar.Foo" and base_namespace="Bar",
+// the resulting file will be put under directory "Foo" (and not "Bar/Foo").
+//
+// Requires:
+//   descriptor != NULL
+//   error != NULL
+//
+//  Returns:
+//    The file name to use as output file for given file descriptor. In case
+//    of failure, this function will return empty string and error parameter
+//    will contain the error message.
+string LIBPROTOC_EXPORT GetOutputFile(
+    const google::protobuf::FileDescriptor* descriptor,
+    const string file_extension,
+    const bool generate_directories,
+    const string base_namespace,
+    string* error);
+
+}  // namespace csharp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__

kortex_api/include/google/protobuf/compiler/importer.h

@@ -0,0 +1,327 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file is the public interface to the .proto file parser.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
+#define GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
+
+#include <string>
+#include <vector>
+#include <set>
+#include <utility>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor_database.h>
+#include <google/protobuf/compiler/parser.h>
+
+namespace google {
+namespace protobuf {
+
+namespace io { class ZeroCopyInputStream; }
+
+namespace compiler {
+
+// Defined in this file.
+class Importer;
+class MultiFileErrorCollector;
+class SourceTree;
+class DiskSourceTree;
+
+// TODO(kenton):  Move all SourceTree stuff to a separate file?
+
+// An implementation of DescriptorDatabase which loads files from a SourceTree
+// and parses them.
+//
+// Note:  This class is not thread-safe since it maintains a table of source
+//   code locations for error reporting.  However, when a DescriptorPool wraps
+//   a DescriptorDatabase, it uses mutex locking to make sure only one method
+//   of the database is called at a time, even if the DescriptorPool is used
+//   from multiple threads.  Therefore, there is only a problem if you create
+//   multiple DescriptorPools wrapping the same SourceTreeDescriptorDatabase
+//   and use them from multiple threads.
+//
+// Note:  This class does not implement FindFileContainingSymbol() or
+//   FindFileContainingExtension(); these will always return false.
+class LIBPROTOBUF_EXPORT SourceTreeDescriptorDatabase : public DescriptorDatabase {
+ public:
+  SourceTreeDescriptorDatabase(SourceTree* source_tree);
+  ~SourceTreeDescriptorDatabase();
+
+  // Instructs the SourceTreeDescriptorDatabase to report any parse errors
+  // to the given MultiFileErrorCollector.  This should be called before
+  // parsing.  error_collector must remain valid until either this method
+  // is called again or the SourceTreeDescriptorDatabase is destroyed.
+  void RecordErrorsTo(MultiFileErrorCollector* error_collector) {
+    error_collector_ = error_collector;
+  }
+
+  // Gets a DescriptorPool::ErrorCollector which records errors to the
+  // MultiFileErrorCollector specified with RecordErrorsTo().  This collector
+  // has the ability to determine exact line and column numbers of errors
+  // from the information given to it by the DescriptorPool.
+  DescriptorPool::ErrorCollector* GetValidationErrorCollector() {
+    using_validation_error_collector_ = true;
+    return &validation_error_collector_;
+  }
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const string& filename, FileDescriptorProto* output);
+  bool FindFileContainingSymbol(const string& symbol_name,
+                                FileDescriptorProto* output);
+  bool FindFileContainingExtension(const string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output);
+
+ private:
+  class SingleFileErrorCollector;
+
+  SourceTree* source_tree_;
+  MultiFileErrorCollector* error_collector_;
+
+  class LIBPROTOBUF_EXPORT ValidationErrorCollector : public DescriptorPool::ErrorCollector {
+   public:
+    ValidationErrorCollector(SourceTreeDescriptorDatabase* owner);
+    ~ValidationErrorCollector();
+
+    // implements ErrorCollector ---------------------------------------
+    void AddError(const string& filename,
+                  const string& element_name,
+                  const Message* descriptor,
+                  ErrorLocation location,
+                  const string& message);
+
+    virtual void AddWarning(const string& filename,
+                            const string& element_name,
+                            const Message* descriptor,
+                            ErrorLocation location,
+                            const string& message);
+
+   private:
+    SourceTreeDescriptorDatabase* owner_;
+  };
+  friend class ValidationErrorCollector;
+
+  bool using_validation_error_collector_;
+  SourceLocationTable source_locations_;
+  ValidationErrorCollector validation_error_collector_;
+};
+
+// Simple interface for parsing .proto files.  This wraps the process
+// of opening the file, parsing it with a Parser, recursively parsing all its
+// imports, and then cross-linking the results to produce a FileDescriptor.
+//
+// This is really just a thin wrapper around SourceTreeDescriptorDatabase.
+// You may find that SourceTreeDescriptorDatabase is more flexible.
+//
+// TODO(kenton):  I feel like this class is not well-named.
+class LIBPROTOBUF_EXPORT Importer {
+ public:
+  Importer(SourceTree* source_tree,
+           MultiFileErrorCollector* error_collector);
+  ~Importer();
+
+  // Import the given file and build a FileDescriptor representing it.  If
+  // the file is already in the DescriptorPool, the existing FileDescriptor
+  // will be returned.  The FileDescriptor is property of the DescriptorPool,
+  // and will remain valid until it is destroyed.  If any errors occur, they
+  // will be reported using the error collector and Import() will return NULL.
+  //
+  // A particular Importer object will only report errors for a particular
+  // file once.  All future attempts to import the same file will return NULL
+  // without reporting any errors.  The idea is that you might want to import
+  // a lot of files without seeing the same errors over and over again.  If
+  // you want to see errors for the same files repeatedly, you can use a
+  // separate Importer object to import each one (but use the same
+  // DescriptorPool so that they can be cross-linked).
+  const FileDescriptor* Import(const string& filename);
+
+  // The DescriptorPool in which all imported FileDescriptors and their
+  // contents are stored.
+  inline const DescriptorPool* pool() const {
+    return &pool_;
+  }
+
+  void AddUnusedImportTrackFile(const string& file_name);
+  void ClearUnusedImportTrackFiles();
+
+
+ private:
+  SourceTreeDescriptorDatabase database_;
+  DescriptorPool pool_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Importer);
+};
+
+// If the importer encounters problems while trying to import the proto files,
+// it reports them to a MultiFileErrorCollector.
+class LIBPROTOBUF_EXPORT MultiFileErrorCollector {
+ public:
+  inline MultiFileErrorCollector() {}
+  virtual ~MultiFileErrorCollector();
+
+  // Line and column numbers are zero-based.  A line number of -1 indicates
+  // an error with the entire file (e.g. "not found").
+  virtual void AddError(const string& filename, int line, int column,
+                        const string& message) = 0;
+
+  virtual void AddWarning(const string& filename, int line, int column,
+                          const string& message) {}
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MultiFileErrorCollector);
+};
+
+// Abstract interface which represents a directory tree containing proto files.
+// Used by the default implementation of Importer to resolve import statements
+// Most users will probably want to use the DiskSourceTree implementation,
+// below.
+class LIBPROTOBUF_EXPORT SourceTree {
+ public:
+  inline SourceTree() {}
+  virtual ~SourceTree();
+
+  // Open the given file and return a stream that reads it, or NULL if not
+  // found.  The caller takes ownership of the returned object.  The filename
+  // must be a path relative to the root of the source tree and must not
+  // contain "." or ".." components.
+  virtual io::ZeroCopyInputStream* Open(const string& filename) = 0;
+
+  // If Open() returns NULL, calling this method immediately will return an
+  // description of the error.
+  // Subclasses should implement this method and return a meaningful value for
+  // better error reporting.
+  // TODO(xiaofeng): change this to a pure virtual function.
+  virtual string GetLastErrorMessage();
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SourceTree);
+};
+
+// An implementation of SourceTree which loads files from locations on disk.
+// Multiple mappings can be set up to map locations in the DiskSourceTree to
+// locations in the physical filesystem.
+class LIBPROTOBUF_EXPORT DiskSourceTree : public SourceTree {
+ public:
+  DiskSourceTree();
+  ~DiskSourceTree();
+
+  // Map a path on disk to a location in the SourceTree.  The path may be
+  // either a file or a directory.  If it is a directory, the entire tree
+  // under it will be mapped to the given virtual location.  To map a directory
+  // to the root of the source tree, pass an empty string for virtual_path.
+  //
+  // If multiple mapped paths apply when opening a file, they will be searched
+  // in order.  For example, if you do:
+  //   MapPath("bar", "foo/bar");
+  //   MapPath("", "baz");
+  // and then you do:
+  //   Open("bar/qux");
+  // the DiskSourceTree will first try to open foo/bar/qux, then baz/bar/qux,
+  // returning the first one that opens successfuly.
+  //
+  // disk_path may be an absolute path or relative to the current directory,
+  // just like a path you'd pass to open().
+  void MapPath(const string& virtual_path, const string& disk_path);
+
+  // Return type for DiskFileToVirtualFile().
+  enum DiskFileToVirtualFileResult {
+    SUCCESS,
+    SHADOWED,
+    CANNOT_OPEN,
+    NO_MAPPING
+  };
+
+  // Given a path to a file on disk, find a virtual path mapping to that
+  // file.  The first mapping created with MapPath() whose disk_path contains
+  // the filename is used.  However, that virtual path may not actually be
+  // usable to open the given file.  Possible return values are:
+  // * SUCCESS: The mapping was found.  *virtual_file is filled in so that
+  //   calling Open(*virtual_file) will open the file named by disk_file.
+  // * SHADOWED: A mapping was found, but using Open() to open this virtual
+  //   path will end up returning some different file.  This is because some
+  //   other mapping with a higher precedence also matches this virtual path
+  //   and maps it to a different file that exists on disk.  *virtual_file
+  //   is filled in as it would be in the SUCCESS case.  *shadowing_disk_file
+  //   is filled in with the disk path of the file which would be opened if
+  //   you were to call Open(*virtual_file).
+  // * CANNOT_OPEN: The mapping was found and was not shadowed, but the
+  //   file specified cannot be opened.  When this value is returned,
+  //   errno will indicate the reason the file cannot be opened.  *virtual_file
+  //   will be set to the virtual path as in the SUCCESS case, even though
+  //   it is not useful.
+  // * NO_MAPPING: Indicates that no mapping was found which contains this
+  //   file.
+  DiskFileToVirtualFileResult
+    DiskFileToVirtualFile(const string& disk_file,
+                          string* virtual_file,
+                          string* shadowing_disk_file);
+
+  // Given a virtual path, find the path to the file on disk.
+  // Return true and update disk_file with the on-disk path if the file exists.
+  // Return false and leave disk_file untouched if the file doesn't exist.
+  bool VirtualFileToDiskFile(const string& virtual_file, string* disk_file);
+
+  // implements SourceTree -------------------------------------------
+  virtual io::ZeroCopyInputStream* Open(const string& filename);
+
+  virtual string GetLastErrorMessage();
+
+ private:
+  struct Mapping {
+    string virtual_path;
+    string disk_path;
+
+    inline Mapping(const string& virtual_path_param,
+                   const string& disk_path_param)
+      : virtual_path(virtual_path_param), disk_path(disk_path_param) {}
+  };
+  std::vector<Mapping> mappings_;
+  string last_error_message_;
+
+  // Like Open(), but returns the on-disk path in disk_file if disk_file is
+  // non-NULL and the file could be successfully opened.
+  io::ZeroCopyInputStream* OpenVirtualFile(const string& virtual_file,
+                                           string* disk_file);
+
+  // Like Open() but given the actual on-disk path.
+  io::ZeroCopyInputStream* OpenDiskFile(const string& filename);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DiskSourceTree);
+};
+
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__

kortex_api/include/google/protobuf/compiler/java/java_generator.h

@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Generates Java code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace java {
+
+// CodeGenerator implementation which generates Java code.  If you create your
+// own protocol compiler binary and you want it to support Java output, you
+// can do so by registering an instance of this CodeGenerator with the
+// CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT JavaGenerator : public CodeGenerator {
+ public:
+  JavaGenerator();
+  ~JavaGenerator();
+
+  // implements CodeGenerator ----------------------------------------
+  bool Generate(const FileDescriptor* file,
+                const string& parameter,
+                GeneratorContext* context,
+                string* error) const;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(JavaGenerator);
+};
+
+}  // namespace java
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_GENERATOR_H__

kortex_api/include/google/protobuf/compiler/java/java_names.h

@@ -0,0 +1,87 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Provides a mechanism for mapping a descriptor to the
+// fully-qualified name of the corresponding Java class.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__
+
+#include <string>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class FileDescriptor;
+class ServiceDescriptor;
+
+namespace compiler {
+namespace java {
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+string ClassName(const Descriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+string ClassName(const EnumDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+string ClassName(const FileDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+string ClassName(const ServiceDescriptor* descriptor);
+
+}  // namespace java
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__

kortex_api/include/google/protobuf/compiler/javanano/javanano_generator.h

@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Generates Java nano code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVANANO_NANO_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVANANO_NANO_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javanano {
+
+// CodeGenerator implementation which generates Java nano code.  If you create your
+// own protocol compiler binary and you want it to support Java output for the
+// nano runtime, you can do so by registering an instance of this CodeGenerator with
+// the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT JavaNanoGenerator : public CodeGenerator {
+ public:
+  JavaNanoGenerator();
+  ~JavaNanoGenerator();
+
+  // implements CodeGenerator ----------------------------------------
+  bool Generate(const FileDescriptor* file,
+                const string& parameter,
+                GeneratorContext* output_directory,
+                string* error) const;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(JavaNanoGenerator);
+};
+
+}  // namespace javanano
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVANANO_NANO_GENERATOR_H__

kortex_api/include/google/protobuf/compiler/js/js_generator.h

@@ -0,0 +1,333 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates JavaScript code for a given .proto file.
+//
+#ifndef GOOGLE_PROTOBUF_COMPILER_JS_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_JS_GENERATOR_H__
+
+#include <string>
+#include <set>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class FieldDescriptor;
+class OneofDescriptor;
+class FileDescriptor;
+
+namespace io { class Printer; }
+
+namespace compiler {
+namespace js {
+
+struct GeneratorOptions {
+  // Output path.
+  string output_dir;
+  // Namespace prefix.
+  string namespace_prefix;
+  // Enable binary-format support?
+  bool binary;
+  // What style of imports should be used.
+  enum ImportStyle {
+    kImportClosure,   // goog.require()
+    kImportCommonJs,  // require()
+    kImportBrowser,   // no import statements
+    kImportEs6,       // import { member } from ''
+  } import_style;
+
+  GeneratorOptions()
+      : output_dir("."),
+        namespace_prefix(""),
+        binary(false),
+        import_style(kImportClosure),
+        add_require_for_enums(false),
+        testonly(false),
+        library(""),
+        error_on_name_conflict(false),
+        extension(".js"),
+        one_output_file_per_input_file(false),
+        annotate_code(false) {}
+
+  bool ParseFromOptions(
+      const std::vector< std::pair< string, string > >& options,
+      string* error);
+
+  // Returns the file name extension to use for generated code.
+  string GetFileNameExtension() const {
+    return import_style == kImportClosure ? extension : "_pb.js";
+  }
+
+  enum OutputMode {
+    // Create an output file for each input .proto file.
+    kOneOutputFilePerInputFile,
+    // Create an output file for each type.
+    kOneOutputFilePerType,
+    // Put everything in a single file named by the library option.
+    kEverythingInOneFile,
+  };
+
+  // Indicates how to output the generated code based on the provided options.
+  OutputMode output_mode() const;
+
+  // The remaining options are only relevant when we are using kImportClosure.
+
+  // Add a `goog.requires()` call for each enum type used. If not set, a
+  // forward declaration with `goog.forwardDeclare` is produced instead.
+  bool add_require_for_enums;
+  // Set this as a test-only module via `goog.setTestOnly();`.
+  bool testonly;
+  // Create a library with name <name>_lib.js rather than a separate .js file
+  // per type?
+  string library;
+  // Error if there are two types that would generate the same output file?
+  bool error_on_name_conflict;
+  // The extension to use for output file names.
+  string extension;
+  // Create a separate output file for each input file?
+  bool one_output_file_per_input_file;
+  // If true, we should build .meta files that contain annotations for
+  // generated code. See GeneratedCodeInfo in descriptor.proto.
+  bool annotate_code;
+};
+
+// CodeGenerator implementation which generates a JavaScript source file and
+// header.  If you create your own protocol compiler binary and you want it to
+// support JavaScript output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT Generator : public CodeGenerator {
+ public:
+  Generator() {}
+  virtual ~Generator() {}
+
+  virtual bool Generate(const FileDescriptor* file,
+                        const string& parameter,
+                        GeneratorContext* context,
+                        string* error) const {
+    *error = "Unimplemented Generate() method. Call GenerateAll() instead.";
+    return false;
+  }
+
+  virtual bool HasGenerateAll() const { return true; }
+
+  virtual bool GenerateAll(const std::vector<const FileDescriptor*>& files,
+                           const string& parameter,
+                           GeneratorContext* context,
+                           string* error) const;
+
+ private:
+  void GenerateHeader(const GeneratorOptions& options,
+                      io::Printer* printer) const;
+
+  // Generate goog.provides() calls.
+  void FindProvides(const GeneratorOptions& options,
+                    io::Printer* printer,
+                    const std::vector<const FileDescriptor*>& file,
+                    std::set<string>* provided) const;
+  void FindProvidesForFile(const GeneratorOptions& options,
+                           io::Printer* printer,
+                           const FileDescriptor* file,
+                           std::set<string>* provided) const;
+  void FindProvidesForMessage(const GeneratorOptions& options,
+                              io::Printer* printer,
+                              const Descriptor* desc,
+                              std::set<string>* provided) const;
+  void FindProvidesForEnum(const GeneratorOptions& options,
+                           io::Printer* printer,
+                           const EnumDescriptor* enumdesc,
+                           std::set<string>* provided) const;
+  // For extension fields at file scope.
+  void FindProvidesForFields(const GeneratorOptions& options,
+                             io::Printer* printer,
+                             const std::vector<const FieldDescriptor*>& fields,
+                             std::set<string>* provided) const;
+  // Print the goog.provides() found by the methods above.
+  void GenerateProvides(const GeneratorOptions& options,
+                        io::Printer* printer,
+                        std::set<string>* provided) const;
+
+  // Generate goog.setTestOnly() if indicated.
+  void GenerateTestOnly(const GeneratorOptions& options,
+                        io::Printer* printer) const;
+
+  // Generate goog.requires() calls.
+  void GenerateRequiresForLibrary(
+      const GeneratorOptions& options, io::Printer* printer,
+      const std::vector<const FileDescriptor*>& files,
+      std::set<string>* provided) const;
+  void GenerateRequiresForMessage(const GeneratorOptions& options,
+                        io::Printer* printer,
+                        const Descriptor* desc,
+                        std::set<string>* provided) const;
+  // For extension fields at file scope.
+  void GenerateRequiresForExtensions(
+      const GeneratorOptions& options, io::Printer* printer,
+      const std::vector<const FieldDescriptor*>& fields,
+      std::set<string>* provided) const;
+  void GenerateRequiresImpl(const GeneratorOptions& options,
+                            io::Printer* printer, std::set<string>* required,
+                            std::set<string>* forwards,
+                            std::set<string>* provided, bool require_jspb,
+                            bool require_extension, bool require_map) const;
+  void FindRequiresForMessage(const GeneratorOptions& options,
+                              const Descriptor* desc,
+                              std::set<string>* required,
+                              std::set<string>* forwards,
+                              bool* have_message) const;
+  void FindRequiresForField(const GeneratorOptions& options,
+                            const FieldDescriptor* field,
+                            std::set<string>* required,
+                            std::set<string>* forwards) const;
+  void FindRequiresForExtension(const GeneratorOptions& options,
+                                const FieldDescriptor* field,
+                                std::set<string>* required,
+                                std::set<string>* forwards) const;
+
+  void GenerateFile(const GeneratorOptions& options,
+                    io::Printer* printer,
+                    const FileDescriptor* file) const;
+
+  // Generate definitions for all message classes and enums in all files,
+  // processing the files in dependence order.
+  void GenerateFilesInDepOrder(
+      const GeneratorOptions& options, io::Printer* printer,
+      const std::vector<const FileDescriptor*>& file) const;
+  // Helper for above.
+  void GenerateFileAndDeps(const GeneratorOptions& options,
+                           io::Printer* printer,
+                           const FileDescriptor* root,
+                           std::set<const FileDescriptor*>* all_files,
+                           std::set<const FileDescriptor*>* generated) const;
+
+  // Generate definitions for all message classes and enums.
+  void GenerateClassesAndEnums(const GeneratorOptions& options,
+                               io::Printer* printer,
+                               const FileDescriptor* file) const;
+
+  void GenerateFieldValueExpression(io::Printer* printer,
+                                    const char* obj_reference,
+                                    const FieldDescriptor* field,
+                                    bool use_default) const;
+
+  // Generate definition for one class.
+  void GenerateClass(const GeneratorOptions& options,
+                     io::Printer* printer,
+                     const Descriptor* desc) const;
+  void GenerateClassConstructor(const GeneratorOptions& options,
+                                io::Printer* printer,
+                                const Descriptor* desc) const;
+  void GenerateClassFieldInfo(const GeneratorOptions& options,
+                              io::Printer* printer,
+                              const Descriptor* desc) const;
+  void GenerateClassXid(const GeneratorOptions& options,
+                        io::Printer* printer,
+                        const Descriptor* desc) const;
+  void GenerateOneofCaseDefinition(const GeneratorOptions& options,
+                                   io::Printer* printer,
+                                   const OneofDescriptor* oneof) const;
+  void GenerateClassToObject(const GeneratorOptions& options,
+                             io::Printer* printer,
+                             const Descriptor* desc) const;
+  void GenerateClassFieldToObject(const GeneratorOptions& options,
+                                  io::Printer* printer,
+                                  const FieldDescriptor* field) const;
+  void GenerateClassFromObject(const GeneratorOptions& options,
+                               io::Printer* printer,
+                               const Descriptor* desc) const;
+  void GenerateClassFieldFromObject(const GeneratorOptions& options,
+                                    io::Printer* printer,
+                                    const FieldDescriptor* field) const;
+  void GenerateClassClone(const GeneratorOptions& options,
+                          io::Printer* printer,
+                          const Descriptor* desc) const;
+  void GenerateClassRegistration(const GeneratorOptions& options,
+                                 io::Printer* printer,
+                                 const Descriptor* desc) const;
+  void GenerateClassFields(const GeneratorOptions& options,
+                           io::Printer* printer,
+                           const Descriptor* desc) const;
+  void GenerateClassField(const GeneratorOptions& options,
+                          io::Printer* printer,
+                          const FieldDescriptor* desc) const;
+  void GenerateClassExtensionFieldInfo(const GeneratorOptions& options,
+                                       io::Printer* printer,
+                                       const Descriptor* desc) const;
+  void GenerateClassDeserialize(const GeneratorOptions& options,
+                                io::Printer* printer,
+                                const Descriptor* desc) const;
+  void GenerateClassDeserializeBinary(const GeneratorOptions& options,
+                                      io::Printer* printer,
+                                      const Descriptor* desc) const;
+  void GenerateClassDeserializeBinaryField(const GeneratorOptions& options,
+                                           io::Printer* printer,
+                                           const FieldDescriptor* field) const;
+  void GenerateClassSerializeBinary(const GeneratorOptions& options,
+                                    io::Printer* printer,
+                                    const Descriptor* desc) const;
+  void GenerateClassSerializeBinaryField(const GeneratorOptions& options,
+                                         io::Printer* printer,
+                                         const FieldDescriptor* field) const;
+
+  // Generate definition for one enum.
+  void GenerateEnum(const GeneratorOptions& options,
+                    io::Printer* printer,
+                    const EnumDescriptor* enumdesc) const;
+
+  // Generate an extension definition.
+  void GenerateExtension(const GeneratorOptions& options,
+                         io::Printer* printer,
+                         const FieldDescriptor* field) const;
+
+  // Generate addFoo() method for repeated primitive fields.
+  void GenerateRepeatedPrimitiveHelperMethods(const GeneratorOptions& options,
+                                              io::Printer* printer,
+                                              const FieldDescriptor* field,
+                                              bool untyped) const;
+
+  // Generate addFoo() method for repeated message fields.
+  void GenerateRepeatedMessageHelperMethods(const GeneratorOptions& options,
+                                            io::Printer* printer,
+                                            const FieldDescriptor* field) const;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Generator);
+};
+
+}  // namespace js
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_JS_GENERATOR_H__

kortex_api/include/google/protobuf/compiler/js/well_known_types_embed.h

@@ -0,0 +1,43 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JS_WELL_KNOWN_TYPES_EMBED_H__
+#define GOOGLE_PROTOBUF_COMPILER_JS_WELL_KNOWN_TYPES_EMBED_H__
+
+#include <stddef.h>
+
+struct FileToc {
+  const char* name;
+  const char* data;
+};
+
+extern struct FileToc well_known_types_js[];
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_JS_WELL_KNOWN_TYPES_EMBED_H__

kortex_api/include/google/protobuf/compiler/objectivec/objectivec_generator.h

@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates ObjectiveC code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace objectivec {
+
+// CodeGenerator implementation which generates a ObjectiveC source file and
+// header.  If you create your own protocol compiler binary and you want it to
+// support ObjectiveC output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT ObjectiveCGenerator : public CodeGenerator {
+ public:
+  ObjectiveCGenerator();
+  ~ObjectiveCGenerator();
+
+  // implements CodeGenerator ----------------------------------------
+  bool HasGenerateAll() const;
+  bool Generate(const FileDescriptor* file,
+                const string& parameter,
+                GeneratorContext* context,
+                string* error) const;
+  bool GenerateAll(const vector<const FileDescriptor*>& files,
+                   const string& parameter,
+                   GeneratorContext* context,
+                   string* error) const;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ObjectiveCGenerator);
+};
+
+}  // namespace objectivec
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__