hkl/hkl-binding.c

   1 /* This file is part of the hkl library.
   2  *
   3  * The hkl library is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * The hkl library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with the hkl library.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright (C) 2012-2016 Synchrotron SOLEIL
  17  *                         L'Orme des Merisiers Saint-Aubin
  18  *                         BP 48 91192 GIF-sur-YVETTE CEDEX
  19  *
  20  * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
  21  */
  22
  23 #include <stdlib.h>                     // for malloc
  24 #include <string.h>                     // for NULL, strdup
  25 #include <sys/types.h>                  // for uint
  26 #include "hkl-factory-private.h"        // for __start_xautodata_factories, etc
  27 #include "hkl-geometry-private.h"       // for _HklGeometry, etc
  28 #include "hkl-parameter-private.h"
  29 #include "hkl-pseudoaxis-private.h"     // for _HklEngine, HklEngineInfo
  30 #include "hkl-sample-private.h"         // for _HklSampleReflection, etc
  31 #include "hkl.h"                        // for HklGeometry, HklEngine, etc
  32 #include "hkl/ccan/autodata/autodata.h"  // for autodata_get
  33 #include "hkl/ccan/darray/darray.h"     // for darray_foreach, darray_size
  34 #include "hkl/ccan/list/list.h"             // for list_for_each, list_head
  35
  36 /**************/
  37 /* HklFactory */
  38 /**************/
  39
  40 /**
  41  * hkl_factories:
  42  *
  43  * return all the Hkl factories objects as a dictionnary
  44  *
  45  * Returns: (element-type utf8 Hkl.Factory) (transfer container):
  46  **/
  47 GHashTable *hkl_factories(void)
  48 {
  49         GHashTable *table = NULL;
  50         size_t i, n;
  51         HklFactory **factories;
  52
  53         table = g_hash_table_new(g_str_hash, g_str_equal);
  54         factories = autodata_get(factories, &n);
  55         for(i=0; i<n; ++i){
  56                 g_hash_table_insert(table,
  57                                     (gpointer)hkl_factory_name_get(factories[i]),
  58                                     factories[i]);
  59         }
  60
  61         return table;
  62 }
  63
  64 /************/
  65 /* Geometry */
  66 /************/
  67
  68 /**
  69  * hkl_geometry_axis_names_get_binding:
  70  * @self: the this ptr
  71  * @length: (out caller-allocates): the length of the returned array
  72  *
  73  * get all the axes of the given geometry.
  74  *
  75  * Rename to: hkl_geometry_axis_names_get
  76  *
  77  * Returns: (array length=length) (transfer none): array of the axes names.
  78  **/
  79 const char **hkl_geometry_axis_names_get_binding(const HklGeometry *self,
  80                                                  size_t *length)
  81 {
  82         const darray_string *axes = hkl_geometry_axis_names_get(self);
  83
  84         *length = darray_size(*axes);
  85
  86         return &darray_item(*axes, 0);
  87 }
  88
  89 /**
  90  * hkl_geometry_axis_values_get_binding:
  91  * @self: the this ptr
  92  * @len: (out caller-allocates): the length of the returned array
  93  * @unit_type: the unit type (default or user) of the returned value
  94  *
  95  * Rename to: hkl_geometry_axis_values_get
  96  *
  97  * Return value: (array length=len) (transfer container): list of axes values,
  98  *          free the list with free when done.
  99  **/
 100 double *hkl_geometry_axis_values_get_binding(const HklGeometry *self, guint *len,
 101                                              HklUnitEnum unit_type)
 102 {
 103         double *values;
 104         uint i = 0;
 105         HklParameter **axis;
 106
 107         if(!self || !len || darray_size(self->axes) == 0)
 108                 return NULL;
 109
 110         *len = darray_size(self->axes);
 111         values = malloc(darray_size(self->axes) * sizeof(*values));
 112
 113         darray_foreach(axis, self->axes){
 114                 values[i++] = hkl_parameter_value_get(*axis, unit_type);
 115         }
 116
 117         return values;
 118 }
 119
 120 /*******************/
 121 /* HklGeometryList */
 122 /*******************/
 123
 124 /**
 125  * hkl_geometry_list_items:
 126  * @self: the #HklGeometryList
 127  *
 128  * Return value: (element-type HklGeometryListItem) (transfer container): list of items,
 129  *               free the list with g_slist_free when done.
 130  **/
 131 GSList* hkl_geometry_list_items(HklGeometryList *self)
 132 {
 133         GSList *list = NULL;
 134         HklGeometryListItem *item;
 135
 136         list_for_each(&self->items, item, list)
 137                 list = g_slist_append(list, item);
 138
 139         return list;
 140 }
 141
 142 /*************/
 143 /* HklEngine */
 144 /*************/
 145
 146 /**
 147  * hkl_engine_modes_names_get_binding:
 148  * @self: the this ptr
 149  * @length: (out caller-allocates): return the length of the returned array.
 150  *
 151  * Rename to: hkl_engine_modes_names_get
 152  *
 153  * Return value: (array length=length) (transfer none): All the modes supported by the #HklEngine
 154  **/
 155 const char **hkl_engine_modes_names_get_binding(const HklEngine *self, size_t *length)
 156 {
 157         *length = darray_size(self->mode_names);
 158         return &darray_item(self->mode_names, 0);
 159 }
 160
 161 /**
 162  * hkl_engine_pseudo_axis_names_get_binding:
 163  * @self: the this ptr
 164  * @length: (out caller-allocates): return the length of the returned array.
 165  *
 166  * Rename to: hkl_engine_pseudo_axis_names_get
 167  *
 168  * Return value: (array length=length) (transfer none): All the pseudo_axes names of the #HklEngine
 169  *
 170  **/
 171 const char **hkl_engine_pseudo_axis_names_get_binding(HklEngine *self, size_t *length)
 172 {
 173         *length = darray_size(self->pseudo_axis_names);
 174         return &darray_item(self->pseudo_axis_names, 0);
 175 }
 176
 177 /**
 178  * hkl_engine_parameters_names_get_binding:
 179  * @self: the this ptr
 180  * @length: (out caller-allocates): return the length of the returned array.
 181  *
 182  * Rename to: hkl_engine_parameters_names_get
 183  *
 184  * Return value: (array length=length) (transfer none): All the parameters of #HklEngine.
 185  **/
 186 const char **hkl_engine_parameters_names_get_binding(const HklEngine *self, size_t *length)
 187 {
 188         *length = darray_size(self->mode->parameters_names);
 189         return &darray_item(self->mode->parameters_names, 0);
 190 }
 191
 192 /**
 193  * hkl_engine_axis_names_get_binding:
 194  * @self: the this ptr
 195  * @mode: the #HklEngineAxesNamesGet
 196  * @length: (out caller-allocates): return the length of the returned array.
 197  *
 198  * Rename to: hkl_engine_axis_names_get
 199  *
 200  * Return value: (array length=length) (transfer none): axes of the #HklEngine for the given mode.
 201  **/
 202 const char **hkl_engine_axis_names_get_binding(const HklEngine *self,
 203                                                HklEngineAxisNamesGet mode,
 204                                                size_t *length)
 205 {
 206         const darray_string *axes = hkl_engine_axis_names_get(self, mode);
 207
 208         *length = darray_size(*axes);
 209
 210         return &darray_item(*axes, 0);
 211 }
 212
 213 /**
 214  * hkl_engine_parameters_values_get_binding:
 215  * @self: the this ptr
 216  * @len: (out caller-allocates): the length of the returned array
 217  * @unit_type: the unit type (default or user) of the returned value
 218  *
 219  * Rename to: hkl_engine_parameters_values_get
 220  *
 221  * Return value: (array length=len) (transfer container): list of parameters values,
 222  *          free the list with free when done.
 223  **/
 224 double *hkl_engine_parameters_values_get_binding(const HklEngine *self, guint *len,
 225                                                  HklUnitEnum unit_type)
 226 {
 227         double *values;
 228         uint i = 0;
 229         HklParameter **parameter;
 230
 231         if(!self || !len || !self->mode || darray_size(self->mode->parameters) == 0)
 232                 return NULL;
 233
 234         *len = darray_size(self->mode->parameters);
 235         values = malloc(*len * sizeof(*values));
 236
 237         darray_foreach(parameter, self->mode->parameters){
 238                 values[i++] = hkl_parameter_value_get(*parameter, unit_type);
 239         }
 240
 241         return values;
 242 }
 243
 244 /**
 245  * hkl_engine_pseudo_axis_values_get_binding:
 246  * @self: the this ptr
 247  * @len: (out caller-allocates): the length of the returned array
 248  * @unit_type: the unit type (default or user) of the returned value
 249  *
 250  * Rename to: hkl_engine_pseudo_axis_values_get
 251  *
 252  * Return value: (array length=len) (transfer container): list of pseudo axes values,
 253  *          free the list with free when done.
 254  **/
 255 double *hkl_engine_pseudo_axis_values_get_binding(const HklEngine *self, guint *len,
 256                                                   HklUnitEnum unit_type)
 257 {
 258         double *values;
 259         uint i = 0;
 260         HklParameter **axis;
 261
 262         if(!self || !len || darray_size(self->pseudo_axes) == 0)
 263                 return NULL;
 264
 265         *len = darray_size(self->pseudo_axes);
 266         values = malloc(darray_size(self->pseudo_axes) * sizeof(*values));
 267
 268         darray_foreach(axis, self->pseudo_axes){
 269                 values[i++] = hkl_parameter_value_get(*axis, unit_type);
 270         }
 271
 272         return values;
 273 }
 274
 275 /**
 276  * hkl_engine_list_engines_get_as_gslist:
 277  * @self: the this ptr
 278  *
 279  * Return value: (element-type HklEngine) (transfer container): list of engines,
 280  *               free the list with g_slist_free when done.
 281  *
 282  * Rename to: hkl_engine_list_engines_get
 283  **/
 284 GSList* hkl_engine_list_engines_get_as_gslist(HklEngineList *self)
 285 {
 286         GSList *list = NULL;
 287         HklEngine **engine;
 288
 289         darray_foreach(engine, *self){
 290                 list = g_slist_append(list, *engine);
 291         }
 292
 293         return list;
 294 }
 295
 296 /*************/
 297 /* HklSample */
 298 /*************/
 299
 300 /**
 301  * hkl_sample_reflections_get:
 302  * @self: the this ptr
 303  *
 304  * Return value: (element-type HklSampleReflection) (transfer container): list of reflections,
 305  *               free the list with g_slist_free when done.
 306  */
 307 GSList *hkl_sample_reflections_get(const HklSample *self)
 308 {
 309         GSList *list = NULL;
 310         HklSampleReflection *reflection;
 311
 312         list_for_each(&self->reflections, reflection, list){
 313                 list = g_slist_append(list, reflection);
 314         }
 315
 316         return list;
 317 }
 318
 319 /**
 320  * hkl_sample_add_reflection_binding:
 321  * @self: the this ptr
 322  * @geometry: the geometry of the HklSampleReflection
 323  * @detector: the detector of the HklSampleReflection
 324  * @h: the h coordinate
 325  * @k: the k coordinate
 326  * @l: the l coordinate
 327  * @error: return location for a GError, or NULL
 328  *
 329  * Return value: (transfer none): the newly created HklSampleReflection
 330  *
 331  * Rename to: hkl_sample_add_reflection
 332  **/
 333 HklSampleReflection *hkl_sample_add_reflection_binding(HklSample *self,
 334                                                        const HklGeometry *geometry,
 335                                                        const HklDetector *detector,
 336                                                        double h, double k, double l,
 337                                                        GError **error)
 338 {
 339         HklSampleReflection *reflection;
 340
 341         hkl_error (error == NULL || *error == NULL);
 342
 343         reflection = hkl_sample_reflection_new(geometry, detector,
 344                                                h, k, l, error);
 345         if(!reflection){
 346                 g_assert (error == NULL || *error != NULL);
 347                 return NULL;
 348         }
 349         g_assert (error == NULL || *error == NULL);
 350
 351         hkl_sample_add_reflection(self, reflection);
 352
 353         return reflection;
 354 }