star-phor-input

sphin_refractive_index.c (5919B)

---

 /* 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_refractive_index.h"
 #include "sphin_spectral_property.h"
 
 #include <rsys/mem_allocator.h>
 #include <rsys/ref_count.h>
 #include <rsys/str.h>
 #include <rsys/text_reader.h>
 
 /*******************************************************************************
  * Helper functions
  ******************************************************************************/
 static res_T
 refractive_index_create
   (struct sphin* sphin,
    struct sphin_refractive_index** out_refractive_index)
 {
   struct sphin_refractive_index* refr_ind = NULL;
   res_T res = RES_OK;
 
   ASSERT(NULL != out_refractive_index);
   ASSERT(NULL != sphin);
 
   refr_ind = MEM_CALLOC
     (sphin->allocator, 1, sizeof(struct sphin_refractive_index));
   if (NULL == refr_ind) { res = RES_MEM_ERR; goto error; }
   ref_init(&refr_ind->ref);
   SPHIN(ref_get(sphin));
   refr_ind->sphin = sphin;
   refr_ind->n_real = NULL;
   refr_ind->n_imag = NULL;
 
 exit:
   *out_refractive_index = refr_ind;
   return res;
 error:
   if (NULL != refr_ind) {
     SPHIN(refractive_index_ref_put(refr_ind));
     refr_ind = NULL;
   }
   goto exit;
 }
 
 static void
 release_refractive_index
   (ref_T* address)
 {
   struct sphin_refractive_index* refr_ind = NULL;
   struct sphin* sphin  = NULL;
 
   ASSERT(NULL != address);
 
   refr_ind = CONTAINER_OF(address, struct sphin_refractive_index, ref);
   sphin = refr_ind->sphin;
   if (NULL != refr_ind->n_real) {
     SPHIN(spectral_property_ref_put(refr_ind->n_real));
   }
   if (NULL != refr_ind->n_imag) {
     SPHIN(spectral_property_ref_put(refr_ind->n_imag));
   }
   sphin = refr_ind->sphin;
   MEM_RM(sphin->allocator, refr_ind);
   SPHIN(ref_put(sphin));
 }
 
 /*******************************************************************************
  * Local functions
  ******************************************************************************/
 res_T
 parse_refractive_index
   (struct sphin* sphin,
    struct txtrdr* txtrdr,
    struct sphin_refractive_index** out_refractive_index)
 {
   char* token = NULL;
   char* token_ptr = NULL;
   char* keyword = NULL;
   char* filename = NULL;
   struct sphin_refractive_index* refr_ind = NULL;
   struct str line;
   res_T res = RES_OK;
 
   ASSERT(NULL != sphin);
   ASSERT(NULL != txtrdr);
   ASSERT(NULL != out_refractive_index);
 
   str_init(sphin->allocator, &line);
 
   res = refractive_index_create(sphin, &refr_ind);
   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; }
 
     token = strtok_r(str_get(&line), ":", &token_ptr);
     if (NULL == token){ res = RES_BAD_ARG; goto error; }
     keyword = trim_keyword(token);
     filename = trim_keyword(token_ptr);
 
     if (0 == strcmp(keyword, "n_real")) {
       res = parse_spectral_property(sphin, filename, &refr_ind->n_real);
       if (RES_OK != res) { goto error; }
       res = txtrdr_read_line(txtrdr);
       if (RES_OK != res) { goto error; }
     }
     else if (0 == strcmp(keyword, "n_imag")) {
       res = parse_spectral_property(sphin, filename, &refr_ind->n_imag);
       if (RES_OK != res) { goto error; }
       res = txtrdr_read_line(txtrdr);
       if (RES_OK != res) { goto error; }
     }
     else {
       break;
     }
   }
 
 exit:
   str_release(&line);
   *out_refractive_index = refr_ind;
   return res;
 error:
   if (NULL != refr_ind) {
     SPHIN(refractive_index_ref_put(refr_ind));
   }
   refr_ind = NULL;
   goto exit;
 }
 
 /*******************************************************************************
  * Exported functions
  ******************************************************************************/
 res_T
 sphin_refractive_index_ref_get
   (struct sphin_refractive_index* refr_ind)
 {
   if (NULL == refr_ind) {
     return RES_BAD_ARG;
   }
   ref_get(&refr_ind->ref);
   return RES_OK;
 }
 
 res_T
 sphin_refractive_index_ref_put
   (struct sphin_refractive_index* refr_ind)
 {
   if (NULL == refr_ind) {
     return RES_BAD_ARG;
   }
   ref_put(&refr_ind->ref, release_refractive_index);
   return RES_OK;
 }
 
 res_T
 sphin_refractive_index_get_n_real
   (struct sphin_refractive_index* refr_ind,
    struct sphin_spectral_property** n_real)
 {
   if (NULL == refr_ind || NULL == n_real) {
     return RES_BAD_ARG;
   }
   *n_real = refr_ind->n_real;
   return RES_OK;
 }
 
 res_T
 sphin_refractive_index_get_n_imag
   (struct sphin_refractive_index* refr_ind,
    struct sphin_spectral_property** n_imag)
 {
   if (NULL == refr_ind || NULL == n_imag) {
     return RES_BAD_ARG;
   }
   *n_imag = refr_ind->n_imag;
   return RES_OK;
 }