south_api.h

Go to the documentation of this file.

#ifndef TEK_SOUTH_API_H
#define TEK_SOUTH_API_H
 
#define TEK_SA_API_VERSION_MAJOR 0
#define TEK_SA_API_VERSION_MINOR 1
#define TEK_SA_API_VERSION_PATCH 0
#define TEK_SA_API_VERSION "0.1.0"
 
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
 
#define TEK_SA_STRUCT_ALIGN_SELECT(O32, O64) (sizeof(void*) == 8 ? O64 : O32)
 
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L
#include <assert.h>
#define TEK_SA_VERIFY_STRUCT_OFFSET(S, M, O32, O64)                             \
  ;                                                                             \
  _Static_assert(offsetof(struct S, M) == TEK_SA_STRUCT_ALIGN_SELECT(O32, O64), \
                 "struct offset of field " #M " in " #S " must be correct")
#else
#define TEK_SA_VERIFY_STRUCT_OFFSET(S, M, O32, O64)                                  \
  ;                                                                                  \
  enum {                                                                             \
    S##__##M##_offset =                                                              \
        1 / (int)(!!(offsetof(struct S, M) == TEK_SA_STRUCT_ALIGN_SELECT(O32, O64))) \
  };
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef void* tek_sa_data_client_handle;
 
/**************************************************************************************************
 * Configuration structures
 *************************************************************************************************/
 
struct tek_sa_additional_file {
  char* name;
 
  char* content;
};
 
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_additional_file, name, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_additional_file, content, 4, 8);
 
struct tek_sa_data_client_configuration {
  char* config;
 
  struct tek_sa_additional_file* additional_files;
 
  uint32_t additional_files_count;
};
 
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client_configuration, config, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client_configuration, additional_files, 4, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client_configuration, additional_files_count, 8, 16);
 
struct tek_sa_configuration {
  uint32_t request_timeout_ms;
};
 
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_configuration, request_timeout_ms, 0, 0);
 
/**************************************************************************************************
 * Built-in type definitions and variant
 *************************************************************************************************/
 
typedef int64_t tek_sa_type_handle;
 
typedef int64_t tek_sa_type_handle_or_type_enum;
 
struct tek_sa_guid {
  uint32_t data1;
 
  uint16_t data2;
 
  uint16_t data3;
 
  uint8_t data4[8];
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_guid, data1, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_guid, data2, 4, 4);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_guid, data3, 6, 6);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_guid, data4, 8, 8);
 
struct tek_sa_byte_string {
  int32_t length;
 
  unsigned char* data;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_byte_string, length, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_byte_string, data, 4, 8);
 
struct tek_sa_string {
  int32_t length;
 
  unsigned char* data;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_string, length, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_string, data, 4, 8);
 
typedef int64_t tek_sa_datetime;
 
struct tek_sa_complex_data {
  tek_sa_type_handle type;
 
  uint32_t data_length;
 
  unsigned char* data;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data, type, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data, data_length, 8, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data, data, 12, 16);
 
struct tek_sa_complex_data_array_item {
  uint32_t data_length;
 
  unsigned char* data;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data_array_item, data_length, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data_array_item, data, 4, 8);
 
struct tek_sa_complex_data_array {
  tek_sa_type_handle type;
 
  uint32_t number_of_items;
 
  struct tek_sa_complex_data_array_item* data;
};
 
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data_array, type, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data_array, number_of_items, 8, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data_array, data, 12, 16);
 
struct tek_sa_complex_data_matrix {
  tek_sa_type_handle type;
 
  uint32_t dimension_length;
 
  uint32_t* dimensions;
 
  struct tek_sa_complex_data_array_item* data;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data_matrix, type, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data_matrix, dimension_length, 8, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data_matrix, dimensions, 12, 16);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_complex_data_matrix, data, 16, 24);
 
enum tek_sa_variant_type {
  TEK_SA_VARIANT_TYPE_NULL = 0x0,
 
  TEK_SA_VARIANT_TYPE_BOOL = 0x1,
 
  TEK_SA_VARIANT_TYPE_UINT8_T = 0x2,
 
  TEK_SA_VARIANT_TYPE_INT8_T = 0x3,
 
  TEK_SA_VARIANT_TYPE_UINT16_T = 0x4,
 
