sparkplug_c.h

Go to the documentation of this file.

 
// include/sparkplug/sparkplug_c.h
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct sparkplug_publisher sparkplug_publisher_t;
 
typedef struct sparkplug_payload sparkplug_payload_t;
 
typedef enum {
  SPARKPLUG_LOG_DEBUG = 0, 
  SPARKPLUG_LOG_INFO = 1,  
  SPARKPLUG_LOG_WARN = 2,  
  SPARKPLUG_LOG_ERROR = 3  
} sparkplug_log_level_t;
 
typedef void (*sparkplug_log_callback_t)(int level,
                                         const char* message,
                                         size_t message_len,
                                         void* user_data);
 
typedef void (*sparkplug_message_callback_t)(const char* topic,
                                             const uint8_t* payload_data,
                                             size_t payload_len,
                                             void* user_data);
 
typedef void (*sparkplug_command_callback_t)(const char* topic,
                                             const uint8_t* payload_data,
                                             size_t payload_len,
                                             void* user_data);
 
/* ============================================================================
 * Publisher API
 * ========================================================================= */
 
sparkplug_publisher_t* sparkplug_publisher_create(const char* broker_url,
                                                  const char* client_id,
                                                  const char* group_id,
                                                  const char* edge_node_id);
 
void sparkplug_publisher_destroy(sparkplug_publisher_t* pub);
 
int sparkplug_publisher_set_credentials(sparkplug_publisher_t* pub,
                                        const char* username,
                                        const char* password);
 
int sparkplug_publisher_set_tls(sparkplug_publisher_t* pub,
                                const char* trust_store,
                                const char* key_store,
                                const char* private_key,
                                const char* private_key_password,
                                int enable_server_cert_auth);
 
void sparkplug_publisher_set_log_callback(sparkplug_publisher_t* pub,
                                          sparkplug_log_callback_t callback,
                                          void* user_data);
 
int sparkplug_publisher_connect(sparkplug_publisher_t* pub);
 
int sparkplug_publisher_disconnect(sparkplug_publisher_t* pub);
 
int sparkplug_publisher_publish_birth(sparkplug_publisher_t* pub,
                                      const uint8_t* payload_data,
                                      size_t payload_len);
 
int sparkplug_publisher_publish_data(sparkplug_publisher_t* pub,
                                     const uint8_t* payload_data,
                                     size_t payload_len);
 
int sparkplug_publisher_publish_death(sparkplug_publisher_t* pub);
 
int sparkplug_publisher_rebirth(sparkplug_publisher_t* pub);
 
uint64_t sparkplug_publisher_get_seq(const sparkplug_publisher_t* pub);
 
uint64_t sparkplug_publisher_get_bd_seq(const sparkplug_publisher_t* pub);
 
int sparkplug_publisher_publish_device_birth(sparkplug_publisher_t* pub,
                                             const char* device_id,
                                             const uint8_t* payload_data,
                                             size_t payload_len);
 
int sparkplug_publisher_publish_device_data(sparkplug_publisher_t* pub,
                                            const char* device_id,
                                            const uint8_t* payload_data,
                                            size_t payload_len);
 
int sparkplug_publisher_publish_device_death(sparkplug_publisher_t* pub,
                                             const char* device_id);
 
int sparkplug_publisher_publish_node_command(sparkplug_publisher_t* pub,
                                             const char* target_edge_node_id,
                                             const uint8_t* payload_data,
                                             size_t payload_len);
 
int sparkplug_publisher_publish_device_command(sparkplug_publisher_t* pub,
                                               const char* target_edge_node_id,
                                               const char* target_device_id,
                                               const uint8_t* payload_data,
                                               size_t payload_len);
 
/* ============================================================================
 * Host Application API
 * ========================================================================= */
 
typedef struct sparkplug_host_application sparkplug_host_application_t;
 
sparkplug_host_application_t* sparkplug_host_application_create(const char* broker_url,
                                                                const char* client_id,
                                                                const char* host_id);
 
void sparkplug_host_application_destroy(sparkplug_host_application_t* host);
 
int sparkplug_host_application_set_credentials(sparkplug_host_application_t* host,
                                               const char* username,
                                               const char* password);
 
int sparkplug_host_application_set_tls(sparkplug_host_application_t* host,
                                       const char* trust_store,
                                       const char* key_store,
                                       const char* private_key,
                                       const char* private_key_password,
                                       int enable_server_cert_auth);
 
int sparkplug_host_application_connect(sparkplug_host_application_t* host);
 
int sparkplug_host_application_disconnect(sparkplug_host_application_t* host);
 
int sparkplug_host_application_publish_state_birth(sparkplug_host_application_t* host,
                                                   uint64_t timestamp);
 
int sparkplug_host_application_publish_state_death(sparkplug_host_application_t* host,
                                                   uint64_t timestamp);
 
int sparkplug_host_application_publish_node_command(sparkplug_host_application_t* host,
                                                    const char* group_id,
                                                    const char* target_edge_node_id,
                                                    const uint8_t* payload_data,
                                                    size_t payload_len);
 
