hkl/hkl-types.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) 2011      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 #include <hkl/hkl-types.h>
  23 #include <hkl/hkl-pseudoaxis-private.h>
  24
  25 GType hkl_error_get_type (void) {
  26         static volatile gsize hkl_error_type_id__volatile = 0;
  27         if (g_once_init_enter (&hkl_error_type_id__volatile)) {
  28                 GType hkl_error_type_id;
  29                 hkl_error_type_id = g_boxed_type_register_static ("HklError",
  30                                                                   (GBoxedCopyFunc) hkl_error_new_copy,
  31                                                                   (GBoxedFreeFunc) hkl_error_free);
  32                 g_once_init_leave (&hkl_error_type_id__volatile, hkl_error_type_id);
  33         }
  34         return hkl_error_type_id__volatile;
  35 }
  36
  37 GType hkl_vector_get_type (void) {
  38         static volatile gsize hkl_vector_type_id__volatile = 0;
  39         if (g_once_init_enter (&hkl_vector_type_id__volatile)) {
  40                 GType hkl_vector_type_id;
  41                 hkl_vector_type_id = g_boxed_type_register_static ("HklVector",
  42                                                                    (GBoxedCopyFunc) hkl_vector_dup,
  43                                                                    (GBoxedFreeFunc) hkl_vector_free);
  44                 g_once_init_leave (&hkl_vector_type_id__volatile, hkl_vector_type_id);
  45         }
  46         return hkl_vector_type_id__volatile;
  47 }
  48
  49 GType hkl_matrix_get_type (void) {
  50         static volatile gsize hkl_matrix_type_id__volatile = 0;
  51         if (g_once_init_enter (&hkl_matrix_type_id__volatile)) {
  52                 GType hkl_matrix_type_id;
  53                 hkl_matrix_type_id = g_boxed_type_register_static ("HklMatrix",
  54                                                                    (GBoxedCopyFunc) hkl_matrix_dup,
  55                                                                    (GBoxedFreeFunc) hkl_matrix_free);
  56                 g_once_init_leave (&hkl_matrix_type_id__volatile, hkl_matrix_type_id);
  57         }
  58         return hkl_matrix_type_id__volatile;
  59 }
  60
  61 GType hkl_quaternion_get_type (void) {
  62         static volatile gsize hkl_quaternion_type_id__volatile = 0;
  63         if (g_once_init_enter (&hkl_quaternion_type_id__volatile)) {
  64                 GType hkl_quaternion_type_id;
  65                 hkl_quaternion_type_id = g_boxed_type_register_static ("HklQuaternion",
  66                                                                        (GBoxedCopyFunc) hkl_quaternion_dup,
  67                                                                        (GBoxedFreeFunc) hkl_quaternion_free);
  68                 g_once_init_leave (&hkl_quaternion_type_id__volatile, hkl_quaternion_type_id);
  69         }
  70         return hkl_quaternion_type_id__volatile;
  71 }
  72
  73 GType hkl_unit_get_type (void) {
  74         static volatile gsize hkl_unit_type_id__volatile = 0;
  75         if (g_once_init_enter (&hkl_unit_type_id__volatile)) {
  76                 GType hkl_unit_type_id;
  77                 hkl_unit_type_id = g_boxed_type_register_static ("HklUnit",
  78                                                                  (GBoxedCopyFunc) hkl_unit_dup,
  79                                                                  (GBoxedFreeFunc) hkl_unit_free);
  80                 g_once_init_leave (&hkl_unit_type_id__volatile, hkl_unit_type_id);
  81         }
  82         return hkl_unit_type_id__volatile;
  83 }
  84
  85 GType hkl_interval_get_type (void) {
  86         static volatile gsize hkl_interval_type_id__volatile = 0;
  87         if (g_once_init_enter (&hkl_interval_type_id__volatile)) {
  88                 GType hkl_interval_type_id;
  89                 hkl_interval_type_id = g_boxed_type_register_static ("HklInterval",
  90                                                                      (GBoxedCopyFunc) hkl_interval_dup,
  91                                                                      (GBoxedFreeFunc) hkl_interval_free);
  92                 g_once_init_leave (&hkl_interval_type_id__volatile, hkl_interval_type_id);
  93         }
  94         return hkl_interval_type_id__volatile;
  95 }
  96
  97 GType hkl_parameter_get_type (void) {
  98         static volatile gsize hkl_parameter_type_id__volatile = 0;
  99         if (g_once_init_enter (&hkl_parameter_type_id__volatile)) {
 100                 GType hkl_parameter_type_id;
 101                 hkl_parameter_type_id = g_boxed_type_register_static ("HklParameter",
 102                                                                       (GBoxedCopyFunc) hkl_parameter_new_copy,
 103                                                                       (GBoxedFreeFunc) hkl_parameter_free);
 104                 g_once_init_leave (&hkl_parameter_type_id__volatile, hkl_parameter_type_id);
 105         }
 106         return hkl_parameter_type_id__volatile;
 107 }
 108
 109 static HklEngine* hkl_parameter_list_fake_ref(HklEngine *src)
 110 {
 111         return src;
 112 }
 113
 114 static void hkl_parameter_list_fake_unref(HklEngine *src)
 115 {
 116         return;
 117 }
 118
 119 GType hkl_parameter_list_get_type (void) {
 120         static volatile gsize hkl_parameter_list_type_id__volatile = 0;
 121         if (g_once_init_enter (&hkl_parameter_list_type_id__volatile)) {
 122                 GType hkl_parameter_list_type_id;
 123                 hkl_parameter_list_type_id = g_boxed_type_register_static ("HklParameterList",
 124                                                                            (GBoxedCopyFunc) hkl_parameter_list_fake_ref,
 125                                                                            (GBoxedFreeFunc) hkl_parameter_list_fake_unref);
 126                 g_once_init_leave (&hkl_parameter_list_type_id__volatile, hkl_parameter_list_type_id);
 127         }
 128         return hkl_parameter_list_type_id__volatile;
 129 }
 130
 131 GType hkl_axis_get_type (void) {
 132         static volatile gsize hkl_axis_type_id__volatile = 0;
 133         if (g_once_init_enter (&hkl_axis_type_id__volatile)) {
 134                 GType hkl_axis_type_id;
 135                 hkl_axis_type_id = g_boxed_type_register_static ("HklAxis",
 136                                                                  (GBoxedCopyFunc) hkl_parameter_new_copy,
 137                                                                  (GBoxedFreeFunc) hkl_parameter_free);
 138                 g_once_init_leave (&hkl_axis_type_id__volatile, hkl_axis_type_id);
 139         }
 140         return hkl_axis_type_id__volatile;
 141 }
 142
 143 GType hkl_source_get_type (void) {
 144         static volatile gsize hkl_source_type_id__volatile = 0;
 145         if (g_once_init_enter (&hkl_source_type_id__volatile)) {
 146                 GType hkl_source_type_id;
 147                 hkl_source_type_id = g_boxed_type_register_static ("HklSource",
 148                                                                    (GBoxedCopyFunc) hkl_source_dup,
 149                                                                    (GBoxedFreeFunc) hkl_source_free);
 150                 g_once_init_leave (&hkl_source_type_id__volatile, hkl_source_type_id);
 151         }
 152         return hkl_source_type_id__volatile;
 153 }
 154
 155 GType hkl_geometry_get_type (void) {
 156         static volatile gsize hkl_geometry_type_id__volatile = 0;
 157         if (g_once_init_enter (&hkl_geometry_type_id__volatile)) {
 158                 GType hkl_geometry_type_id;
 159                 hkl_geometry_type_id = g_boxed_type_register_static ("HklGeometry",
 160                                                                      (GBoxedCopyFunc) hkl_geometry_new_copy,
 161                                                                      (GBoxedFreeFunc) hkl_geometry_free);
 162                 g_once_init_leave (&hkl_geometry_type_id__volatile, hkl_geometry_type_id);
 163         }
 164         return hkl_geometry_type_id__volatile;
 165 }
 166
 167 GType hkl_geometry_list_item_get_type (void) {
 168         static volatile gsize hkl_geometry_list_item_type_id__volatile = 0;
 169         if (g_once_init_enter (&hkl_geometry_list_item_type_id__volatile)) {
 170                 GType hkl_geometry_list_item_type_id;
 171                 hkl_geometry_list_item_type_id = g_boxed_type_register_static ("HklGeometryListItem",
 172                                                                                (GBoxedCopyFunc) hkl_geometry_list_item_new_copy,
 173                                                                                (GBoxedFreeFunc) hkl_geometry_list_item_free);
 174                 g_once_init_leave (&hkl_geometry_list_item_type_id__volatile, hkl_geometry_list_item_type_id);
 175         }
 176         return hkl_geometry_list_item_type_id__volatile;
 177 }
 178
 179 GType hkl_geometry_list_get_type (void) {
 180         static volatile gsize hkl_geometry_list_type_id__volatile = 0;
 181         if (g_once_init_enter (&hkl_geometry_list_type_id__volatile)) {
 182                 GType hkl_geometry_list_type_id;
 183                 hkl_geometry_list_type_id = g_boxed_type_register_static ("HklGeometryList",
 184                                                                           (GBoxedCopyFunc) hkl_geometry_list_new_copy,
 185                                                                           (GBoxedFreeFunc) hkl_geometry_list_free);
 186                 g_once_init_leave (&hkl_geometry_list_type_id__volatile, hkl_geometry_list_type_id);
 187         }
 188         return hkl_geometry_list_type_id__volatile;
 189 }
 190
 191 GType hkl_detector_get_type (void) {
 192         static volatile gsize hkl_detector_type_id__volatile = 0;
 193         if (g_once_init_enter (&hkl_detector_type_id__volatile)) {
 194                 GType hkl_detector_type_id;
 195                 hkl_detector_type_id = g_boxed_type_register_static ("HklDetector",
 196                                                                      (GBoxedCopyFunc) hkl_detector_new_copy,
 197                                                                      (GBoxedFreeFunc) hkl_detector_free);
 198                 g_once_init_leave (&hkl_detector_type_id__volatile, hkl_detector_type_id);
 199         }
 200         return hkl_detector_type_id__volatile;
 201 }
 202
 203 GType hkl_lattice_get_type (void) {
 204         static volatile gsize hkl_lattice_type_id__volatile = 0;
 205         if (g_once_init_enter (&hkl_lattice_type_id__volatile)) {
 206                 GType hkl_lattice_type_id;
 207                 hkl_lattice_type_id = g_boxed_type_register_static ("HklLattice",
 208                                                                     (GBoxedCopyFunc) hkl_lattice_new_copy,
 209                                                                     (GBoxedFreeFunc) hkl_lattice_free);
 210                 g_once_init_leave (&hkl_lattice_type_id__volatile, hkl_lattice_type_id);
 211         }
 212         return hkl_lattice_type_id__volatile;
 213 }
 214
 215 GType hkl_sample_reflection_get_type (void) {
 216         static volatile gsize hkl_sample_reflection_type_id__volatile = 0;
 217         if (g_once_init_enter (&hkl_sample_reflection_type_id__volatile)) {
 218                 GType hkl_sample_reflection_type_id;
 219                 hkl_sample_reflection_type_id = g_boxed_type_register_static ("HklSampleReflection",
 220                                                                               (GBoxedCopyFunc) hkl_sample_reflection_new_copy,
 221                                                                               (GBoxedFreeFunc) hkl_sample_reflection_free);
 222                 g_once_init_leave (&hkl_sample_reflection_type_id__volatile, hkl_sample_reflection_type_id);
 223         }
 224         return hkl_sample_reflection_type_id__volatile;
 225 }
 226
 227 GType hkl_sample_get_type (void) {
 228         static volatile gsize hkl_sample_type_id__volatile = 0;
 229         if (g_once_init_enter (&hkl_sample_type_id__volatile)) {
 230                 GType hkl_sample_type_id;
 231                 hkl_sample_type_id = g_boxed_type_register_static ("HklSample",
 232                                                                    (GBoxedCopyFunc) hkl_sample_new_copy,
 233                                                                    (GBoxedFreeFunc) hkl_sample_free);
 234                 g_once_init_leave (&hkl_sample_type_id__volatile, hkl_sample_type_id);
 235         }
 236         return hkl_sample_type_id__volatile;
 237 }
 238
 239 GType hkl_sample_list_get_type (void) {
 240         static volatile gsize hkl_sample_list_type_id__volatile = 0;
 241         if (g_once_init_enter (&hkl_sample_list_type_id__volatile)) {
 242                 GType hkl_sample_list_type_id;
 243                 hkl_sample_list_type_id = g_boxed_type_register_static ("HklSampleList",
 244                                                                         (GBoxedCopyFunc) hkl_sample_list_new_copy,
 245                                                                         (GBoxedFreeFunc) hkl_sample_list_free);
 246                 g_once_init_leave (&hkl_sample_list_type_id__volatile, hkl_sample_list_type_id);
 247         }
 248         return hkl_sample_list_type_id__volatile;
 249 }
 250
 251 GType hkl_pseudo_axis_get_type (void) {
 252         static volatile gsize hkl_pseudo_axis_type_id__volatile = 0;
 253         if (g_once_init_enter (&hkl_pseudo_axis_type_id__volatile)) {
 254                 GType hkl_pseudo_axis_type_id;
 255                 hkl_pseudo_axis_type_id = g_boxed_type_register_static ("HklPseudoAxis",
 256                                                                         (GBoxedCopyFunc) hkl_parameter_new_copy,
 257                                                                         (GBoxedFreeFunc) hkl_parameter_free);
 258                 g_once_init_leave (&hkl_pseudo_axis_type_id__volatile, hkl_pseudo_axis_type_id);
 259         }
 260         return hkl_pseudo_axis_type_id__volatile;
 261 }
 262
 263 static HklEngine* hkl_engine_fake_ref(HklEngine *src)
 264 {
 265         return src;
 266 }
 267
 268 static void hkl_engine_fake_unref(HklEngine *src)
 269 {
 270         return;
 271 }
 272
 273 GType hkl_engine_get_type (void) {
 274         static volatile gsize hkl_engine_type_id__volatile = 0;
 275         if (g_once_init_enter (&hkl_engine_type_id__volatile)) {
 276                 GType hkl_engine_type_id;
 277                 hkl_engine_type_id = g_boxed_type_register_static (
 278                         "HklEngine",
 279                         (GBoxedCopyFunc) hkl_engine_fake_ref,
 280                         (GBoxedFreeFunc) hkl_engine_fake_unref);
 281                 g_once_init_leave (&hkl_engine_type_id__volatile, hkl_engine_type_id);
 282         }
 283         return hkl_engine_type_id__volatile;
 284 }
 285
 286 GType hkl_engine_list_get_type (void) {
 287         static volatile gsize hkl_engine_list_type_id__volatile = 0;
 288         if (g_once_init_enter (&hkl_engine_list_type_id__volatile)) {
 289                 GType hkl_engine_list_type_id;
 290                 hkl_engine_list_type_id = g_boxed_type_register_static (
 291                         "HklEngineList",
 292                         (GBoxedCopyFunc) hkl_engine_list_new_copy,
 293                         (GBoxedFreeFunc) hkl_engine_list_free);
 294                 g_once_init_leave (&hkl_engine_list_type_id__volatile, hkl_engine_list_type_id);
 295         }
 296         return hkl_engine_list_type_id__volatile;
 297 }