  TEK_SA_VARIANT_TYPE_INT16_T = 0x5,
 
  TEK_SA_VARIANT_TYPE_UINT32_T = 0x6,
 
  TEK_SA_VARIANT_TYPE_INT32_T = 0x7,
 
  TEK_SA_VARIANT_TYPE_UINT64_T = 0x8,
 
  TEK_SA_VARIANT_TYPE_INT64_T = 0x9,
 
  TEK_SA_VARIANT_TYPE_FLOAT = 0xa,
 
  TEK_SA_VARIANT_TYPE_DOUBLE = 0xb,
 
  TEK_SA_VARIANT_TYPE_DATETIME = 0xc,
 
  TEK_SA_VARIANT_TYPE_STRING = 0xd,
 
  TEK_SA_VARIANT_TYPE_GUID = 0xe,
 
  TEK_SA_VARIANT_TYPE_BYTE_STRING = 0xf,
 
  TEK_SA_VARIANT_TYPE_COMPLEX = 0x20,
 
  TEK_SA_VARIANT_TYPE_FLAG_ARRAY = 0x40,
 
  TEK_SA_VARIANT_TYPE_FLAG_MATRIX = 0x80
};
 
struct tek_sa_variant_array {
  uint32_t length;
 
  union {
    bool* b;
    uint8_t* ui8;
    int8_t* i8;
    uint16_t* ui16;
    int16_t* i16;
    uint32_t* ui32;
    int32_t* i32;
    uint64_t* ui64;
    int64_t* i64;
    float* f;
    double* d;
    tek_sa_datetime* dt;
    struct tek_sa_string* s;
    struct tek_sa_guid* guid;
    struct tek_sa_byte_string* bs;
  } data;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_variant_array, length, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_variant_array, data, 4, 8);
 
struct tek_sa_variant_matrix {
  uint32_t dimension_length;
 
  uint32_t* dimensions;
 
  struct tek_sa_variant_array data;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_variant_matrix, dimension_length, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_variant_matrix, dimensions, 4, 8);
 
struct tek_sa_variant {
  uint8_t type;
 
  union {
    bool b;
    uint8_t ui8;
    int8_t i8;
    uint16_t ui16;
    int16_t i16;
    uint32_t ui32;
    int32_t i32;
    uint64_t ui64;
    int64_t i64;
    float f;
    double d;
    tek_sa_datetime dt;
    struct tek_sa_string s;
    struct tek_sa_guid guid;
    struct tek_sa_byte_string bs;
    struct tek_sa_variant_array array;
    struct tek_sa_variant_matrix matrix;
    struct tek_sa_complex_data complex;
    struct tek_sa_complex_data_array complex_array;
    struct tek_sa_complex_data_matrix complex_matrix;
  } data;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_variant, type, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_variant, data, 8, 8);
 
typedef struct tek_sa_variant tek_sa_field_value;
 
/**************************************************************************************************
 * Type definitions from data client to TEK
 *************************************************************************************************/
 
struct tek_sa_struct_field_type_definition {
  char* name;
 
  tek_sa_type_handle_or_type_enum type;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_struct_field_type_definition, name, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_struct_field_type_definition, type, 8, 8);
 
struct tek_sa_struct_definition {
  char* name;
 
  struct tek_sa_struct_field_type_definition* items;
 
  uint32_t item_count;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_struct_definition, name, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_struct_definition, items, 4, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_struct_definition, item_count, 8, 16);
 
struct tek_sa_enum_item_definition {
  char* name;
 
  int32_t value;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_enum_item_definition, name, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_enum_item_definition, value, 4, 8);
 
struct tek_sa_enum_definition {
  char* name;
 
  struct tek_sa_enum_item_definition* items;
 
  uint32_t item_count;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_enum_definition, name, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_enum_definition, items, 4, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_enum_definition, item_count, 8, 16);
 
struct tek_sa_method_argument_description {
  char const* name;
 
  enum tek_sa_variant_type type;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_method_argument_description, name, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_method_argument_description, type, 4, 8);
 
/**************************************************************************************************
 * Handles and structures for data exchange
 *************************************************************************************************/
 
enum tek_sa_field_attributes {
  TEK_SA_FIELD_ATTRIBUTES_WRITABLE = 0x1,
 
  TEK_SA_FIELD_ATTRIBUTES_READABLE = 0x2,
 