int sparkplug_host_application_publish_device_command(sparkplug_host_application_t* host,
                                                      const char* group_id,
                                                      const char* target_edge_node_id,
                                                      const char* target_device_id,
                                                      const uint8_t* payload_data,
                                                      size_t payload_len);
 
int sparkplug_host_application_set_message_callback(sparkplug_host_application_t* host,
                                                    sparkplug_message_callback_t callback,
                                                    void* user_data);
 
void sparkplug_host_application_set_log_callback(sparkplug_host_application_t* host,
                                                 sparkplug_log_callback_t callback,
                                                 void* user_data);
 
int sparkplug_host_application_subscribe_all(sparkplug_host_application_t* host);
 
int sparkplug_host_application_subscribe_group(sparkplug_host_application_t* host,
                                               const char* group_id);
 
int sparkplug_host_application_subscribe_node(sparkplug_host_application_t* host,
                                              const char* group_id,
                                              const char* edge_node_id);
 
int sparkplug_host_application_get_metric_name(sparkplug_host_application_t* host,
                                               const char* group_id,
                                               const char* edge_node_id,
                                               const char* device_id,
                                               uint64_t alias,
                                               char* name_buffer,
                                               size_t buffer_size);
 
/* ============================================================================
 * Payload Builder API
 * ========================================================================= */
 
sparkplug_payload_t* sparkplug_payload_create(void);
 
void sparkplug_payload_destroy(sparkplug_payload_t* payload);
 
void sparkplug_payload_set_timestamp(sparkplug_payload_t* payload, uint64_t ts);
 
void sparkplug_payload_set_seq(sparkplug_payload_t* payload, uint64_t seq);
 
/* Metric functions by name */
 
void sparkplug_payload_add_int8(sparkplug_payload_t* payload,
                                const char* name,
                                int8_t value);
void sparkplug_payload_add_int16(sparkplug_payload_t* payload,
                                 const char* name,
                                 int16_t value);
void sparkplug_payload_add_int32(sparkplug_payload_t* payload,
                                 const char* name,
                                 int32_t value);
void sparkplug_payload_add_int64(sparkplug_payload_t* payload,
                                 const char* name,
                                 int64_t value);
void sparkplug_payload_add_uint8(sparkplug_payload_t* payload,
                                 const char* name,
                                 uint8_t value);
void sparkplug_payload_add_uint16(sparkplug_payload_t* payload,
                                  const char* name,
                                  uint16_t value);
void sparkplug_payload_add_uint32(sparkplug_payload_t* payload,
                                  const char* name,
                                  uint32_t value);
void sparkplug_payload_add_uint64(sparkplug_payload_t* payload,
                                  const char* name,
                                  uint64_t value);
void sparkplug_payload_add_float(sparkplug_payload_t* payload,
                                 const char* name,
                                 float value);
void sparkplug_payload_add_double(sparkplug_payload_t* payload,
                                  const char* name,
                                  double value);
void sparkplug_payload_add_bool(sparkplug_payload_t* payload,
                                const char* name,
                                bool value);
void sparkplug_payload_add_string(sparkplug_payload_t* payload,
                                  const char* name,
                                  const char* value);
 
/* Metric functions with alias */
 
void sparkplug_payload_add_int32_with_alias(sparkplug_payload_t* payload,
                                            const char* name,
                                            uint64_t alias,
                                            int32_t value);
void sparkplug_payload_add_int64_with_alias(sparkplug_payload_t* payload,
                                            const char* name,
                                            uint64_t alias,
                                            int64_t value);
void sparkplug_payload_add_uint32_with_alias(sparkplug_payload_t* payload,
                                             const char* name,
                                             uint64_t alias,
                                             uint32_t value);
void sparkplug_payload_add_uint64_with_alias(sparkplug_payload_t* payload,
                                             const char* name,
                                             uint64_t alias,
                                             uint64_t value);
void sparkplug_payload_add_float_with_alias(sparkplug_payload_t* payload,
                                            const char* name,
                                            uint64_t alias,
                                            float value);
void sparkplug_payload_add_double_with_alias(sparkplug_payload_t* payload,
                                             const char* name,
                                             uint64_t alias,
                                             double value);
void sparkplug_payload_add_bool_with_alias(sparkplug_payload_t* payload,
                                           const char* name,
                                           uint64_t alias,
                                           bool value);
 
/* Metric functions with name, alias, and timestamp */
 
void sparkplug_payload_add_int32_with_alias_timestamp(sparkplug_payload_t* payload,
                                                      const char* name,
                                                      uint64_t alias,
                                                      int32_t value,
                                                      uint64_t timestamp_ms);
void sparkplug_payload_add_int64_with_alias_timestamp(sparkplug_payload_t* payload,
                                                      const char* name,
                                                      uint64_t alias,
                                                      int64_t value,
                                                      uint64_t timestamp_ms);
