ntcore: Initial commit.

Change-Id: Id8df275a34aaa628581b18e39014b880c29bf9b2

src/nt_messagewriter.cpp

@@ -0,0 +1,247 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2015. All Rights Reserved.                             */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+#include "nt_messagewriter.h"
+
+#include <cassert>
+#include <cstdlib>
+
+#include "nt_internal.h"
+#include "nt_leb128.h"
+
+using namespace NtImpl;
+
+MessageWriter::MessageWriter(unsigned int proto_rev)
+{
+    m_start = m_cur = (char *)std::malloc(1024);
+    m_end = m_start + 1024;
+    m_proto_rev = proto_rev;
+    m_error = 0;
+}
+
+MessageWriter::~MessageWriter()
+{
+    std::free(m_start);
+}
+
+void
+MessageWriter::EnsureSlow(std::size_t len)
+{
+    assert(m_end > m_cur);
+    if (static_cast<std::size_t>(m_end - m_cur) >= len)
+        return;
+    std::size_t pos = m_cur - m_start;
+    std::size_t newlen = (m_end - m_start) * 2;
+    while (newlen < (pos + len))
+        newlen *= 2;
+    m_start = (char *)std::realloc(m_start, newlen);
+    m_cur = m_start + pos;
+    m_end = m_start + newlen;
+}
+
+void
+MessageWriter::WriteKeepAlive()
+{
+    Ensure(1);
+    Write8(NT_MSG_KEEP_ALIVE);
+}
+
+void
+MessageWriter::WriteClientHello(const NT_String &self_id)
+{
+    Ensure(3);
+    Write8(NT_MSG_CLIENT_HELLO);
+    Write16(m_proto_rev);
+    if (m_proto_rev < 0x0300u)
+        return;
+    WriteString(self_id);
+}
+
+void
+MessageWriter::WriteProtoUnsup()
+{
+    Ensure(3);
+    Write8(NT_MSG_PROTO_UNSUP);
+    Write16(m_proto_rev);
+}
+
+void
+MessageWriter::WriteServerHelloDone()
+{
+    Ensure(1);
+    Write8(NT_MSG_SERVER_HELLO_DONE);
+}
+
+void
+MessageWriter::WriteServerHello(unsigned int flags, const NT_String &self_id)
+{
+    if (m_proto_rev < 0x0300u)
+        return; // new message in version 3.0
+    Ensure(2);
+    Write8(NT_MSG_SERVER_HELLO);
+    Write8(flags);
+    WriteString(self_id);
+}
+
+void
+MessageWriter::WriteClientHelloDone()
+{
+    if (m_proto_rev < 0x0300u)
+        return; // new message in version 3.0
+    Ensure(1);
+    Write8(NT_MSG_CLIENT_HELLO_DONE);
+}
+
+void
+MessageWriter::WriteEntryAssign(const NT_String &name,
+                                unsigned int id,
+                                unsigned int seq_num,
+                                const NT_Value &value,
+                                unsigned int flags)
+{
+    Ensure(1);
+    Write8(NT_MSG_ENTRY_ASSIGN);
+    WriteString(name);
+    Ensure(6);
+    WriteType(value.type);
+    Write16(id);
+    Write16(seq_num);
+    if (m_proto_rev >= 0x0300u)
+        Write8(flags);
+    WriteValue(value);
+}
+
+void
+MessageWriter::WriteEntryUpdate(unsigned int id,
+                                unsigned int seq_num,
+                                const NT_Value &value)
+{
+    Ensure(6);
+    Write8(NT_MSG_ENTRY_UPDATE);
+    Write16(id);
+    Write16(seq_num);
+    if (m_proto_rev >= 0x0300u)
+        Write8(value.type);
+    WriteValue(value);
+}
+
+void
+MessageWriter::WriteFlagsUpdate(unsigned int id, unsigned int flags)
+{
+    if (m_proto_rev < 0x0300u)
+        return; // new message in version 3.0
+    Ensure(4);
+    Write8(NT_MSG_FLAGS_UPDATE);
+    Write16(id);
+    Write8(flags);
+}
+
+void
+MessageWriter::WriteEntryDelete(unsigned int id)
+{
+    if (m_proto_rev < 0x0300u)
+        return; // new message in version 3.0
+    Ensure(3);
+    Write8(NT_MSG_ENTRY_DELETE);
+    Write16(id);
+}
+
+void
+MessageWriter::WriteClearEntries()
+{
+    if (m_proto_rev < 0x0300u)
+        return; // new message in version 3.0
+
+    Ensure(5);
+    Write8(NT_MSG_CLEAR_ENTRIES);
+    Write32(NT_CLEAR_ALL_MAGIC);
+}
+
+void
+MessageWriter::WriteExecuteRpc(unsigned int id,
+                               unsigned int uid,
+                               const NT_Value *params_start,
+                               const NT_Value *params_end)
+{
+    WriteRpc(NT_MSG_EXECUTE_RPC, id, uid, params_start, params_end);
+}
+
+void
+MessageWriter::WriteRpcResponse(unsigned int id,
+                                unsigned int uid,
+                                const NT_Value *results_start,
+                                const NT_Value *results_end)
+{
+    WriteRpc(NT_MSG_RPC_RESPONSE, id, uid, results_start, results_end);
+}
+
+void
+MessageWriter::WriteRpc(unsigned int msg_type,
+                        unsigned int id,
+                        unsigned int uid,
+                        const NT_Value *values_start,
+                        const NT_Value *values_end)
+{
+    if (m_proto_rev < 0x0300u)
+        return; // new message in version 3.0
+
+    Ensure(5);
+    Write8(msg_type);
+    Write16(id);
+    Write16(uid);
+
+    unsigned long len = 0;
+    for (const NT_Value *value = values_start; value != values_end; ++value)
+        len += NT_GetValueSize(value, m_proto_rev);
+    WriteULEB128(len);
+
+    for (const NT_Value *value = values_start; value != values_end; ++value)
+        WriteValue(*value);
+}
+
+void
+MessageWriter::WriteULEB128(unsigned long val)
+{
+    Ensure(size_uleb128(val));
+    m_cur += write_uleb128(m_cur, val);
+}
+
+void
+MessageWriter::WriteType(NT_Type type)
+{
+    Ensure(1);
+    size_t len = NT_WriteType(m_cur, type, m_proto_rev);
+    if (len == 0)
+        m_error = "unrecognized type";
+    m_cur += len;
+}
+
+void
+MessageWriter::WriteValue(const NT_Value &value)
+{
+    std::size_t len = NT_GetValueSize(&value, m_proto_rev);
+    if (len == 0)
+    {
+        m_error = "unrecognized type when writing value";
+        return;
+    }
+    Ensure(len);
+    m_cur += NT_WriteValue(m_cur, &value, m_proto_rev);
+}
+
+void
+MessageWriter::WriteString(const NT_String &str)
+{
+    std::size_t len = NT_GetStringSize(&str, m_proto_rev);
+    if (len == 0)
+    {
+        m_error = "invalid string";
+        return;
+    }
+    Ensure(len);
+    m_cur += NT_WriteString(m_cur, &str, m_proto_rev);
+}