  TEK_SA_FIELD_ATTRIBUTES_SUBSCRIBABLE = 0x4,
};
 
typedef uint32_t tek_sa_field_handle;
 
typedef uint32_t tek_sa_event_handle;
 
typedef uint32_t tek_sa_alarm_handle;
 
typedef uint32_t tek_sa_method_handle;
 
typedef int TEK_SA_RESULT;
 
#define TEK_SA_ERR_SUCCESS 0
 
#define TEK_SA_ERR_NON_BLOCKING_IMPOSSIBLE 10
 
#define TEK_SA_ERR_OUT_OF_MEMORY 11
 
#define TEK_SA_ERR_INVALID_PARAMETER 12
 
#define TEK_SA_ERR_RETRY_LATER 0xffffffff
 
#define TEK_SA_READ_RESULT_STATUS_OK 0
 
#define TEK_SA_READ_RESULT_STATUS_NOK 1
 
#define TEK_SA_READ_RESULT_STATUS_TIMEOUT 2
 
#define TEK_SA_READ_RESULT_STATUS_INVALID_HANDLE 3
 
#define TEK_SA_BLOCK_TRANSFER_END_OF_FILE 26
 
#define TEK_SA_BLOCK_TRANSFER_ABORT 24
#define TEK_SA_ERR_UNSPECIFIED 1000
 
/**************************************************************************************************
 * Request and response structures
 *************************************************************************************************/
 
struct tek_sa_field_write_request {
  tek_sa_field_handle handle;
 
  tek_sa_field_value value;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_field_write_request, handle, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_field_write_request, value, 8, 8);
 
struct tek_sa_write_result {
  TEK_SA_RESULT status;
 
  tek_sa_field_handle handle;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_write_result, status, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_write_result, handle, 4, 4);
 
struct tek_sa_read_result {
  TEK_SA_RESULT status;
 
  tek_sa_field_handle handle;
 
  tek_sa_field_value value;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_read_result, status, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_read_result, handle, 4, 4);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_read_result, value, 8, 8);
 
struct tek_sa_event_parameter {
  char const* name;
 
  tek_sa_field_value value;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_event_parameter, name, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_event_parameter, value, 8, 8);
 
struct tek_sa_dc_event {
  tek_sa_datetime timestamp;
 
  int16_t severity;
 
  tek_sa_event_handle event_type;
 
  tek_sa_field_handle source;
 
  uint32_t number_of_parameters;
 
  struct tek_sa_event_parameter* parameters;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_dc_event, timestamp, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_dc_event, severity, 8, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_dc_event, event_type, 12, 12);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_dc_event, source, 16, 16);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_dc_event, number_of_parameters, 20, 20);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_dc_event, parameters, 24, 24);
 
enum tek_sa_log_level_t {
  TEK_SA_LOG_LEVEL_TRACE = 0x0,
  TEK_SA_LOG_LEVEL_DEBUG = 0x1,
  TEK_SA_LOG_LEVEL_INFO = 0x2,
  TEK_SA_LOG_LEVEL_WARNING = 0x3,
  TEK_SA_LOG_LEVEL_ERROR = 0x4,
  TEK_SA_LOG_LEVEL_CRITICAL = 0x5,
};
 
/**************************************************************************************************
 * Data client capabilities
 *************************************************************************************************/
 
enum tek_sa_threading_model {
  TEK_SA_THREADING_MODEL_SAME_THREAD = 0x0,
 
  TEK_SA_THREADING_MODEL_SEQUENTIAL = 0x1,
 
  TEK_SA_THREADING_MODEL_PARALLEL = 0x2,
};
 
struct tek_sa_data_client_capabilities {
  uint32_t number_of_inflight_calls;
 
  enum tek_sa_threading_model threading_model;
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client_capabilities, number_of_inflight_calls, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client_capabilities, threading_model, 4, 4);
 
struct tek_sa_data_client {
  TEK_SA_RESULT (*register_features)(tek_sa_data_client_handle dc);
 
  TEK_SA_RESULT (*connect)(tek_sa_data_client_handle dc);
 
  void (*free)(tek_sa_data_client_handle dc);
 
  TEK_SA_RESULT (*read_fields)(tek_sa_data_client_handle dc,
                               uint64_t request_id,
                               const tek_sa_field_handle items_to_read[],
                               uint32_t number_of_items,
                               bool do_not_block);
 
