Runs clang-format on ntcore (#150)

Also updates .clang-format to match allwpilib

WPIUtil was skipped

src/ntcore_c.cpp

@@ -72,14 +72,12 @@ static void ConvertToC(const RpcCallInfo& in, NT_RpcCallInfo* out) {
   ConvertToC(in.params, &out->params);
 }
 
-static void DisposeConnectionInfo(NT_ConnectionInfo *info) {
+static void DisposeConnectionInfo(NT_ConnectionInfo* info) {
   std::free(info->remote_id.str);
   std::free(info->remote_ip.str);
 }
 
-static void DisposeEntryInfo(NT_EntryInfo *info) {
-  std::free(info->name.str);
-}
+static void DisposeEntryInfo(NT_EntryInfo* info) { std::free(info->name.str); }
 
 static RpcParamDef ConvertFromC(const NT_RpcParamDef& in) {
   RpcParamDef out;
@@ -117,8 +115,8 @@ extern "C" {
  * Table Functions
  */
 
-void NT_GetEntryValue(const char *name, size_t name_len,
-                      struct NT_Value *value) {
+void NT_GetEntryValue(const char* name, size_t name_len,
+                      struct NT_Value* value) {
   NT_InitValue(value);
   auto v = nt::GetEntryValue(StringRef(name, name_len));
   if (!v) return;
@@ -126,37 +124,37 @@ void NT_GetEntryValue(const char *name, size_t name_len,
 }
 
 int NT_SetDefaultEntryValue(const char* name, size_t name_len,
-                            const struct NT_Value *set_value) {
-    return nt::SetDefaultEntryValue(StringRef(name, name_len),
-                                    ConvertFromC(*set_value));
+                            const struct NT_Value* set_value) {
+  return nt::SetDefaultEntryValue(StringRef(name, name_len),
+                                  ConvertFromC(*set_value));
 }
 
-int NT_SetEntryValue(const char *name, size_t name_len,
-                     const struct NT_Value *value) {
+int NT_SetEntryValue(const char* name, size_t name_len,
+                     const struct NT_Value* value) {
   return nt::SetEntryValue(StringRef(name, name_len), ConvertFromC(*value));
 }
 
-void NT_SetEntryTypeValue(const char *name, size_t name_len,
-                          const struct NT_Value *value) {
+void NT_SetEntryTypeValue(const char* name, size_t name_len,
+                          const struct NT_Value* value) {
   nt::SetEntryTypeValue(StringRef(name, name_len), ConvertFromC(*value));
 }
 
-void NT_SetEntryFlags(const char *name, size_t name_len, unsigned int flags) {
+void NT_SetEntryFlags(const char* name, size_t name_len, unsigned int flags) {
   nt::SetEntryFlags(StringRef(name, name_len), flags);
 }
 
-unsigned int NT_GetEntryFlags(const char *name, size_t name_len) {
+unsigned int NT_GetEntryFlags(const char* name, size_t name_len) {
   return nt::GetEntryFlags(StringRef(name, name_len));
 }
 
-void NT_DeleteEntry(const char *name, size_t name_len) {
+void NT_DeleteEntry(const char* name, size_t name_len) {
   nt::DeleteEntry(StringRef(name, name_len));
 }
 
 void NT_DeleteAllEntries(void) { nt::DeleteAllEntries(); }
 
-struct NT_EntryInfo *NT_GetEntryInfo(const char *prefix, size_t prefix_len,
-                                     unsigned int types, size_t *count) {
+struct NT_EntryInfo* NT_GetEntryInfo(const char* prefix, size_t prefix_len,
+                                     unsigned int types, size_t* count) {
   auto info_v = nt::GetEntryInfo(StringRef(prefix, prefix_len), types);
   *count = info_v.size();
   if (info_v.size() == 0) return nullptr;
@@ -174,17 +172,16 @@ void NT_Flush(void) { nt::Flush(); }
  * Callback Creation Functions
  */
 
-void NT_SetListenerOnStart(void (*on_start)(void *data), void *data) {
+void NT_SetListenerOnStart(void (*on_start)(void* data), void* data) {
   nt::SetListenerOnStart([=]() { on_start(data); });
 }
 
-void NT_SetListenerOnExit(void (*on_exit)(void *data), void *data) {
+void NT_SetListenerOnExit(void (*on_exit)(void* data), void* data) {
   nt::SetListenerOnExit([=]() { on_exit(data); });
 }
 
-unsigned int NT_AddEntryListener(const char *prefix, size_t prefix_len,
-                                 void *data,
-                                 NT_EntryListenerCallback callback,
+unsigned int NT_AddEntryListener(const char* prefix, size_t prefix_len,
+                                 void* data, NT_EntryListenerCallback callback,
                                  unsigned int flags) {
   return nt::AddEntryListener(
       StringRef(prefix, prefix_len),
@@ -199,11 +196,11 @@ void NT_RemoveEntryListener(unsigned int entry_listener_uid) {
   nt::RemoveEntryListener(entry_listener_uid);
 }
 
-unsigned int NT_AddConnectionListener(void *data,
+unsigned int NT_AddConnectionListener(void* data,
                                       NT_ConnectionListenerCallback callback,
                                       int immediate_notify) {
   return nt::AddConnectionListener(
-      [=](unsigned int uid, bool connected, const ConnectionInfo &conn) {
+      [=](unsigned int uid, bool connected, const ConnectionInfo& conn) {
         NT_ConnectionInfo conn_c;
         ConvertToC(conn, &conn_c);
         callback(uid, data, connected ? 1 : 0, &conn_c);
@@ -222,85 +219,82 @@ int NT_NotifierDestroyed() { return nt::NotifierDestroyed(); }
  * Remote Procedure Call Functions
  */
 
-void NT_SetRpcServerOnStart(void (*on_start)(void *data), void *data) {
+void NT_SetRpcServerOnStart(void (*on_start)(void* data), void* data) {
   nt::SetRpcServerOnStart([=]() { on_start(data); });
 }
 
-void NT_SetRpcServerOnExit(void (*on_exit)(void *data), void *data) {
+void NT_SetRpcServerOnExit(void (*on_exit)(void* data), void* data) {
   nt::SetRpcServerOnExit([=]() { on_exit(data); });
 }
 
-void NT_CreateRpc(const char *name, size_t name_len, const char *def,
-                  size_t def_len, void *data, NT_RpcCallback callback) {
-  nt::CreateRpc(
-      StringRef(name, name_len), StringRef(def, def_len),
-      [=](StringRef name, StringRef params, 
-          const ConnectionInfo& conn_info) -> std::string {
-        size_t results_len;
-        NT_ConnectionInfo conn_c;
-        ConvertToC(conn_info, &conn_c);
-        char* results_c = callback(data, name.data(), name.size(),
-                                   params.data(), params.size(), &results_len,
-                                   &conn_c);
-        std::string results(results_c, results_len);
-        std::free(results_c);
-        DisposeConnectionInfo(&conn_c);
-        return results;
-      });
+void NT_CreateRpc(const char* name, size_t name_len, const char* def,
+                  size_t def_len, void* data, NT_RpcCallback callback) {
+  nt::CreateRpc(StringRef(name, name_len), StringRef(def, def_len),
+                [=](StringRef name, StringRef params,
+                    const ConnectionInfo& conn_info) -> std::string {
+                  size_t results_len;
+                  NT_ConnectionInfo conn_c;
+                  ConvertToC(conn_info, &conn_c);
+                  char* results_c =
+                      callback(data, name.data(), name.size(), params.data(),
+                               params.size(), &results_len, &conn_c);
+                  std::string results(results_c, results_len);
+                  std::free(results_c);
+                  DisposeConnectionInfo(&conn_c);
+                  return results;
+                });
 }
 
-void NT_CreatePolledRpc(const char *name, size_t name_len, const char *def,
+void NT_CreatePolledRpc(const char* name, size_t name_len, const char* def,
                         size_t def_len) {
   nt::CreatePolledRpc(StringRef(name, name_len), StringRef(def, def_len));
 }
 
 int NT_PollRpc(int blocking, NT_RpcCallInfo* call_info) {
   RpcCallInfo call_info_cpp;
-  if (!nt::PollRpc(blocking != 0, &call_info_cpp))
-    return 0;
+  if (!nt::PollRpc(blocking != 0, &call_info_cpp)) return 0;
   ConvertToC(call_info_cpp, call_info);
   return 1;
 }
 
-int NT_PollRpcTimeout(int blocking, double time_out, 
+int NT_PollRpcTimeout(int blocking, double time_out,
                       NT_RpcCallInfo* call_info) {
   RpcCallInfo call_info_cpp;
-  if (!nt::PollRpc(blocking != 0, time_out, &call_info_cpp))
-    return 0;
+  if (!nt::PollRpc(blocking != 0, time_out, &call_info_cpp)) return 0;
   ConvertToC(call_info_cpp, call_info);
   return 1;
 }
 
 void NT_PostRpcResponse(unsigned int rpc_id, unsigned int call_uid,
-                        const char *result, size_t result_len) {
+                        const char* result, size_t result_len) {
   nt::PostRpcResponse(rpc_id, call_uid, StringRef(result, result_len));
 }
 
-unsigned int NT_CallRpc(const char *name, size_t name_len,
-                        const char *params, size_t params_len) {
+unsigned int NT_CallRpc(const char* name, size_t name_len, const char* params,
+                        size_t params_len) {
   return nt::CallRpc(StringRef(name, name_len), StringRef(params, params_len));
 }
 
-char *NT_GetRpcResult(int blocking, unsigned int call_uid, size_t *result_len) {
+char* NT_GetRpcResult(int blocking, unsigned int call_uid, size_t* result_len) {
   std::string result;
   if (!nt::GetRpcResult(blocking != 0, call_uid, &result)) return nullptr;
 
   // convert result
   *result_len = result.size();
-  char *result_cstr;
+  char* result_cstr;
   ConvertToC(result, &result_cstr);
   return result_cstr;
 }
 
-char *NT_GetRpcResultTimeout(int blocking, unsigned int call_uid, 
-                             double time_out, size_t *result_len) {
+char* NT_GetRpcResultTimeout(int blocking, unsigned int call_uid,
+                             double time_out, size_t* result_len) {
   std::string result;
-  if (!nt::GetRpcResult(blocking != 0, call_uid, time_out, &result)) 
+  if (!nt::GetRpcResult(blocking != 0, call_uid, time_out, &result))
     return nullptr;
 
   // convert result
   *result_len = result.size();
-  char *result_cstr;
+  char* result_cstr;
   ConvertToC(result, &result_cstr);
   return result_cstr;
 }
@@ -309,29 +303,28 @@ void NT_CancelBlockingRpcResult(unsigned int call_uid) {
   nt::CancelBlockingRpcResult(call_uid);
 }
 
-char *NT_PackRpcDefinition(const NT_RpcDefinition *def, size_t *packed_len) {
+char* NT_PackRpcDefinition(const NT_RpcDefinition* def, size_t* packed_len) {
   auto packed = nt::PackRpcDefinition(ConvertFromC(*def));
 
   // convert result
   *packed_len = packed.size();
-  char *packed_cstr;
+  char* packed_cstr;
   ConvertToC(packed, &packed_cstr);
   return packed_cstr;
 }
 
-int NT_UnpackRpcDefinition(const char *packed, size_t packed_len,
-                           NT_RpcDefinition *def) {
+int NT_UnpackRpcDefinition(const char* packed, size_t packed_len,
+                           NT_RpcDefinition* def) {
   nt::RpcDefinition def_v;
-  if (!nt::UnpackRpcDefinition(StringRef(packed, packed_len), &def_v))
-      return 0;
+  if (!nt::UnpackRpcDefinition(StringRef(packed, packed_len), &def_v)) return 0;
 
   // convert result
   ConvertToC(def_v, def);
   return 1;
 }
 
-char *NT_PackRpcValues(const NT_Value **values, size_t values_len,
-                       size_t *packed_len) {
+char* NT_PackRpcValues(const NT_Value** values, size_t values_len,
+                       size_t* packed_len) {
   // create input vector
   std::vector<std::shared_ptr<Value>> values_v;
   values_v.reserve(values_len);
@@ -343,20 +336,20 @@ char *NT_PackRpcValues(const NT_Value **values, size_t values_len,
 
   // convert result
   *packed_len = packed.size();
-  char *packed_cstr;
+  char* packed_cstr;
   ConvertToC(packed, &packed_cstr);
   return packed_cstr;
 }
 
-NT_Value **NT_UnpackRpcValues(const char *packed, size_t packed_len,
-                              const NT_Type *types, size_t types_len) {
+NT_Value** NT_UnpackRpcValues(const char* packed, size_t packed_len,
+                              const NT_Type* types, size_t types_len) {
   auto values_v = nt::UnpackRpcValues(StringRef(packed, packed_len),
                                       ArrayRef<NT_Type>(types, types_len));
   if (values_v.size() == 0) return nullptr;
 
   // create array and copy into it
-  NT_Value** values = static_cast<NT_Value**>(
-      std::malloc(values_v.size() * sizeof(NT_Value*)));
+  NT_Value** values =
+      static_cast<NT_Value**>(std::malloc(values_v.size() * sizeof(NT_Value*)));
   for (size_t i = 0; i < values_v.size(); ++i) {
     values[i] = static_cast<NT_Value*>(std::malloc(sizeof(NT_Value)));
     ConvertToC(*values_v[i], values[i]);
@@ -368,53 +361,45 @@ NT_Value **NT_UnpackRpcValues(const char *packed, size_t packed_len,
  * Client/Server Functions
  */
 
-void NT_SetNetworkIdentity(const char *name, size_t name_len) {
+void NT_SetNetworkIdentity(const char* name, size_t name_len) {
   nt::SetNetworkIdentity(StringRef(name, name_len));
 }
 
-void NT_StartServer(const char *persist_filename, const char *listen_address,
+void NT_StartServer(const char* persist_filename, const char* listen_address,
                     unsigned int port) {
   nt::StartServer(persist_filename, listen_address, port);
 }
 
 void NT_StopServer(void) { nt::StopServer(); }
 
-void NT_StartClient(const char *server_name, unsigned int port) {
+void NT_StartClient(const char* server_name, unsigned int port) {
   nt::StartClient(server_name, port);
 }
 
-void NT_StartClientMulti(size_t count, const char **server_names,
-                         const unsigned int *ports) {
+void NT_StartClientMulti(size_t count, const char** server_names,
+                         const unsigned int* ports) {
   std::vector<std::pair<StringRef, unsigned int>> servers;
   servers.reserve(count);
-  for (size_t i=0; i<count; ++i)
+  for (size_t i = 0; i < count; ++i)
     servers.emplace_back(std::make_pair(server_names[i], ports[i]));
   nt::StartClient(servers);
 }
 
-void NT_StopClient(void) {
-  nt::StopClient();
-}
+void NT_StopClient(void) { nt::StopClient(); }
 
-void NT_StopRpcServer(void) {
-  nt::StopRpcServer();
-}
+void NT_StopRpcServer(void) { nt::StopRpcServer(); }
 
-void NT_StopNotifier(void) {
-  nt::StopNotifier();
-}
+void NT_StopNotifier(void) { nt::StopNotifier(); }
 
-void NT_SetUpdateRate(double interval) {
-  nt::SetUpdateRate(interval);
-}
+void NT_SetUpdateRate(double interval) { nt::SetUpdateRate(interval); }
 
-struct NT_ConnectionInfo *NT_GetConnections(size_t *count) {
+struct NT_ConnectionInfo* NT_GetConnections(size_t* count) {
   auto conn_v = nt::GetConnections();
   *count = conn_v.size();
   if (conn_v.size() == 0) return nullptr;
 
   // create array and copy into it
-  NT_ConnectionInfo *conn = static_cast<NT_ConnectionInfo *>(
+  NT_ConnectionInfo* conn = static_cast<NT_ConnectionInfo*>(
       std::malloc(conn_v.size() * sizeof(NT_ConnectionInfo)));
   for (size_t i = 0; i < conn_v.size(); ++i) ConvertToC(conn_v[i], &conn[i]);
   return conn;
@@ -424,12 +409,12 @@ struct NT_ConnectionInfo *NT_GetConnections(size_t *count) {
  * Persistent Functions
  */
 
-const char *NT_SavePersistent(const char *filename) {
+const char* NT_SavePersistent(const char* filename) {
   return nt::SavePersistent(filename);
 }
 
-const char *NT_LoadPersistent(const char *filename,
-                              void (*warn)(size_t line, const char *msg)) {
+const char* NT_LoadPersistent(const char* filename,
+                              void (*warn)(size_t line, const char* msg)) {
   return nt::LoadPersistent(filename, warn);
 }
 
@@ -437,15 +422,13 @@ const char *NT_LoadPersistent(const char *filename,
  * Utility Functions
  */
 
-unsigned long long NT_Now() {
-  return wpi::Now();
-}
+unsigned long long NT_Now() { return wpi::Now(); }
 
 void NT_SetLogger(NT_LogFunc func, unsigned int min_level) {
   nt::SetLogger(func, min_level);
 }
 
-void NT_DisposeValue(NT_Value *value) {
+void NT_DisposeValue(NT_Value* value) {
   switch (value->type) {
     case NT_UNASSIGNED:
     case NT_BOOLEAN:
@@ -475,39 +458,39 @@ void NT_DisposeValue(NT_Value *value) {
   value->last_change = 0;
 }
 
-void NT_InitValue(NT_Value *value) {
+void NT_InitValue(NT_Value* value) {
   value->type = NT_UNASSIGNED;
   value->last_change = 0;
 }
 
-void NT_DisposeString(NT_String *str) {
+void NT_DisposeString(NT_String* str) {
   std::free(str->str);
   str->str = nullptr;
   str->len = 0;
 }
 
-void NT_InitString(NT_String *str) {
+void NT_InitString(NT_String* str) {
   str->str = nullptr;
   str->len = 0;
 }
 
-enum NT_Type NT_GetType(const char *name, size_t name_len) {
+enum NT_Type NT_GetType(const char* name, size_t name_len) {
   auto v = nt::GetEntryValue(StringRef(name, name_len));
   if (!v) return NT_Type::NT_UNASSIGNED;
   return v->type();
 }
 
-void NT_DisposeConnectionInfoArray(NT_ConnectionInfo *arr, size_t count) {
+void NT_DisposeConnectionInfoArray(NT_ConnectionInfo* arr, size_t count) {
   for (size_t i = 0; i < count; i++) DisposeConnectionInfo(&arr[i]);
   std::free(arr);
 }
 
-void NT_DisposeEntryInfoArray(NT_EntryInfo *arr, size_t count){
+void NT_DisposeEntryInfoArray(NT_EntryInfo* arr, size_t count) {
   for (size_t i = 0; i < count; i++) DisposeEntryInfo(&arr[i]);
   std::free(arr);
 }
 
-void NT_DisposeRpcDefinition(NT_RpcDefinition *def) {
+void NT_DisposeRpcDefinition(NT_RpcDefinition* def) {
   NT_DisposeString(&def->name);
 
   for (size_t i = 0; i < def->num_params; ++i) {
@@ -525,7 +508,7 @@ void NT_DisposeRpcDefinition(NT_RpcDefinition *def) {
   def->num_results = 0;
 }
 
-void NT_DisposeRpcCallInfo(NT_RpcCallInfo *call_info) {
+void NT_DisposeRpcCallInfo(NT_RpcCallInfo* call_info) {
   NT_DisposeString(&call_info->name);
   NT_DisposeString(&call_info->params);
 }
@@ -535,39 +518,39 @@ void NT_DisposeRpcCallInfo(NT_RpcCallInfo *call_info) {
 /* Array and Struct Allocations */
 
 /* Allocates a char array of the specified size.*/
-char *NT_AllocateCharArray(size_t size) {
-  char *retVal = static_cast<char *>(std::malloc(size * sizeof(char)));
+char* NT_AllocateCharArray(size_t size) {
+  char* retVal = static_cast<char*>(std::malloc(size * sizeof(char)));
   return retVal;
 }
 
 /* Allocates an integer or boolean array of the specified size. */
-int *NT_AllocateBooleanArray(size_t size) {
-  int *retVal = static_cast<int *>(std::malloc(size * sizeof(int)));
+int* NT_AllocateBooleanArray(size_t size) {
+  int* retVal = static_cast<int*>(std::malloc(size * sizeof(int)));
   return retVal;
 }
 
 /* Allocates a double array of the specified size. */
-double *NT_AllocateDoubleArray(size_t size) {
-  double *retVal = static_cast<double *>(std::malloc(size * sizeof(double)));
+double* NT_AllocateDoubleArray(size_t size) {
+  double* retVal = static_cast<double*>(std::malloc(size * sizeof(double)));
   return retVal;
 }
 
 /* Allocates an NT_String array of the specified size. */
-struct NT_String *NT_AllocateStringArray(size_t size) {
-  NT_String *retVal =
-      static_cast<NT_String *>(std::malloc(size * sizeof(NT_String)));
+struct NT_String* NT_AllocateStringArray(size_t size) {
+  NT_String* retVal =
+      static_cast<NT_String*>(std::malloc(size * sizeof(NT_String)));
   return retVal;
 }
 
-void NT_FreeCharArray(char *v_char) { std::free(v_char); }
-void NT_FreeDoubleArray(double *v_double) { std::free(v_double); }
-void NT_FreeBooleanArray(int *v_boolean) { std::free(v_boolean); }
-void NT_FreeStringArray(struct NT_String *v_string, size_t arr_size) {
+void NT_FreeCharArray(char* v_char) { std::free(v_char); }
+void NT_FreeDoubleArray(double* v_double) { std::free(v_double); }
+void NT_FreeBooleanArray(int* v_boolean) { std::free(v_boolean); }
+void NT_FreeStringArray(struct NT_String* v_string, size_t arr_size) {
   for (size_t i = 0; i < arr_size; i++) std::free(v_string[i].str);
   std::free(v_string);
 }
 
-int NT_SetEntryDouble(const char *name, size_t name_len, double v_double,
+int NT_SetEntryDouble(const char* name, size_t name_len, double v_double,
                       int force) {
   if (force != 0) {
     nt::SetEntryTypeValue(StringRef(name, name_len),
@@ -579,7 +562,7 @@ int NT_SetEntryDouble(const char *name, size_t name_len, double v_double,
   }
 }
 
-int NT_SetEntryBoolean(const char *name, size_t name_len, int v_boolean,
+int NT_SetEntryBoolean(const char* name, size_t name_len, int v_boolean,
                        int force) {
   if (force != 0) {
     nt::SetEntryTypeValue(StringRef(name, name_len),
@@ -591,7 +574,7 @@ int NT_SetEntryBoolean(const char *name, size_t name_len, int v_boolean,
   }
 }
 
-int NT_SetEntryString(const char *name, size_t name_len, const char *str,
+int NT_SetEntryString(const char* name, size_t name_len, const char* str,
                       size_t str_len, int force) {
   if (force != 0) {
     nt::SetEntryTypeValue(StringRef(name, name_len),
@@ -603,7 +586,7 @@ int NT_SetEntryString(const char *name, size_t name_len, const char *str,
   }
 }
 
-int NT_SetEntryRaw(const char *name, size_t name_len, const char *raw,
+int NT_SetEntryRaw(const char* name, size_t name_len, const char* raw,
                    size_t raw_len, int force) {
   if (force != 0) {
     nt::SetEntryTypeValue(StringRef(name, name_len),
@@ -615,7 +598,7 @@ int NT_SetEntryRaw(const char *name, size_t name_len, const char *raw,
   }
 }
 
-int NT_SetEntryBooleanArray(const char *name, size_t name_len, const int *arr,
+int NT_SetEntryBooleanArray(const char* name, size_t name_len, const int* arr,
                             size_t size, int force) {
   if (force != 0) {
     nt::SetEntryTypeValue(
@@ -629,7 +612,7 @@ int NT_SetEntryBooleanArray(const char *name, size_t name_len, const int *arr,
   }
 }
 
-int NT_SetEntryDoubleArray(const char *name, size_t name_len, const double *arr,
+int NT_SetEntryDoubleArray(const char* name, size_t name_len, const double* arr,
                            size_t size, int force) {
   if (force != 0) {
     nt::SetEntryTypeValue(
@@ -643,8 +626,8 @@ int NT_SetEntryDoubleArray(const char *name, size_t name_len, const double *arr,
   }
 }
 
-int NT_SetEntryStringArray(const char *name, size_t name_len,
-                           const struct NT_String *arr, size_t size,
+int NT_SetEntryStringArray(const char* name, size_t name_len,
+                           const struct NT_String* arr, size_t size,
                            int force) {
   std::vector<std::string> v;
   v.reserve(size);
@@ -660,79 +643,79 @@ int NT_SetEntryStringArray(const char *name, size_t name_len,
   }
 }
 
-enum NT_Type NT_GetValueType(const struct NT_Value *value) {
+enum NT_Type NT_GetValueType(const struct NT_Value* value) {
   if (!value) return NT_Type::NT_UNASSIGNED;
   return value->type;
 }
 
-int NT_GetValueBoolean(const struct NT_Value *value,
-                       unsigned long long *last_change, int *v_boolean) {
+int NT_GetValueBoolean(const struct NT_Value* value,
+                       unsigned long long* last_change, int* v_boolean) {
   if (!value || value->type != NT_Type::NT_BOOLEAN) return 0;
   *v_boolean = value->data.v_boolean;
   *last_change = value->last_change;
   return 1;
 }
 
-int NT_GetValueDouble(const struct NT_Value *value,
-                      unsigned long long *last_change, double *v_double) {
+int NT_GetValueDouble(const struct NT_Value* value,
+                      unsigned long long* last_change, double* v_double) {
   if (!value || value->type != NT_Type::NT_DOUBLE) return 0;
   *last_change = value->last_change;
   *v_double = value->data.v_double;
   return 1;
 }
 
-char *NT_GetValueString(const struct NT_Value *value,
-                        unsigned long long *last_change, size_t *str_len) {
+char* NT_GetValueString(const struct NT_Value* value,
+                        unsigned long long* last_change, size_t* str_len) {
   if (!value || value->type != NT_Type::NT_STRING) return nullptr;
   *last_change = value->last_change;
   *str_len = value->data.v_string.len;
-  char *str = (char*)std::malloc(value->data.v_string.len + 1);
+  char* str = (char*)std::malloc(value->data.v_string.len + 1);
   std::memcpy(str, value->data.v_string.str, value->data.v_string.len + 1);
   return str;
 }
 
-char *NT_GetValueRaw(const struct NT_Value *value,
-                     unsigned long long *last_change, size_t *raw_len) {
+char* NT_GetValueRaw(const struct NT_Value* value,
+                     unsigned long long* last_change, size_t* raw_len) {
   if (!value || value->type != NT_Type::NT_RAW) return nullptr;
   *last_change = value->last_change;
   *raw_len = value->data.v_string.len;
-  char *raw = (char*)std::malloc(value->data.v_string.len + 1);
+  char* raw = (char*)std::malloc(value->data.v_string.len + 1);
   std::memcpy(raw, value->data.v_string.str, value->data.v_string.len + 1);
   return raw;
 }
 
-int *NT_GetValueBooleanArray(const struct NT_Value *value,
-                             unsigned long long *last_change,
-                             size_t *arr_size) {
+int* NT_GetValueBooleanArray(const struct NT_Value* value,
+                             unsigned long long* last_change,
+                             size_t* arr_size) {
   if (!value || value->type != NT_Type::NT_BOOLEAN_ARRAY) return nullptr;
   *last_change = value->last_change;
   *arr_size = value->data.arr_boolean.size;
-  int *arr = (int*)std::malloc(value->data.arr_boolean.size * sizeof(int));
+  int* arr = (int*)std::malloc(value->data.arr_boolean.size * sizeof(int));
   std::memcpy(arr, value->data.arr_boolean.arr,
               value->data.arr_boolean.size * sizeof(int));
   return arr;
 }
 
-double *NT_GetValueDoubleArray(const struct NT_Value *value,
-                               unsigned long long *last_change,
-                               size_t *arr_size) {
+double* NT_GetValueDoubleArray(const struct NT_Value* value,
+                               unsigned long long* last_change,
+                               size_t* arr_size) {
   if (!value || value->type != NT_Type::NT_DOUBLE_ARRAY) return nullptr;
   *last_change = value->last_change;
   *arr_size = value->data.arr_double.size;
-  double *arr =
-      (double *)std::malloc(value->data.arr_double.size * sizeof(double));
+  double* arr =
+      (double*)std::malloc(value->data.arr_double.size * sizeof(double));
   std::memcpy(arr, value->data.arr_double.arr,
               value->data.arr_double.size * sizeof(double));
   return arr;
 }
 
-NT_String *NT_GetValueStringArray(const struct NT_Value *value,
-                                  unsigned long long *last_change,
-                                  size_t *arr_size) {
+NT_String* NT_GetValueStringArray(const struct NT_Value* value,
+                                  unsigned long long* last_change,
+                                  size_t* arr_size) {
   if (!value || value->type != NT_Type::NT_STRING_ARRAY) return nullptr;
   *last_change = value->last_change;
   *arr_size = value->data.arr_string.size;
-  NT_String *arr = static_cast<NT_String *>(
+  NT_String* arr = static_cast<NT_String*>(
       std::malloc(value->data.arr_string.size * sizeof(NT_String)));
   for (size_t i = 0; i < value->data.arr_string.size; ++i) {
     size_t len = value->data.arr_string.arr[i].len;
@@ -743,59 +726,62 @@ NT_String *NT_GetValueStringArray(const struct NT_Value *value,
   return arr;
 }
 
-int NT_SetDefaultEntryBoolean(const char *name, size_t name_len,
+int NT_SetDefaultEntryBoolean(const char* name, size_t name_len,
                               int default_boolean) {
   return nt::SetDefaultEntryValue(StringRef(name, name_len),
                                   Value::MakeBoolean(default_boolean != 0));
 }
 
-int NT_SetDefaultEntryDouble(const char *name, size_t name_len,
+int NT_SetDefaultEntryDouble(const char* name, size_t name_len,
                              double default_double) {
   return nt::SetDefaultEntryValue(StringRef(name, name_len),
                                   Value::MakeDouble(default_double));
 }
 
-int NT_SetDefaultEntryString(const char *name, size_t name_len,
-                             const char *default_value, size_t default_len) {
-  return nt::SetDefaultEntryValue(StringRef(name, name_len),
-                                  Value::MakeString(StringRef(default_value,
-                                                    default_len)));
+int NT_SetDefaultEntryString(const char* name, size_t name_len,
+                             const char* default_value, size_t default_len) {
+  return nt::SetDefaultEntryValue(
+      StringRef(name, name_len),
+      Value::MakeString(StringRef(default_value, default_len)));
 }
 
-int NT_SetDefaultEntryRaw(const char *name, size_t name_len,
-                          const char *default_value, size_t default_len) {
-  return nt::SetDefaultEntryValue(StringRef(name, name_len),
-                                  Value::MakeString(StringRef(default_value,
-                                                    default_len)));
+int NT_SetDefaultEntryRaw(const char* name, size_t name_len,
+                          const char* default_value, size_t default_len) {
+  return nt::SetDefaultEntryValue(
+      StringRef(name, name_len),
+      Value::MakeString(StringRef(default_value, default_len)));
 }
 
-int NT_SetDefaultEntryBooleanArray(const char *name, size_t name_len,
-                                   const int *default_value, 
+int NT_SetDefaultEntryBooleanArray(const char* name, size_t name_len,
+                                   const int* default_value,
                                    size_t default_size) {
-  return nt::SetDefaultEntryValue(StringRef(name, name_len),
-                                  Value::MakeBooleanArray(llvm::makeArrayRef(default_value, default_size)));
+  return nt::SetDefaultEntryValue(
+      StringRef(name, name_len),
+      Value::MakeBooleanArray(llvm::makeArrayRef(default_value, default_size)));
 }
 
-int NT_SetDefaultEntryDoubleArray(const char *name, size_t name_len, const double *default_value,
+int NT_SetDefaultEntryDoubleArray(const char* name, size_t name_len,
+                                  const double* default_value,
                                   size_t default_size) {
-  return nt::SetDefaultEntryValue(StringRef(name, name_len),
-                                  Value::MakeDoubleArray(llvm::makeArrayRef(default_value, default_size)));
+  return nt::SetDefaultEntryValue(
+      StringRef(name, name_len),
+      Value::MakeDoubleArray(llvm::makeArrayRef(default_value, default_size)));
 }
 
-int NT_SetDefaultEntryStringArray(const char *name, size_t name_len,
+int NT_SetDefaultEntryStringArray(const char* name, size_t name_len,
                                   const struct NT_String* default_value,
                                   size_t default_size) {
   std::vector<std::string> vec;
   vec.reserve(default_size);
-  for (size_t i = 0; i < default_size; ++i) 
+  for (size_t i = 0; i < default_size; ++i)
     vec.push_back(ConvertFromC(default_value[i]));
-  
-  return nt::SetDefaultEntryValue(StringRef(name, name_len), 
+
+  return nt::SetDefaultEntryValue(StringRef(name, name_len),
                                   Value::MakeStringArray(std::move(vec)));
 }
 
-int NT_GetEntryBoolean(const char *name, size_t name_len,
-                       unsigned long long *last_change, int *v_boolean) {
+int NT_GetEntryBoolean(const char* name, size_t name_len,
+                       unsigned long long* last_change, int* v_boolean) {
   auto v = nt::GetEntryValue(StringRef(name, name_len));
   if (!v || !v->IsBoolean()) return 0;
   *v_boolean = v->GetBoolean();
@@ -803,8 +789,8 @@ int NT_GetEntryBoolean(const char *name, size_t name_len,
   return 1;
 }
 
-int NT_GetEntryDouble(const char *name, size_t name_len,
-                      unsigned long long *last_change, double *v_double) {
+int NT_GetEntryDouble(const char* name, size_t name_len,
+                      unsigned long long* last_change, double* v_double) {
   auto v = nt::GetEntryValue(StringRef(name, name_len));
   if (!v || !v->IsDouble()) return 0;
   *last_change = v->last_change();
@@ -812,8 +798,8 @@ int NT_GetEntryDouble(const char *name, size_t name_len,
   return 1;
 }
 
-char *NT_GetEntryString(const char *name, size_t name_len,
-                        unsigned long long *last_change, size_t *str_len) {
+char* NT_GetEntryString(const char* name, size_t name_len,
+                        unsigned long long* last_change, size_t* str_len) {
   auto v = nt::GetEntryValue(StringRef(name, name_len));
   if (!v || !v->IsString()) return nullptr;
   *last_change = v->last_change();
@@ -823,8 +809,8 @@ char *NT_GetEntryString(const char *name, size_t name_len,
   return v_string.str;
 }
 
-char *NT_GetEntryRaw(const char *name, size_t name_len,
-                     unsigned long long *last_change, size_t *raw_len) {
+char* NT_GetEntryRaw(const char* name, size_t name_len,
+                     unsigned long long* last_change, size_t* raw_len) {
   auto v = nt::GetEntryValue(StringRef(name, name_len));
   if (!v || !v->IsRaw()) return nullptr;
   *last_change = v->last_change();
@@ -834,42 +820,41 @@ char *NT_GetEntryRaw(const char *name, size_t name_len,
   return v_raw.str;
 }
 
-int *NT_GetEntryBooleanArray(const char *name, size_t name_len,
-                             unsigned long long *last_change,
-                             size_t *arr_size) {
+int* NT_GetEntryBooleanArray(const char* name, size_t name_len,
+                             unsigned long long* last_change,
+                             size_t* arr_size) {
   auto v = nt::GetEntryValue(StringRef(name, name_len));
   if (!v || !v->IsBooleanArray()) return nullptr;
   *last_change = v->last_change();
   auto vArr = v->GetBooleanArray();
-  int *arr = static_cast<int *>(std::malloc(vArr.size() * sizeof(int)));
+  int* arr = static_cast<int*>(std::malloc(vArr.size() * sizeof(int)));
   *arr_size = vArr.size();
   std::copy(vArr.begin(), vArr.end(), arr);
   return arr;
 }
 
-double *NT_GetEntryDoubleArray(const char *name, size_t name_len,
-                               unsigned long long *last_change,
-                               size_t *arr_size) {
+double* NT_GetEntryDoubleArray(const char* name, size_t name_len,
+                               unsigned long long* last_change,
+                               size_t* arr_size) {
   auto v = nt::GetEntryValue(StringRef(name, name_len));
   if (!v || !v->IsDoubleArray()) return nullptr;
   *last_change = v->last_change();
   auto vArr = v->GetDoubleArray();
-  double *arr =
-      static_cast<double *>(std::malloc(vArr.size() * sizeof(double)));
+  double* arr = static_cast<double*>(std::malloc(vArr.size() * sizeof(double)));
   *arr_size = vArr.size();
   std::copy(vArr.begin(), vArr.end(), arr);
   return arr;
 }
 
-NT_String *NT_GetEntryStringArray(const char *name, size_t name_len,
-                                  unsigned long long *last_change,
-                                  size_t *arr_size) {
+NT_String* NT_GetEntryStringArray(const char* name, size_t name_len,
+                                  unsigned long long* last_change,
+                                  size_t* arr_size) {
   auto v = nt::GetEntryValue(StringRef(name, name_len));
   if (!v || !v->IsStringArray()) return nullptr;
   *last_change = v->last_change();
   auto vArr = v->GetStringArray();
-  NT_String *arr =
-      static_cast<NT_String *>(std::malloc(vArr.size() * sizeof(NT_String)));
+  NT_String* arr =
+      static_cast<NT_String*>(std::malloc(vArr.size() * sizeof(NT_String)));
   for (size_t i = 0; i < vArr.size(); ++i) {
     ConvertToC(vArr[i], &arr[i]);
   }