void sparkplug_payload_add_uint32_with_alias_timestamp(sparkplug_payload_t* payload,
                                                       const char* name,
                                                       uint64_t alias,
                                                       uint32_t value,
                                                       uint64_t timestamp_ms);
void sparkplug_payload_add_uint64_with_alias_timestamp(sparkplug_payload_t* payload,
                                                       const char* name,
                                                       uint64_t alias,
                                                       uint64_t value,
                                                       uint64_t timestamp_ms);
void sparkplug_payload_add_float_with_alias_timestamp(sparkplug_payload_t* payload,
                                                      const char* name,
                                                      uint64_t alias,
                                                      float value,
                                                      uint64_t timestamp_ms);
void sparkplug_payload_add_double_with_alias_timestamp(sparkplug_payload_t* payload,
                                                       const char* name,
                                                       uint64_t alias,
                                                       double value,
                                                       uint64_t timestamp_ms);
void sparkplug_payload_add_bool_with_alias_timestamp(sparkplug_payload_t* payload,
                                                     const char* name,
                                                     uint64_t alias,
                                                     bool value,
                                                     uint64_t timestamp_ms);
 
/* Metric functions by alias only */
 
void sparkplug_payload_add_int32_by_alias(sparkplug_payload_t* payload,
                                          uint64_t alias,
                                          int32_t value);
void sparkplug_payload_add_int64_by_alias(sparkplug_payload_t* payload,
                                          uint64_t alias,
                                          int64_t value);
void sparkplug_payload_add_uint32_by_alias(sparkplug_payload_t* payload,
                                           uint64_t alias,
                                           uint32_t value);
void sparkplug_payload_add_uint64_by_alias(sparkplug_payload_t* payload,
                                           uint64_t alias,
                                           uint64_t value);
void sparkplug_payload_add_float_by_alias(sparkplug_payload_t* payload,
                                          uint64_t alias,
                                          float value);
void sparkplug_payload_add_double_by_alias(sparkplug_payload_t* payload,
                                           uint64_t alias,
                                           double value);
void sparkplug_payload_add_bool_by_alias(sparkplug_payload_t* payload,
                                         uint64_t alias,
                                         bool value);
 
size_t sparkplug_payload_serialize(const sparkplug_payload_t* payload,
                                   uint8_t* buffer,
                                   size_t buffer_size);
 
/* ============================================================================
 * Payload Parsing and Reading API
 * ========================================================================= */
 
sparkplug_payload_t* sparkplug_payload_parse(const uint8_t* data, size_t data_len);
 
bool sparkplug_payload_get_timestamp(const sparkplug_payload_t* payload,
                                     uint64_t* out_timestamp);
 
bool sparkplug_payload_get_seq(const sparkplug_payload_t* payload, uint64_t* out_seq);
 
const char* sparkplug_payload_get_uuid(const sparkplug_payload_t* payload);
 
size_t sparkplug_payload_get_metric_count(const sparkplug_payload_t* payload);
 
typedef enum {
  SPARKPLUG_DATA_TYPE_UNKNOWN = 0,
  SPARKPLUG_DATA_TYPE_INT8 = 1,
  SPARKPLUG_DATA_TYPE_INT16 = 2,
  SPARKPLUG_DATA_TYPE_INT32 = 3,
  SPARKPLUG_DATA_TYPE_INT64 = 4,
  SPARKPLUG_DATA_TYPE_UINT8 = 5,
  SPARKPLUG_DATA_TYPE_UINT16 = 6,
  SPARKPLUG_DATA_TYPE_UINT32 = 7,
  SPARKPLUG_DATA_TYPE_UINT64 = 8,
  SPARKPLUG_DATA_TYPE_FLOAT = 9,
  SPARKPLUG_DATA_TYPE_DOUBLE = 10,
  SPARKPLUG_DATA_TYPE_BOOLEAN = 11,
  SPARKPLUG_DATA_TYPE_STRING = 12,
  SPARKPLUG_DATA_TYPE_DATETIME = 13,
  SPARKPLUG_DATA_TYPE_TEXT = 14,
} sparkplug_data_type_t;
 
typedef union {
  int8_t int8_value;
  int16_t int16_value;
  int32_t int32_value;
  int64_t int64_value;
  uint8_t uint8_value;
  uint16_t uint16_value;
  uint32_t uint32_value;
  uint64_t uint64_value;
  float float_value;
  double double_value;
  bool boolean_value;
  const char*
      string_value; 
} sparkplug_metric_value_t;
 
typedef struct {
  const char* name;               
  uint64_t alias;                 
  uint64_t timestamp;             
  sparkplug_data_type_t datatype; 
  bool has_name;                  
  bool has_alias;                 
  bool has_timestamp;             
  bool is_null;                   
  sparkplug_metric_value_t value; 
} sparkplug_metric_t;
 
bool sparkplug_payload_get_metric_at(const sparkplug_payload_t* payload,
                                     size_t index,
                                     sparkplug_metric_t* out_metric);
 
#ifdef __cplusplus
}
#endif