  TEK_SA_RESULT (*write_fields)(tek_sa_data_client_handle dc,
                                uint64_t request_id,
                                const struct tek_sa_field_write_request items_to_write[],
                                uint32_t number_of_items,
                                bool do_not_block);
 
  TEK_SA_RESULT (*block_read)(const tek_sa_data_client_handle dc,
                              uint64_t request_id,
                              const char* filepath,
                              uint64_t offset,
                              int64_t length,
                              bool do_not_block,
                              int64_t* filesize);
 
  TEK_SA_RESULT (*block_write)(const tek_sa_data_client_handle dc,
                               uint64_t request_id,
                               const char* filepath,
                               uint64_t offset,
                               int64_t length,
                               bool do_not_block);
 
  TEK_SA_RESULT (*subscribe)(tek_sa_data_client_handle dc,
                             const tek_sa_field_handle items_to_subscribe[],
                             uint32_t number_of_items);
 
  TEK_SA_RESULT (*unsubscribe)(tek_sa_data_client_handle dc,
                               const tek_sa_field_handle items_to_unsubscribe[],
                               uint32_t number_of_items);
 
  TEK_SA_RESULT (*invoke)(const tek_sa_data_client_handle dc,
                          const tek_sa_method_handle method,
                          uint64_t request_id,
                          const tek_sa_field_value parameters[],
                          const uint32_t number_of_parameters);
 
  TEK_SA_RESULT (*acknowledge_alarm)(tek_sa_data_client_handle dc, const tek_sa_alarm_handle alarm);
 
  tek_sa_data_client_handle handle;
 
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, register_features, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, connect, 4, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, free, 8, 16);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, read_fields, 12, 24);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, write_fields, 16, 32);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, block_read, 20, 40);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, block_write, 24, 48);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, subscribe, 28, 56);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, unsubscribe, 32, 64);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, invoke, 36, 72);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, acknowledge_alarm, 40, 80);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client, handle, 44, 88);
 
struct tek_sa_data_client_plugin {
  void* plugin_context;
 
  TEK_SA_RESULT (*data_client_new)(void* plugin_context,
                                   const struct tek_sa_data_client_configuration* config,
                                   struct tek_sa_data_client* created_client,
                                   struct tek_sa_data_client_capabilities* capabilities);
 
  void (*free_context)(void* plugin_context);
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client_plugin, plugin_context, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client_plugin, data_client_new, 4, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_data_client_plugin, free_context, 8, 16);
 
struct tek_sa_transformation_engine {
  TEK_SA_RESULT (*register_field)(tek_sa_data_client_handle dc,
                                  const char* name,
                                  enum tek_sa_field_attributes attributes,
                                  enum tek_sa_variant_type type,
                                  tek_sa_field_handle* new_field_handle);
 
  TEK_SA_RESULT (*register_method)(tek_sa_data_client_handle dc,
                                   const char* name,
                                   struct tek_sa_method_argument_description input_parameter[],
                                   uint32_t number_of_input_parameters,
                                   struct tek_sa_method_argument_description output_parameter[],
                                   uint32_t number_of_output_parameters,
                                   tek_sa_method_handle* new_method_handle);
 
  TEK_SA_RESULT (*register_event)(tek_sa_data_client_handle dc,
                                  const char* name,
                                  tek_sa_event_handle* new_event_handle);
 
  TEK_SA_RESULT (*register_alarm)(tek_sa_data_client_handle dc,
                                  const char* name,
                                  const int16_t severity,
                                  const tek_sa_field_handle source,
                                  tek_sa_alarm_handle* new_alarm_handle);
 
  TEK_SA_RESULT (*register_enum_type)(tek_sa_data_client_handle dc,
                                      struct tek_sa_enum_definition const* type_definition,
                                      tek_sa_type_handle* new_type_handle);
 
  TEK_SA_RESULT (*register_struct_type)(tek_sa_data_client_handle dc,
                                        struct tek_sa_struct_definition const* type_definition,
                                        tek_sa_type_handle* new_type_handle);
 
  TEK_SA_RESULT (*post_event)(tek_sa_data_client_handle dc, struct tek_sa_dc_event const* event);
 
  TEK_SA_RESULT (*set_alarm)(tek_sa_data_client_handle dc, const tek_sa_alarm_handle alarm);
 
