star-phor-input

sphin_sensor_surface.c (5906B)

---

 /* Copyright (C) 2024-2026 Centre National de la Recherche Scientifique
  * Copyright (C) 2024-2026 Clermont Auvergne INP
  * Copyright (C) 2024-2026 INSA Lyon
  * Copyright (C) 2024-2026 Institut Mines Télécom Albi-Carmaux
  * Copyright (C) 2024-2026 Institut National Polytechnique de Toulouse
  * Copyright (C) 2024-2026 |Méso|Star> (contact@meso-star.com)
  * Copyright (C) 2024-2026 PhotonLyX (info@photonlyx.com)
  * Copyright (C) 2024-2026 Université de Lorraine
  * Copyright (C) 2024-2026 Université Paul Sabatier
  * Copyright (C) 2024-2026 Université Toulouse - Jean Jaurès
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>. */
 #define _POSIX_C_SOURCE 200112L /* for strtok_r support */
 
 #include "sphin.h"
 #include "sphin_c.h"
 #include "sphin_config.h"
 #include "sphin_sensor.h"
 #include "sphin_sensor_surface.h"
 
 #include <rsys/mem_allocator.h>
 #include <rsys/ref_count.h>
 #include <rsys/rsys.h>
 #include <rsys/str.h>
 #include <rsys/text_reader.h>
 
 struct txtrdr;
 
 struct sphin_sensor_surface {
   struct str name;
   double response_function;
 
   struct sphin* sphin;
   ref_T ref;
 };
 
 /*******************************************************************************
  * Helper functions
  ******************************************************************************/
 static res_T
 sensor_surface_create
   (struct sphin* sphin,
    const char* name,
    struct sphin_sensor_surface** out_sensor_surface)
 {
   struct sphin_sensor_surface* sensor_surface = NULL;
   res_T res = RES_OK;
 
   ASSERT(NULL != sphin);
   ASSERT(NULL != out_sensor_surface);
   ASSERT(NULL != name);
   ASSERT('\0' != name[0]); /* Name can't be empty */
 
   sensor_surface = MEM_CALLOC
     (sphin->allocator, 1, sizeof(struct sphin_sensor_surface));
   if (NULL == sensor_surface) { res = RES_MEM_ERR; goto error; }
   ref_init(&sensor_surface->ref);
   SPHIN(ref_get(sphin));
   sensor_surface->sphin = sphin;
 
   str_init(sphin->allocator, &sensor_surface->name);
   res = str_set(&sensor_surface->name, name);
   if (RES_OK != res) { goto error; }
 
 exit:
   *out_sensor_surface = sensor_surface;
   return res;
 error:
   if (NULL != sensor_surface) {
     SPHIN(sensor_surface_ref_put(sensor_surface));
     sensor_surface = NULL;
   }
   goto exit;
 }
 
 static void
 release_sensor_surface
   (ref_T* address)
 {
   struct sphin_sensor_surface* sensor_surface = NULL;
   struct sphin* sphin = NULL;
 
   ASSERT(NULL != address);
   sensor_surface = CONTAINER_OF(address, struct sphin_sensor_surface, ref);
   str_release(&sensor_surface->name);
   sphin = sensor_surface->sphin;
   MEM_RM(sphin->allocator, sensor_surface);
   SPHIN(ref_put(sphin));
 }
 
 /*******************************************************************************
  * Local functions
  ******************************************************************************/
 res_T
 parse_sensor_surface
   (struct sphin* sphin,
    struct txtrdr* txtrdr,
    const char* name,
    struct sphin_sensor_surface** out_sensor_surface)
 {
   char* keyword = NULL;
   char* token = NULL;
   char* token_ptr = NULL;
   char* value = NULL;
   struct sphin_sensor_surface* sensor_surface = NULL;
   struct str line;
   res_T res = RES_OK;
 
   ASSERT(NULL != sphin);
   ASSERT(NULL != txtrdr);
   ASSERT(NULL != name);
   ASSERT(NULL != out_sensor_surface);
 
   str_init(sphin->allocator, &line);
 
   res = sensor_surface_create(sphin, name, &sensor_surface);
   if (RES_OK != res) { goto error; }
 
   res = txtrdr_read_line(txtrdr);
   if (RES_OK != res) { goto error; }
 
   while (NULL != txtrdr_get_line(txtrdr)) {
     res = str_set(&line, txtrdr_get_cline(txtrdr));
     if (RES_OK != res) { goto error; }
 
     /* Parse keyword */
     token = strtok_r(str_get(&line), ":", &token_ptr);
     if (NULL == token){ res = RES_BAD_ARG; goto error; }
     keyword = trim_keyword(token);
     if (NULL == keyword){ res = RES_BAD_ARG; goto error; }
 
     /* Parse value */
     token = strtok_r(NULL, "", &token_ptr);
     value = token;
     /* Parse response function */
     if (0 == strcmp(keyword, "response_function")){
       res =  parse_response_function(&sensor_surface->response_function,
                                      txtrdr, value);
     }
     else {
       break;
     }
     if (RES_OK != res) { goto error; }
   }
 
 exit:
   str_release(&line);
   *out_sensor_surface = sensor_surface;
   return res;
 error:
   if (sensor_surface != NULL){
     SPHIN(sensor_surface_ref_put(sensor_surface));
     sensor_surface = NULL;
   }
   goto exit;
 }
 
 /*******************************************************************************
  * Exported functions
  ******************************************************************************/
 res_T
 sphin_sensor_surface_ref_get
   (struct sphin_sensor_surface* sensor_surface)
 {
   if (NULL == sensor_surface) {
     return RES_BAD_ARG;
   }
   ref_get(&sensor_surface->ref);
   return RES_OK;
 }
 
 res_T
 sphin_sensor_surface_ref_put
   (struct sphin_sensor_surface* sensor_surface)
 {
   if (NULL == sensor_surface) {
     return RES_BAD_ARG;
   }
   ref_put(&sensor_surface->ref, release_sensor_surface);
   return RES_OK;
 }
 
 res_T
 sphin_sensor_surface_get_response_function
   (struct sphin_sensor_surface* sensor_surface,
    double* response_function)
 {
   if (NULL == sensor_surface || NULL == response_function){
     return RES_BAD_ARG;
   }
 
   *response_function = sensor_surface->response_function;
   return RES_OK;
 }