  TEK_SA_RESULT (*reset_alarm)(tek_sa_data_client_handle dc, const tek_sa_alarm_handle alarm);
 
  TEK_SA_RESULT (*log)(tek_sa_data_client_handle source,
                       enum tek_sa_log_level_t lvl,
                       const char* format,
                       va_list args);
 
  tek_sa_event_handle (*get_global_event)(const char* name);
 
  TEK_SA_RESULT (*update_capabilities)(tek_sa_data_client_handle dc,
                                       struct tek_sa_data_client_capabilities const* capabilities);
 
  TEK_SA_RESULT (*read_progress)(tek_sa_data_client_handle dc,
                                 uint64_t request_id,
                                 uint64_t progress);
 
  TEK_SA_RESULT (*read_result)(tek_sa_data_client_handle dc,
                               uint64_t request_id,
                               TEK_SA_RESULT result,
                               const struct tek_sa_read_result results[],
                               uint32_t number_of_results);
 
  TEK_SA_RESULT (*notify_change)(tek_sa_data_client_handle dc,
                                 const struct tek_sa_read_result changes[],
                                 uint32_t number_of_changes);
 
  TEK_SA_RESULT (*write_result)(tek_sa_data_client_handle dc,
                                uint64_t request_id,
                                TEK_SA_RESULT result,
                                const struct tek_sa_write_result results[],
                                uint32_t number_of_results);
 
  TEK_SA_RESULT (*call_method_result)(tek_sa_data_client_handle dc,
                                      uint64_t request_id,
                                      TEK_SA_RESULT result,
                                      const tek_sa_field_value results[],
                                      uint32_t number_of_results);
 
  TEK_SA_RESULT (*block_read_data)(tek_sa_data_client_handle dc,
                                   uint64_t request_id,
                                   TEK_SA_RESULT result,
                                   unsigned char buffer[],
                                   uint32_t buffer_length);
 
  TEK_SA_RESULT (*block_write_data)(tek_sa_data_client_handle dc,
                                    uint64_t request_id,
                                    unsigned char buffer[],
                                    uint32_t buffer_length,
                                    uint32_t* bytes_written);
 
  TEK_SA_RESULT (*block_write_result)(tek_sa_data_client_handle dc,
                                      uint64_t request_id,
                                      TEK_SA_RESULT result);
 
};
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, register_field, 0, 0);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, register_method, 4, 8);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, register_event, 8, 16);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, register_alarm, 12, 24);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, register_enum_type, 16, 32);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, register_struct_type, 20, 40);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, post_event, 24, 48);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, set_alarm, 28, 56);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, reset_alarm, 32, 64);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, log, 36, 72);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, get_global_event, 40, 80);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, update_capabilities, 44, 88);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, read_progress, 48, 96);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, read_result, 52, 104);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, notify_change, 56, 112);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, write_result, 60, 120);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, call_method_result, 64, 128);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, block_read_data, 68, 136);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, block_write_data, 72, 144);
TEK_SA_VERIFY_STRUCT_OFFSET(tek_sa_transformation_engine, block_write_result, 76, 152);
 
typedef TEK_SA_RESULT (*tek_sa_load_plugin_fn)(
    struct tek_sa_transformation_engine* api,
    const struct tek_sa_data_client_configuration* plugin_configuration,
    struct tek_sa_data_client_plugin* plugin,
    struct tek_sa_configuration* tek_configuration);
 
#ifdef TEK_SA_DATA_CLIENT_IMPL
 
#ifdef _WIN32
#define TEK_SA_API_EXPORT __declspec(dllexport) __stdcall
#else
#define TEK_SA_API_EXPORT __attribute__((__visibility__("default")))
#endif
 
TEK_SA_RESULT TEK_SA_API_EXPORT
load_plugin(struct tek_sa_transformation_engine* api,
            const struct tek_sa_data_client_configuration* plugin_configuration,
            struct tek_sa_data_client_plugin* plugin,
            struct tek_sa_configuration* tek_configuration);
 
#endif
 
#ifdef __cplusplus
}
#endif
 
#undef TEK_SA_STRUCT_ALIGN_SELECT
#undef TEK_SA_VERIFY_STRUCT_OFFSET
 
#endif /* TEK_SOUTH_API_H */